Add MCP block and fix issues

project/app.py

@@ -2,9 +2,6 @@ from fastapi import FastAPI, Request
 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()
@@ -19,15 +16,7 @@ app.add_middleware(
 
 load_dotenv()
 
-history = []
 latest_blockly_code = ""
-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")
@@ -39,61 +28,120 @@ async def update_code(request: Request):
     return {"ok": True}
 
 
-def execute_blockly_logic(user_message: str, loop):
-    global latest_blockly_code, history
+def execute_blockly_logic(user_inputs):
+    global latest_blockly_code
     if not latest_blockly_code.strip():
-        return
+        return "No Blockly code available"
 
-    def safe_reply(msg):
-        asyncio.run_coroutine_threadsafe(reply(msg), loop)
+    result = ""
+    
+    def capture_result(msg):
+        nonlocal result
+        result = msg
 
     env = {
-        "reply": safe_reply,
-        "history": history,
-        "print": print,
+        "reply": capture_result,
     }
 
     try:
         exec(latest_blockly_code, env)
-        if "on_user_send" in env:
-            env["on_user_send"](user_message)
+        if "create_mcp" in env:
+            # If create_mcp function exists, call it with the input arguments
+            # Filter out None values and convert to list for unpacking
+            args = [arg for arg in user_inputs if arg is not None]
+            result = env["create_mcp"](*args)
+        elif "process_input" in env:
+            env["process_input"](user_inputs)
     except Exception as e:
         print("[EXECUTION ERROR]", e)
+        result = f"Error: {str(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()
+    return result if result else "No output generated"
 
 
 def build_interface():
     with gr.Blocks() as demo:
-        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, assistant_queue
-            history.append({"role": "user", "content": message})
-            print(f"[USER] {message!r}")
-            yield "", history
-
-            while not assistant_queue.empty():
-                assistant_queue.get_nowait()
-
-            run_blockly_thread(message)
-
-            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)
+        gr.Markdown("# Blockly Code Executor")
+        
+        # Create a fixed number of potential input fields (max 10)
+        input_fields = []
+        input_labels = []
+        input_group_items = []
+        
+        with gr.Accordion("MCP Inputs", open=True):
+            for i in range(10):
+                # Create inputs that can be shown/hidden
+                txt = gr.Textbox(label=f"Input {i+1}", visible=False)
+                input_fields.append(txt)
+                input_group_items.append(txt)
+        
+        output_text = gr.Textbox(label="Output", interactive=False)
+        
+        with gr.Row():
+            submit_btn = gr.Button("Submit")
+            refresh_btn = gr.Button("Refresh Inputs")
+
+        def refresh_inputs():
+            global latest_blockly_code
+            
+            # Parse the Python code to extract function parameters
+            import re
+            
+            # Look for the create_mcp function definition
+            pattern = r'def create_mcp\((.*?)\):'
+            match = re.search(pattern, latest_blockly_code)
+            
+            params = []
+            if match:
+                params_str = match.group(1)
+                if params_str.strip():
+                    # Parse parameters to extract names and types
+                    for param in params_str.split(','):
+                        param = param.strip()
+                        if ':' in param:
+                            name, type_hint = param.split(':')
+                            params.append({
+                                'name': name.strip(),
+                                'type': type_hint.strip()
+                            })
+                        else:
+                            params.append({
+                                'name': param,
+                                'type': 'str'
+                            })
+            
+            # Generate visibility and label updates for each input field
+            updates = []
+            for i, field in enumerate(input_fields):
+                if i < len(params):
+                    # Show this field and update its label
+                    param = params[i]
+                    updates.append(gr.update(
+                        visible=True,
+                        label=f"{param['name']} ({param['type']})"
+                    ))
+                else:
+                    # Hide this field
+                    updates.append(gr.update(visible=False))
+            
+            return updates
+
+        def process_input(*args):
+            # Get the input values from Gradio fields
+            return execute_blockly_logic(args)
+
+        # When refresh is clicked, update input field visibility and labels
+        refresh_btn.click(
+            refresh_inputs,
+            outputs=input_fields,
+            queue=False
+        )
+        
+        submit_btn.click(
+            process_input,
+            inputs=input_fields,
+            outputs=[output_text]
+        )
 
     return demo
 

