Add history and multiple messages

hello-world/app.py

@@ -3,10 +3,12 @@ from fastapi.middleware.cors import CORSMiddleware
 import gradio as gr
 import uvicorn
 import asyncio
+import threading
+import os
+from dotenv import load_dotenv
 
 app = FastAPI()
 
-# Allow Blockly (running on localhost:8080) to connect
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["http://localhost:8080", "http://127.0.0.1:8080"],
@@ -15,19 +17,21 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Authoritative chat history (the one true state)
-history = []
+load_dotenv()
 
-# Live Python code string generated from Blockly
+history = []
 latest_blockly_code = ""
-
-# A queue for assistant replies (so Gradio waits until Blockly has responded)
 assistant_queue = asyncio.Queue()
 
 
+async def reply(message):
+    global history, assistant_queue
+    history.append({"role": "assistant", "content": message})
+    await assistant_queue.put(message)
+
+
 @app.post("/update_code")
 async def update_code(request: Request):
-    """Receives live Python code generated by Blockly."""
     global latest_blockly_code
     data = await request.json()
     latest_blockly_code = data.get("code", "")
@@ -35,59 +39,59 @@ async def update_code(request: Request):
     return {"ok": True}
 
 
-def execute_blockly_logic(user_message: str) -> str:
-    """
-    Executes the latest Blockly-generated Python code in a controlled environment.
-    Expects the Blockly code to define a function called on_user_send(user_message)
-    that returns or prints the assistant reply.
-    """
-    global latest_blockly_code
-
+def execute_blockly_logic(user_message: str, loop):
+    global latest_blockly_code, history
     if not latest_blockly_code.strip():
-        print("[EXECUTION] No Blockly code yet.")
-        return "(no logic yet)"
+        return
+
+    def safe_reply(msg):
+        asyncio.run_coroutine_threadsafe(reply(msg), loop)
+
+    env = {
+        "reply": safe_reply,
+        "history": history,
+        "print": print,
+    }
 
     try:
-        local_vars = {}
-        # Execute the code safely (creates function definitions, etc.)
-        exec(latest_blockly_code, {}, local_vars)
-        # Call the defined handler function, if it exists
-        if "on_user_send" in local_vars:
-            result = local_vars["on_user_send"](user_message)
-            if result is None:
-                result = "(no reply)"
-            return str(result)
-        else:
-            print("[EXECUTION] No on_user_send() found in Blockly code.")
-            return "(missing on_user_send)"
+        exec(latest_blockly_code, env)
+        if "on_user_send" in env:
+            env["on_user_send"](user_message)
     except Exception as e:
         print("[EXECUTION ERROR]", e)
-        return f"(error: {e})"
+
+
+def run_blockly_thread(user_message):
+    loop = asyncio.get_running_loop()
+    thread = threading.Thread(target=execute_blockly_logic, args=(user_message, loop))
+    thread.start()
 
 
 def build_interface():
     with gr.Blocks() as demo:
-        chatbot = gr.Chatbot(type="messages", label="Assistant")
+        chatbot = gr.Chatbot(type="messages", label="Assistant", group_consecutive_messages=False)
         msg = gr.Textbox(placeholder="Type a message and press Enter")
 
         async def process_message(message):
-            global history
-
-            # 1. Add user message
+            global history, assistant_queue
             history.append({"role": "user", "content": message})
             print(f"[USER] {message!r}")
             yield "", history
 
-            # 2. Compute assistant response using current Blockly logic
-            assistant_text = execute_blockly_logic(message)
-            print(f"[ASSISTANT] {assistant_text!r}")
+            while not assistant_queue.empty():
+                assistant_queue.get_nowait()
 
-            # 3. Add assistant message
-            history.append({"role": "assistant", "content": assistant_text})
-            yield "", history
+            run_blockly_thread(message)
 
-        msg.submit(process_message, [msg], [msg, chatbot], queue=True)
+            while True:
+                try:
+                    reply_text = await asyncio.wait_for(assistant_queue.get(), timeout=2)
+                    print(f"[ASSISTANT STREAM] {reply_text!r}")
+                    yield "", history
+                except asyncio.TimeoutError:
+                    break
 
+        msg.submit(process_message, [msg], [msg, chatbot], queue=True)
         clear_btn = gr.Button("Reset chat")
         clear_btn.click(lambda: ([], ""), None, [chatbot, msg], queue=False)
 

hello-world/src/blocks/text.js

@@ -8,7 +8,7 @@ import * as Blockly from 'blockly/core';
 
 const whenUserSends = {
   type: 'when_user_sends',
-  message0: 'When user sends msg do %1 %2',
+  message0: 'when user sends message do %1 %2',
   args0: [
     {
       "type": "input_dummy"
@@ -26,7 +26,7 @@ const whenUserSends = {
 
 const assistantReply = {
   type: 'assistant_reply',
-  message0: 'Reply with %1',
+  message0: 'reply with %1',
   args0: [
     {
       type: 'input_value',
@@ -41,7 +41,41 @@ const assistantReply = {
   helpUrl: '',
 };
 
+const getAssistantResponse = {
+  type: 'get_assistant_response',
+  message0: 'call model %1 with prompt %2 with %3',
+  args0: [
+    {
+      type: 'field_dropdown',
+      name: 'MODEL',
+      options: [
+        ['gpt-3.5-turbo', 'gpt-3.5-turbo-0125'],
+        ['gpt-5-mini', 'gpt-5-mini-2025-08-07'],
+      ],
+    },
+    {
+      type: 'input_value',
+      name: 'PROMPT',
+      check: 'String',
+    },
+    {
+      type: 'field_dropdown',
+      name: 'HISTORY',
+      options: [
+        ["history", "True"],
+        ["no history", "False"]
+      ]
+    },
+  ],
+  inputsInline: true,
+  output: 'String',
+  colour: 230,
+  tooltip: 'Call the selected OpenAI model to get a response.',
+  helpUrl: '',
+};
+
 export const blocks = Blockly.common.createBlockDefinitionsFromJsonArray([
   whenUserSends,
   assistantReply,
+  getAssistantResponse,
 ]);

hello-world/src/generators/python.js

@@ -5,13 +5,22 @@ export const forBlock = Object.create(null);
 // Generates a Python function that runs when the user sends a message
 forBlock['when_user_sends'] = function (block, generator) {
   const body = generator.statementToCode(block, 'code') || "";
-  const code = `def on_user_send(user_message):\n${body}\n`;
+  const code = `def on_user_send(user_message):\n${body}  return\n`;
   return code;
 };
 
 // Generates a Python 'return' statement for the assistant's reply
 forBlock['assistant_reply'] = function (block, generator) {
   const reply = generator.valueToCode(block, 'INPUT', Order.NONE) || "''";
-  const code = `return ${reply}\n`;
+  const code = `reply(${reply})\n`;
   return code;
 };
+
+forBlock['get_assistant_response'] = function (block, generator) {
+  const model = block.getFieldValue('MODEL');
+  const prompt = generator.valueToCode(block, 'PROMPT', Order.NONE) || "''";
+  const history = block.getFieldValue('HISTORY');
+
+  const code = `get_assistant_response(${prompt}, model="${model}", use_history=${history})`;
+  return [code, Order.NONE];
+};

hello-world/src/index.css

@@ -22,7 +22,7 @@ body {
 #outputPane {
   display: flex;
   flex-direction: column;
-  width: 400px;
+  width: 600px;
   flex-shrink: 0;
   height: 100%;
   overflow: hidden;

hello-world/src/index.js

@@ -52,6 +52,10 @@ const ws = Blockly.inject(blocklyDiv, {
   theme: myTheme,
 });
 
+if (!ws.getVariable('user_message')) {
+  ws.createVariable('user_message');
+}
+
 ws.updateUserMessage = (message) => {
   let variable = ws.getVariable('user_message');
   if (!variable) ws.createVariable('user_message');
@@ -59,10 +63,34 @@ ws.updateUserMessage = (message) => {
   ws.variableValues['user_message'] = message;
 };
 
-const runCode = () => {
-  const code = pythonGenerator.workspaceToCode(ws);
+const updateCode = () => {
+  let code = pythonGenerator.workspaceToCode(ws);
   const codeEl = document.querySelector('#generatedCode code');
 
+  const response = `def get_assistant_response(prompt, model, use_history=True):
+  global history
+  from openai import OpenAI
+  import os
+
+  client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+  if use_history:
+      messages = history + [{"role": "user", "content": prompt}]
+  else:
+      messages = [{"role": "user", "content": prompt}]
+
+  completion = client.chat.completions.create(model=model, messages=messages)
+  return completion.choices[0].message.content.strip()
+  
+`;
+
+  const blocks = ws.getAllBlocks(false);
+  const hasResponse = blocks.some(block => block.type === 'assistant_reply');
+
+  if (hasResponse) {
+    code = response + code;
+  }
+
   if (codeEl) {
     codeEl.textContent = code;
   }
@@ -87,10 +115,15 @@ try {
   console.warn('Workspace load failed, clearing storage:', e);
   localStorage.clear();
 }
-runCode();
+updateCode();
 
 ws.addChangeListener((e) => {
   if (e.isUiEvent) return;
+
+  if (!ws.getVariable('user_message')) {
+    ws.createVariable('user_message');
+  }
+
   save(ws);
 });
 
@@ -98,7 +131,7 @@ ws.addChangeListener((e) => {
   if (e.isUiEvent || e.type == Blockly.Events.FINISHED_LOADING || ws.isDragging()) {
     return;
   }
-  runCode();
+  updateCode();
 });
 
 window.addEventListener("message", (event) => {

hello-world/src/toolbox.js

@@ -28,6 +28,23 @@ export const toolbox = {
           kind: 'block',
           type: 'assistant_reply',
         },
+        {
+          kind: 'block',
+          type: 'get_assistant_response',
+          inputs: {
+            PROMPT: {
+              shadow: {
+                type: "variables_get",
+                fields: {
+                  VAR: {
+                    name: "user_message",
+                    type: "String"
+                  }
+                }
+              }
+            },
+          },
+        },
       ]
     },
     {
@@ -190,10 +207,6 @@ export const toolbox = {
             },
           },
         },
-        {
-          kind: 'block',
-          type: 'math_constant',
-        },
         {
           kind: 'block',
           type: 'math_number_property',
@@ -225,13 +238,6 @@ export const toolbox = {
             },
           },
         },
-        {
-          kind: 'block',
-          type: 'math_on_list',
-          fields: {
-            OP: 'SUM',
-          },
-        },
         {
           kind: 'block',
           type: 'math_modulo',
@@ -306,10 +312,6 @@ export const toolbox = {
             },
           },
         },
-        {
-          kind: 'block',
-          type: 'math_random_float',
-        },
       ],
     },
     {

requirements.txt

@@ -1 +1,3 @@
-gradio
+gradio
+dotenv
+openai