project/src/blocks/text.js

@@ -1,89 +1,369 @@
 import * as Blockly from 'blockly/core';
+import { pythonGenerator } from 'blockly/python';
 
-const whenUserSends = {
-  type: 'when_user_sends',
-  message0: 'when user sends %1 do %2 %3',
-  args0: [
-    {
-      "type": "input_value",
-      "name": "DUPLICATE"
+// Function to create a unique block type for an input
+function createInputRefBlockType(inputName) {
+  const blockType = `input_reference_${inputName}`;
+
+  // Only create if not already defined
+  if (!Blockly.Blocks[blockType]) {
+    // Define block
+    Blockly.Blocks[blockType] = {
+      init: function () {
+        this.jsonInit({
+          "type": blockType,
+          "message0": "%1",
+          "args0": [
+            {
+              "type": "field_label_serializable",
+              "name": "VARNAME",
+              "text": inputName
+            }
+          ],
+          "output": null,
+          "colour": 210,
+          "outputShape": 1  // Oval shape (1 = round)
+        });
+      }
+    };
+
+    // Define Python generator for this block type
+    pythonGenerator.forBlock[blockType] = function (block) {
+      // Just return the input name as a variable reference
+      return [inputName, pythonGenerator.ORDER_ATOMIC];
+    };
+  }
+  return blockType;
+}
+
+// Keep track of input reference blocks
+const inputRefs = new Map();  // Maps input name to block ID
+
+Blockly.Extensions.registerMutator(
+  'test_mutator',
+  {
+    // Initialize tracking of input reference blocks
+    initialize: function () {
+      if (!this.initialized_) {
+        this.inputCount_ = 0;
+        this.inputNames_ = [];
+        this.inputTypes_ = [];
+        this.inputRefBlocks_ = new Map();  // Maps input name to block reference
+        this.initialized_ = true;
+      }
+    },
+
+    decompose: function (workspace) {
+      var containerBlock = workspace.newBlock('container');
+      containerBlock.initSvg();
+      var connection = containerBlock.getInput('STACK').connection;
+
+      // Ensure inputCount_ is defined
+      this.inputCount_ = this.inputCount_ || 0;
+      this.inputNames_ = this.inputNames_ || [];
+      this.inputTypes_ = this.inputTypes_ || [];
+
+      // Dynamically add input blocks based on inputCount_
+      for (var i = 0; i < this.inputCount_; i++) {
+        var itemBlock = workspace.newBlock('container_input');
+        itemBlock.initSvg();
+
+        var typeVal = this.inputTypes_[i] || 'string';
+        var nameVal = this.inputNames_[i] || typeVal;
+        itemBlock.setFieldValue(typeVal, 'TYPE');  // Set data type
+        itemBlock.setFieldValue(nameVal, 'NAME');  // Set name from stored name
+
+        // Preserve any existing connection from this block's input
+        var input = this.getInput('X' + i);
+        if (input && input.connection && input.connection.targetConnection) {
+          itemBlock.valueConnection_ = input.connection.targetConnection;
+        }
+
+        connection.connect(itemBlock.previousConnection);
+        connection = itemBlock.nextConnection;
+      }
+
+      return containerBlock;
+    },
+
+    compose: function (containerBlock) {
+      // Disable events during mutator updates to prevent duplication
+      Blockly.Events.disable();
+
+      try {
+        // Ensure initialization
+        if (!this.initialized_) {
+          this.initialize();
+        }
+
+        var itemBlock = containerBlock.getInputTargetBlock('STACK');
+        var connections = [];
+        var oldNames = this.inputNames_ ? [...this.inputNames_] : [];  // Copy old names for cleanup
+
+        // Collect input connections
+        while (itemBlock) {
+          connections.push(itemBlock.valueConnection_);
+          itemBlock = itemBlock.nextConnection && itemBlock.nextConnection.targetBlock();
+        }
+
+        var newCount = connections.length;
+        this.inputCount_ = newCount;
+        this.inputNames_ = this.inputNames_ || [];
+        this.inputTypes_ = this.inputTypes_ || [];
+
+        var idx = 0;
+        var it = containerBlock.getInputTargetBlock('STACK');
+        var newNames = [];
+        while (it) {
+          this.inputTypes_[idx] = it.getFieldValue('TYPE') || 'string';
+          this.inputNames_[idx] = it.getFieldValue('NAME') || ('arg' + idx);
+          newNames.push(this.inputNames_[idx]);
+          it = it.nextConnection && it.nextConnection.targetBlock();
+          idx++;
+        }
+
+        // Clean up removed input reference blocks only if count decreased
+        if (newCount < oldNames.length) {
+          // Only remove blocks for inputs that were deleted (beyond new count)
+          for (let i = newCount; i < oldNames.length; i++) {
+            const oldName = oldNames[i];
+            const block = this.inputRefBlocks_.get(oldName);
+            if (block && !block.disposed) {
+              block.dispose(true);  // true = skip gap
+            }
+            this.inputRefBlocks_.delete(oldName);
+          }
+        }
+
+        // Handle renamed variables - update ALL instances (main block + clones)
+        for (let i = 0; i < Math.min(oldNames.length, newNames.length); i++) {
+          const oldName = oldNames[i];
+          const newName = newNames[i];
+          if (oldName !== newName) {
+            const oldBlockType = `input_reference_${oldName}`;
+            const newBlockType = `input_reference_${newName}`;
+
+            // Update the reference block in the MCP block
+            if (this.inputRefBlocks_.has(oldName)) {
+              const refBlock = this.inputRefBlocks_.get(oldName);
+              if (refBlock && !refBlock.disposed) {
+                this.inputRefBlocks_.delete(oldName);
+                this.inputRefBlocks_.set(newName, refBlock);
+                refBlock.setFieldValue(newName, 'VARNAME');
+                refBlock.type = newBlockType;  // Update the block type
+              }
+            }
+
+            // Find and update ALL clones of this reference block in the workspace
+            const workspace = this.workspace;
+            const allBlocks = workspace.getAllBlocks(false);
+            for (const block of allBlocks) {
+              if (block.type === oldBlockType && block !== this.inputRefBlocks_.get(newName)) {
+                // This is a clone - update it too
+                block.type = newBlockType;
+                block.setFieldValue(newName, 'VARNAME');
+              }
+            }
+
+            // Update the Python generator for the new block type
+            pythonGenerator.forBlock[newBlockType] = function (block) {
+              return [newName, pythonGenerator.ORDER_ATOMIC];
+            };
+          }
+        }
+
+        // Remove only the dynamic inputs (X0, X1, etc.)
+        var i = 0;
+        while (this.getInput('X' + i)) {
+          this.removeInput('X' + i);
+          i++;
+        }
+
+        // Now add dynamic inputs at the correct position
+        for (var j = 0; j < newCount; j++) {
+          var type = this.inputTypes_[j] || 'string';
+          var name = this.inputNames_[j] || type;
+          var check = null;
+          if (type === 'integer') check = 'Number';
+          if (type === 'string') check = 'String';
+          // For list, leave check as null (no restriction)
+
+          // Get existing reference block if any
+          const existingRefBlock = this.inputRefBlocks_.get(name);
+
+          // Insert inputs at the beginning (after the static text)
+          var input = this.appendValueInput('X' + j);
+          if (check) input.setCheck(check);
+          input.appendField(type);  // Display the type instead of the name
+
+          // Move the input to the correct position (after dummy inputs, before BODY)
+          this.moveInputBefore('X' + j, 'BODY');
+
+          // Create or reuse reference block
+          const blockType = createInputRefBlockType(name);
+          if (!existingRefBlock) {
+            // Create new reference block
+            const workspace = this.workspace;
+            const refBlock = workspace.newBlock(blockType);
+            refBlock.initSvg();
+            refBlock.setDeletable(false);  // Can't be deleted directly
+            refBlock.render();
+            this.inputRefBlocks_.set(name, refBlock);
+
+            // Connect new block
+            if (input && input.connection && refBlock.outputConnection) {
+              input.connection.connect(refBlock.outputConnection);
+            }
+          } else {
+            // Reuse existing block - connect it to new input
+            if (input && input.connection && existingRefBlock.outputConnection) {
+              input.connection.connect(existingRefBlock.outputConnection);
+            }
+
+            // Update the Python generator for renamed variables
+            pythonGenerator.forBlock[blockType] = function (block) {
+              return [name, pythonGenerator.ORDER_ATOMIC];
+            };
+          }
+        }
+
+        // Reconnect preserved connections
+        for (var k = 0; k < newCount; k++) {
+          var conn = connections[k];
+          if (conn) {
+            try {
+              conn.connect(this.getInput('X' + k).connection);
+            } catch (e) {
+              // ignore failed reconnects
+            }
+          }
+        }
+
+        // Force workspace to update
+        this.workspace.render();
+
+      } finally {
+        // Re-enable events
+        Blockly.Events.enable();
+      }
+    },
+
+    saveExtraState: function () {
+      const state = {
+        inputCount: this.inputCount_,
+        inputNames: this.inputNames_,
+        inputTypes: this.inputTypes_
+      };
+      return state;
     },
+
+    loadExtraState: function (state) {
+      this.inputCount_ = state['inputCount'];
+      this.inputNames_ = state['inputNames'] || [];
+      this.inputTypes_ = state['inputTypes'] || [];
+    }
+  },
+  null,  // No helper function needed
+  ['container_input']
+);
+
+// Define the test block with mutator
+const create_mcp = {
+  "type": "create_mcp",
+  "message0": "create MCP with inputs: %1 %2 and return %3",
+  "args0": [
     {
       "type": "input_dummy"
     },
     {
       "type": "input_statement",
-      "name": "CODE"
-    }
+      "name": "BODY"
+    },
+    {
+      "type": "input_value",
+      "name": "RETURN",
+    },
   ],
-  inputsInline: true,
-  colour: 230,
-  tooltip: 'Triggered when the user sends a chat message.',
-  helpUrl: '',
+  "colour": 160,
+  "inputsInline": true,
+  "mutator": "test_mutator",
+  "inputCount_": 0,  // Start with no inputs
+  "deletable": false,  // Make the block non-deletable
+
+  // Override the dispose function to clean up reference blocks
+  "extensions": ["test_cleanup_extension"]
 };
 
-const assistantReply = {
-  type: 'assistant_reply',
-  message0: 'reply with %1',
-  args0: [
+// Define the container block for the mutator
+const container = {
+  "type": "container",
+  "message0": "inputs %1 %2",
+  "args0": [
     {
-      type: 'input_value',
-      name: 'INPUT',
-      check: 'String',
+      "type": "input_dummy",
+      "name": "title"
     },
+    {
+      "type": "input_statement",
+      "name": "STACK"
+    }
   ],
-  previousStatement: null,
-  nextStatement: null,
-  colour: 65,
-  tooltip: 'Send a message as the assistant.',
-  helpUrl: '',
-};
+  "colour": 160,
+  "inputsInline": false
+}
 
-const getAssistantResponse = {
-  type: 'get_assistant_response',
-  message0: 'call model %1 with prompt %2 %3 history',
+
+// Define the input block for the mutator
+const container_input = {
+  type: 'container_input',
+  message0: '%1 %2',
   args0: [
     {
       type: 'field_dropdown',
-      name: 'MODEL',
+      name: 'TYPE',
       options: [
-        ['gpt-3.5-turbo', 'gpt-3.5-turbo-0125'],
-        ['gpt-5-mini', 'gpt-5-mini-2025-08-07'],
-      ],
+        ["String", "string"],
+        ["Integer", "integer"],
+        ["List", "list"],
+      ]
     },
     {
-      type: 'input_value',
-      name: 'PROMPT',
-      check: 'String',
-    },
-    {
-      type: 'field_dropdown',
-      name: 'HISTORY',
-      options: [
-        ["with", "True"],
-        ["without", "False"]
-      ]
+      type: 'field_input',
+      name: 'NAME',
     },
   ],
-  inputsInline: true,
-  output: 'String',
-  colour: 230,
-  tooltip: 'Call the selected OpenAI model to get a response.',
-  helpUrl: '',
+  previousStatement: null,
+  nextStatement: null,
+  colour: 210,
 };
 
-const user_message = {
-  type: "user_message",
-  message0: "user message",
-  output: "String",
-  colour: "#47A8D1",
-  tooltip: "",
-  helpUrl: "",
-};
+// Register an extension to handle cleanup when the block is deleted
+Blockly.Extensions.register('test_cleanup_extension', function () {
+  // Store the original dispose function
+  const oldDispose = this.dispose;
+
+  // Override the dispose function
+  this.dispose = function (healStack, recursive) {
+    // Clean up all reference blocks first
+    if (this.inputRefBlocks_) {
+      for (const [name, refBlock] of this.inputRefBlocks_) {
+        if (refBlock && !refBlock.disposed) {
+          refBlock.dispose(false);  // Don't heal stack for reference blocks
+        }
+      }
+      this.inputRefBlocks_.clear();
+    }
+
+    // Call the original dispose function
+    if (oldDispose) {
+      oldDispose.call(this, healStack, recursive);
+    }
+  };
+});
 
+// Create block definitions from the JSON
 export const blocks = Blockly.common.createBlockDefinitionsFromJsonArray([
-  whenUserSends,
-  assistantReply,
-  getAssistantResponse,
-  user_message
+  create_mcp,
+  container,
+  container_input,
 ]);

project/src/generators/python.js

@@ -2,30 +2,58 @@ import { Order } from 'blockly/python';
 
 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}  return\n`;
-  return code;
-};
+forBlock['create_mcp'] = function (block, generator) {
+  // Get all inputs with their types
+  const typedInputs = [];
+  let i = 0;
+  while (block.getInput('X' + i)) {
+    const input = block.getInput('X' + i);
+    if (input && input.connection && input.connection.targetBlock()) {
+      // Get the actual parameter name from inputNames_ array
+      const paramName = (block.inputNames_ && block.inputNames_[i]) || ('arg' + i);
+      // Get the type from inputTypes_ array
+      const type = (block.inputTypes_ && block.inputTypes_[i]) || 'string';
+      // Convert type to Python type annotation
+      let pyType;
+      switch (type) {
+        case 'integer':
+          pyType = 'int';
+          break;
+        case 'string':
+          pyType = 'str';
+          break;
+        case 'list':
+          pyType = 'list';
+          break;
+        default:
+          pyType = 'Any';
+      }
+      typedInputs.push(`${paramName}: ${pyType}`);
+    }
+    i++;
+  }
 
-// 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 = `reply(${reply})\n`;
-  return code;
-};
+  // Get the code for blocks inside the BODY statement input
+  let body = generator.statementToCode(block, 'BODY');
 
-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');
+  // Get the return value if any
+  let returnValue = generator.valueToCode(block, 'RETURN', Order.ATOMIC);
 
-  const code = `get_assistant_response(${prompt}, model="${model}", use_history=${history})`;
-  return [code, Order.NONE];
-};
+  // Replace arg references with actual parameter names
+  if (returnValue && block.inputNames_) {
+    for (let j = 0; j < block.inputNames_.length; j++) {
+      const paramName = block.inputNames_[j];
+      returnValue = returnValue.replace(new RegExp(`arg${j}\\b`, 'g'), paramName);
+    }
+  }
 
-forBlock['user_message'] = function (block, generator) {
-  const code = `user_message`;
-  return [code, generator.ORDER_NONE];
+  let returnStatement = returnValue ? `  return ${returnValue}\n` : '  return\n';
+
+  // Create the function with all typed inputs
+  if (typedInputs.length > 0) {
+    const code = `def create_mcp(${typedInputs.join(', ')}):\n${body}${returnStatement}\n`;
+    return code;
+  } else {
+    return `def create_mcp():\n${body}${returnStatement}`;
+  }
 };

project/src/index.js

@@ -57,29 +57,8 @@ 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;
-  }
+  const hasBlock = blocks.some(block => block.type === 'block');
 
   if (codeEl) {
     codeEl.textContent = code;
@@ -105,6 +84,21 @@ try {
   console.warn('Workspace load failed, clearing storage:', e);
   localStorage.clear();
 }
+
+// Ensure there's always one MCP block in the workspace
+const existingMcpBlocks = ws.getBlocksByType('create_mcp');
+if (existingMcpBlocks.length === 0) {
+  // Create the MCP block
+  const mcpBlock = ws.newBlock('create_mcp');
+  mcpBlock.initSvg();
+  mcpBlock.setDeletable(false);
+  mcpBlock.setMovable(true);  // Allow moving but not deleting
+
+  // Position it in a reasonable spot
+  mcpBlock.moveBy(50, 50);
+  mcpBlock.render();
+}
+
 updateCode();
 
 ws.addChangeListener((e) => {
@@ -124,24 +118,36 @@ ws.addChangeListener((event) => {
       if (
         removedBlock &&
         oldParent &&
-        removedBlock.type === 'user_message' &&
-        oldParent.type === 'when_user_sends'
+        removedBlock.type.startsWith('input_reference_') &&
+        oldParent.type === 'create_mcp'
       ) {
-        console.log('[DISCONNECT] user_message removed from when_user_sends');
+        // Only duplicate if removed from a mutator input (X0, X1, X2, etc.)
+        // NOT from other inputs like RETURN, BODY, or title input
+        const inputName = event.oldInputName;
+        const isMutatorInput = inputName && /^X\d+$/.test(inputName);
 
-        if (event.oldInputName) {
+        if (isMutatorInput) {
           Blockly.Events.disable();
           try {
-            const newMsgBlock = ws.newBlock('user_message');
-            newMsgBlock.initSvg();
-            newMsgBlock.render();
+            // Create a new block of the same reference type
+            const newRefBlock = ws.newBlock(removedBlock.type);
+            newRefBlock.initSvg();
+            newRefBlock.setDeletable(false);  // This one stays in the MCP block
 
-            const input = oldParent.getInput(event.oldInputName);
+            const input = oldParent.getInput(inputName);
             if (input) {
-              input.connection.connect(newMsgBlock.outputConnection);
-              console.log('[REPLACE] user_message restored instantly (no blink)');
+              input.connection.connect(newRefBlock.outputConnection);
+            }
+
+            // Update the parent block's reference tracking
+            const varName = removedBlock.type.replace('input_reference_', '');
+            if (oldParent.inputRefBlocks_) {
+              oldParent.inputRefBlocks_.set(varName, newRefBlock);
             }
 
+            // Make the dragged-out block deletable
+            removedBlock.setDeletable(true);
+
             ws.render(); // ensure workspace updates immediately
           } finally {
             Blockly.Events.enable();
@@ -159,23 +165,4 @@ ws.addChangeListener((e) => {
     return;
   }
   updateCode();
-});
-
-window.addEventListener("message", (event) => {
-  if (event.data?.type === "user_message") {
-    handleUserMessage(event.data.text);
-  }
-});
-
-function handleUserMessage(message) {
-  const blocks = ws.getAllBlocks();
-  const msgBlock = blocks.find(b => b.type === 'user_message');
-  if (msgBlock) {
-    msgBlock.setFieldValue(message, 'TEXT');
-    console.log(`[Blockly] Updated user_message with: ${message}`);
-  }
-
-  if (typeof window.userSendHandler === "function") {
-    window.userSendHandler(message);
-  }
-}
+});

project/src/toolbox.js

@@ -9,45 +9,7 @@ export const toolbox = {
     {
       'kind': 'sep',
     },
-    {
-      kind: 'category',
-      name: 'Custom',
-      categorystyle: 'logic_category',
-      contents: [
-        {
-          kind: 'block',
-          type: 'when_user_sends',
-          inputs: {
-            DUPLICATE: {
-              block: {
-                kind: "block",
-                type: "user_message"
-              }
-            },
-          },
-        },
-        {
-          kind: 'block',
-          type: 'assistant_reply',
-        },
-        {
-          kind: 'block',
-          type: 'get_assistant_response',
-          inputs: {
-            PROMPT: {
-              shadow: {
-                kind: "block",
-                type: "user_message"
-              }
-            },
-          },
-        },
-        {
-          kind: 'block',
-          type: 'user_message',
-        },
-      ]
-    },
+
     {
       kind: 'category',
       name: 'Logic',