Add more blocks; blocks inside blocks

README.md

@@ -10,7 +10,13 @@ The interface has three main areas. The canvas on the left is where you build by
 
 In the Development tab, you see your generated Python code alongside a test interface. The interface automatically creates input fields matching your tool's parameters. After you arrange your blocks, click Refresh to update the test interface, enter values, and click Submit to run your code. Results appear in the output fields.
 
-The AI Chat tab is the core feature of Agent-Blockly. It connects you to an AI assistant that understands your exact block configuration and can help you build, modify, and debug your workflows. You communicate in natural language. You can ask it to add validation to an input, fix a broken API call, restructure your logic, or explain what your current blocks do. The assistant reads your blocks, understands your intent, and can modify your workspace directly in real time. You can also ask it to run your tool with sample inputs to see how it behaves. The chat interface is not just for asking questions - it's an active collaborator that reshapes your blocks as you iterate on your design.
+The AI Chat tab is the centerpiece of Agent-Blockly. It connects you with an AI assistant that fully understands your current block configuration and helps you build, modify, and debug your workflows through natural language. You can ask it to add input validation, fix a broken API call, reorganize your logic, or explain how your blocks work.
+
+The assistant doesn’t just answer questions - it actively collaborates with you. It can edit your workspace in real time, run your tool with sample inputs, and show you how it behaves. It’s aware of your project’s structure and can make precise, context-aware changes as you iterate.
+
+The AI is capable of complex manipulations, such as inserting blocks inside others, creating nested structures, and arranging deeply recursive workflows.
+
+While it can handle a wide range of tasks, multi-step or highly complex changes work best when broken into smaller requests. Taking things one step at a time leads to more accurate and reliable results.
 
 The File menu handles creating new projects, opening existing ones, and downloading your work. You can download just the generated Python code or the entire project as a JSON file. The Edit menu provides standard undo, redo, and a cleanup button to reorganize blocks. The Examples menu includes pre-built projects you can load to understand how to structure your own. You need to set your OpenAI API key through Settings before the system can execute language model calls or power the chat.
 

project/blocks.txt

@@ -3,24 +3,46 @@ llm_call(inputs(MODEL: "gpt-3.5-turbo-0125/gpt-4o-2024-08-06/gpt-5-mini-2025-08-
 
 # JSON and API
 in_json(inputs(NAME: value, JSON: value)) // Name is the value you want to extract from the JSON
+make_json(inputs(KEYN: value, FIELDN: value)) // N starts at 0; you can make as many N as you want. Each key goes with one field
+call_api(inputs(METHOD: "GET/POST/PUT/DELETE", URL: value, HEADERS: value)) // Headers is optional
 
 # Logic
+controls_if(inputs(IFN: value)) // N starts at 0; you can make as many N as you want
 logic_negate(inputs())
 logic_boolean(inputs(BOOL: "TRUE/FALSE"))
 logic_null(inputs())
 logic_compare(inputs(OP: "EQ/NEQ/LT/LTE/GT/GTE", A: value, B: value))
 logic_operation(inputs(OP: "AND/OR", A: value, B: value))
 
+# Loops
+controls_repeat_ext(inputs(TIMES: value))
+controls_whileUntil(inputs(MODE: "WHILE/UNTIL", BOOL: value))
+controls_flow_statements(inputs(FLOW: "CONTINUE/BREAK")) // Must go **inside** of a loop
+
 # Math
 math_number(inputs(NUM: value))
 math_arithmetic(inputs(OP: "ADD/MINUS/MULTIPLY/DIVIDE/POWER", A: value, B: value)) // A and B are required. They must be blocks, so you need to add math_number or an alternative
+math_single(inputs(OP: "ROOT/ABS/NEG/LN/LOG10/EXP/POW10", NUM: value)) // EXP is e^num
+math_number_property(inputs(PROPERTY: "EVEN/ODD/PRIME/WHOLE/POSITIVE/NEGATIVE", NUMBER_TO_CHECK: value)) // Boolean output
+math_round(inputs(OP: "ROUND/ROUNDUP/ROUNDDOWN", NUM: value))
+math_modulo(inputs(DIVIDEND: value, DIVISOR: value))
+math_constrain(VALUE: value, LOW: value, HIGH: value)
+math_random_int(inputs(FROM: value, TO: value))
 
 # Text
 text(inputs(TEXT: value))
 text_length(VALUE: value)
 text_join(inputs(ADDN: value)) // N starts at 0; you can make as many N as you want
+text_isEmpty(inputs(VALUE: value)) // Boolean output
+text_changeCase(inputs(CASE: "UPPERCASE/LOWERCASE/TITLECASE", TEXT: value))
+text_reverse(inputs(TEXT: value))
+text_count(inputs(SUB: value, TEXT: value)) // Integer output
+text_replace(inputs(FROM: value, TO: value, TEXT: value))
+text_trim(inputs(MODE: "BOTH/LEFT/RIGHT", TEXT: value)) // Trim spaces from text
 
 # Lists
 lists_length(inputs(VALUE: value))
-lists_isEmpty(inputs(VALUE: value))
-lists_reverse(inputs(LIST: value))
+lists_isEmpty(inputs(VALUE: value)) // Boolean output
+lists_reverse(inputs(LIST: value))
+lists_create_with(inputs(ADDN: value)) // N starts at 0; you can make as many N as you want
+lists_sort(inputs(TYPE: "NUMERIC/TEXT/IGNORE_CASE", DIRECTION: "1/-1")) // For direction, 1 is ascending, -1 is descending

project/chat.py

@@ -227,10 +227,12 @@ def delete_block(block_id):
         traceback.print_exc()
         return f"Error deleting block: {str(e)}"
 
-def create_block(block_spec):
+def create_block(block_spec, under_block_id=None):
     """Create a block in the Blockly workspace"""
     try:
         print(f"[CREATE REQUEST] Attempting to create block: {block_spec}")
+        if under_block_id:
+            print(f"[CREATE REQUEST] Under block ID: {under_block_id}")
         
         # Generate a unique request ID
         import uuid
@@ -240,8 +242,11 @@ def create_block(block_spec):
         if request_id in creation_results:
             creation_results.pop(request_id)
         
-        # Add to creation queue
-        creation_queue.put({"request_id": request_id, "block_spec": block_spec})
+        # Add to creation queue with optional under_block_id
+        queue_data = {"request_id": request_id, "block_spec": block_spec}
+        if under_block_id:
+            queue_data["under_block_id"] = under_block_id
+        creation_queue.put(queue_data)
         print(f"[CREATE REQUEST] Added to queue with ID: {request_id}")
         
         # Wait for result with timeout
@@ -485,6 +490,28 @@ List of blocks:
 {blocks_context}
 
 YOU CANNOT CREATE A MCP BLOCK OR EDIT ITS INPUTS. YOU MUST TELL THE USER TO DO SO.
+
+For creating blocks, keep in mind: for `value`, if you want to put a string, you need to
+put a string block inside of it - you can't just put the string. For example:
+
+text_isEmpty(inputs(VALUE: "text"))
+
+This wouldn't work - you can't put a raw string in, you need to create a text block
+recursively inside of this. Same thing for numbers and so on.
+
+To put a block inside another (like an if inside a repeat), use two create block commands:
+first for the outer block, then for the inner block under it. This only applies to
+non-outputting blocks; outputting blocks (like a number in an addition) can be nested
+in one command.
+
+For blocks that allow infinite things (like ...N) you do not need to provide any inputs
+if you want it to be blank.
+
+---
+
+Don't share the DSL (DSL being the custom Blockly language) info with the user such
+as when creating a block unless they ask about it. It's not sensitive so you can
+share it with the user if they ask.
 """
     
     tools = [
@@ -517,6 +544,10 @@ YOU CANNOT CREATE A MCP BLOCK OR EDIT ITS INPUTS. YOU MUST TELL THE USER TO DO S
                             "type": "string",
                             "description": "The create block command using the custom DSL format.",
                         },
+                        "under": {
+                            "type": "string",
+                            "description": "The ID of the block that you want to place this under.",
+                        },
                     },
                     "required": ["command"],
                 },
@@ -630,7 +661,8 @@ YOU CANNOT CREATE A MCP BLOCK OR EDIT ITS INPUTS. YOU MUST TELL THE USER TO DO S
                             
                         elif function_name == "create_block":
                             command = function_args.get("command", "")
-                            tool_result = create_block(command)
+                            under_block_id = function_args.get("under", None)
+                            tool_result = create_block(command, under_block_id)
                             result_label = "Create Operation"
                             
                         elif function_name == "run_mcp":
@@ -657,7 +689,7 @@ YOU CANNOT CREATE A MCP BLOCK OR EDIT ITS INPUTS. YOU MUST TELL THE USER TO DO S
                             # Update history with the tool call and result
                             temp_history.append({"role": "user", "content": current_prompt})
                             temp_history.append({"role": "assistant", "content": ai_response, "tool_calls": response_message.tool_calls})
-                            temp_history.append({"role": "tool", "tool_call_id": tool_call.id, "content": tool_result})
+                            temp_history.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(tool_result)})
                             
                             # Set up next prompt to have the model respond to the tool result
                             current_prompt = f"The tool has been executed with the result shown above. Please respond appropriately to the user based on this result."

project/src/generators/chat.js

@@ -247,7 +247,7 @@ chatGenerator.blockToCode = function(block, opt_thisOnly) {
     // Then get all value inputs (connected blocks)
     const inputList = block.inputList || [];
     for (const input of inputList) {
-      if (input.type === Blockly.inputs.inputTypes.VALUE && input.connection) {
+      if (input.type === Blockly.INPUT_VALUE && input.connection) {
         const inputName = input.name;
         const inputValue = this.valueToCode(block, inputName, this.ORDER_ATOMIC);
         
@@ -263,7 +263,7 @@ chatGenerator.blockToCode = function(block, opt_thisOnly) {
     // Handle statement inputs (for blocks that have a body)
     let statements = '';
     for (const input of inputList) {
-      if (input.type === Blockly.inputs.inputTypes.STATEMENT && input.connection) {
+      if (input.type === Blockly.NEXT_STATEMENT && input.connection) {
         const statementCode = this.statementToCode(block, input.name);
         if (statementCode) {
           statements += statementCode;

project/src/generators/python.js

@@ -1,8 +1,21 @@
 import { Order } from 'blockly/python';
+import * as Blockly from 'blockly';
 
 export const forBlock = Object.create(null);
 
 forBlock['create_mcp'] = function (block, generator) {
+  // Ensure the generator is properly initialized for nested blocks like loops
+  if (!generator.nameDB_) {
+    generator.nameDB_ = new Blockly.Names(generator.RESERVED_WORDS_ || []);
+  }
+  
+  // Ensure getDistinctName is available for control flow blocks
+  if (!generator.getDistinctName) {
+    generator.getDistinctName = function(name, type) {
+      return this.nameDB_.getDistinctName(name, type);
+    };
+  }
+  
   const typedInputs = [];
   let i = 0;
 
@@ -138,6 +151,18 @@ demo.launch(mcp_server=True)
 };
 
 forBlock['func_def'] = function (block, generator) {
+  // Ensure the generator is properly initialized for nested blocks like loops
+  if (!generator.nameDB_) {
+    generator.nameDB_ = new Blockly.Names(generator.RESERVED_WORDS_ || []);
+  }
+  
+  // Ensure getDistinctName is available for control flow blocks
+  if (!generator.getDistinctName) {
+    generator.getDistinctName = function(name, type) {
+      return this.nameDB_.getDistinctName(name, type);
+    };
+  }
+  
   const name = block.getFieldValue('NAME');
   const typedInputs = [];
   let i = 0;

project/src/index.js

@@ -9,6 +9,37 @@ import '@blockly/toolbox-search';
 import DarkTheme from '@blockly/theme-dark';
 import './index.css';
 
+// Initialize the Python generator's Names database if it doesn't exist
+if (!pythonGenerator.nameDB_) {
+  pythonGenerator.init = function(workspace) {
+    // Call parent init if it exists
+    if (Blockly.Generator.prototype.init) {
+      Blockly.Generator.prototype.init.call(this, workspace);
+    }
+    
+    // Initialize the Names database for variable name generation
+    if (!this.nameDB_) {
+      this.nameDB_ = new Blockly.Names(this.RESERVED_WORDS_);
+    } else {
+      this.nameDB_.reset();
+    }
+    
+    // Add reserved Python keywords
+    const reservedWords = ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 
+                          'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
+                          'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 
+                          'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
+                          'try', 'while', 'with', 'yield'];
+    
+    for (const word of reservedWords) {
+      this.nameDB_.setVariableMap(word, word);
+    }
+    
+    // Initialize function name database
+    this.functionNames_ = this.nameDB_;
+  };
+}
+
 // Register the blocks and generator with Blockly
 Blockly.common.defineBlocks(blocks);
 Object.assign(pythonGenerator.forBlock, forBlock);
@@ -364,44 +395,107 @@ const setupCreationStream = () => {
               const inputs = parseInputs(inputsContent);
               console.log('[SSE CREATE] Parsed inputs:', inputs);
               
-              // Set field values and connect child blocks
-              for (const [key, value] of Object.entries(inputs)) {
-                if (typeof value === 'string') {
-                  // Check if this is a nested block specification
-                  if (value.match(/^\w+\s*\(inputs\(/)) {
-                    // This is a nested block, create it recursively
-                    const childBlock = parseAndCreateBlock(value);
+              // Special handling for make_json block
+              if (blockType === 'make_json') {
+                // Count FIELD entries to determine how many fields we need
+                let fieldCount = 0;
+                const fieldValues = {};
+                const keyValues = {};
+                
+                for (const [key, value] of Object.entries(inputs)) {
+                  const fieldMatch = key.match(/^FIELD(\d+)$/);
+                  const keyMatch = key.match(/^KEY(\d+)$/);
+                  
+                  if (fieldMatch) {
+                    const index = parseInt(fieldMatch[1]);
+                    fieldCount = Math.max(fieldCount, index + 1);
+                    fieldValues[index] = value;
+                  } else if (keyMatch) {
+                    const index = parseInt(keyMatch[1]);
+                    keyValues[index] = value;
+                  }
+                }
+                
+                // Set up the mutator state
+                if (fieldCount > 0) {
+                  newBlock.fieldCount_ = fieldCount;
+                  newBlock.fieldKeys_ = [];
+                  
+                  // Create the inputs through the mutator
+                  for (let i = 0; i < fieldCount; i++) {
+                    const keyValue = keyValues[i];
+                    const key = (typeof keyValue === 'string' && !keyValue.match(/^\w+\s*\(inputs\(/)) 
+                      ? keyValue.replace(/^["']|["']$/g, '') 
+                      : `key${i}`;
                     
-                    // Connect the child block to the appropriate input
-                    const input = newBlock.getInput(key);
-                    if (input && input.connection) {
-                      childBlock.outputConnection.connect(input.connection);
-                    }
-                  } else {
-                    // This is a simple value, set it as a field
-                    // Remove quotes if present
-                    const cleanValue = value.replace(/^["']|["']$/g, '');
+                    newBlock.fieldKeys_[i] = key;
                     
-                    // Try to set as a field value
+                    // Create the input
+                    const input = newBlock.appendValueInput('FIELD' + i);
+                    const field = new Blockly.FieldTextInput(key);
+                    field.setValidator((newValue) => {
+                      newBlock.fieldKeys_[i] = newValue || `key${i}`;
+                      return newValue;
+                    });
+                    input.appendField(field, 'KEY' + i);
+                    input.appendField(':');
+                  }
+                  
+                  // Now connect the field values
+                  for (let i = 0; i < fieldCount; i++) {
+                    const value = fieldValues[i];
+                    if (value && typeof value === 'string' && value.match(/^\w+\s*\(inputs\(/)) {
+                      // This is a nested block, create it recursively
+                      const childBlock = parseAndCreateBlock(value);
+                      
+                      // Connect the child block to the FIELD input
+                      const input = newBlock.getInput('FIELD' + i);
+                      if (input && input.connection && childBlock.outputConnection) {
+                        childBlock.outputConnection.connect(input.connection);
+                      }
+                    }
+                  }
+                }
+              } else {
+                // Normal block handling
+                for (const [key, value] of Object.entries(inputs)) {
+                  if (typeof value === 'string') {
+                    // Check if this is a nested block specification
+                    if (value.match(/^\w+\s*\(inputs\(/)) {
+                      // This is a nested block, create it recursively
+                      const childBlock = parseAndCreateBlock(value);
+                      
+                      // Connect the child block to the appropriate input
+                      const input = newBlock.getInput(key);
+                      if (input && input.connection && childBlock.outputConnection) {
+                        childBlock.outputConnection.connect(input.connection);
+                      }
+                    } else {
+                      // This is a simple value, set it as a field
+                      // Remove quotes if present
+                      const cleanValue = value.replace(/^["']|["']$/g, '');
+                      
+                      // Try to set as a field value
+                      try {
+                        newBlock.setFieldValue(cleanValue, key);
+                      } catch (e) {
+                        console.log(`[SSE CREATE] Could not set field ${key} to ${cleanValue}:`, e);
+                      }
+                    }
+                  } else if (typeof value === 'number') {
+                    // Set numeric field value
                     try {
-                      newBlock.setFieldValue(cleanValue, key);
+                      newBlock.setFieldValue(value, key);
                     } catch (e) {
-                      console.log(`[SSE CREATE] Could not set field ${key} to ${cleanValue}:`, e);
+                      console.log(`[SSE CREATE] Could not set field ${key} to ${value}:`, e);
+                    }
+                  } else if (typeof value === 'boolean') {
+                    // Set boolean field value
+                    try {
+                      newBlock.setFieldValue(value ? 'TRUE' : 'FALSE', key);
+                    } catch (e) {
+                      console.log(`[SSE CREATE] Could not set field ${key} to ${value}:`, e);
                     }
-                  }
-                } else if (typeof value === 'number') {
-                  // Set numeric field value
-                  try {
-                    newBlock.setFieldValue(value, key);
-                  } catch (e) {
-                    console.log(`[SSE CREATE] Could not set field ${key} to ${value}:`, e);
-                  }
-                } else if (typeof value === 'boolean') {
-                  // Set boolean field value
-                  try {
-                    newBlock.setFieldValue(value ? 'TRUE' : 'FALSE', key);
-                  } catch (e) {
-                    console.log(`[SSE CREATE] Could not set field ${key} to ${value}:`, e);
                   }
                 }
               }
@@ -534,6 +628,71 @@ const setupCreationStream = () => {
           
           if (newBlock) {
             blockId = newBlock.id;
+            
+            // If under_block_id is specified, attach the new block under the parent
+            if (data.under_block_id) {
+              const parentBlock = ws.getBlockById(data.under_block_id);
+              if (parentBlock) {
+                console.log('[SSE CREATE] Attaching to parent block:', data.under_block_id);
+                
+                // Find an appropriate input to connect to
+                // Try common statement inputs first
+                const statementInputs = ['BODY', 'DO', 'THEN', 'ELSE', 'STACK'];
+                let connected = false;
+                
+                for (const inputName of statementInputs) {
+                  const input = parentBlock.getInput(inputName);
+                  if (input && input.type === Blockly.NEXT_STATEMENT) {
+                    // Check if something is already connected
+                    if (input.connection && !input.connection.targetBlock()) {
+                      // Connect directly
+                      if (newBlock.previousConnection) {
+                        input.connection.connect(newBlock.previousConnection);
+                        connected = true;
+                        console.log('[SSE CREATE] Connected to input:', inputName);
+                        break;
+                      }
+                    } else if (input.connection && input.connection.targetBlock()) {
+                      // Find the last block in the stack
+                      let lastBlock = input.connection.targetBlock();
+                      while (lastBlock.nextConnection && lastBlock.nextConnection.targetBlock()) {
+                        lastBlock = lastBlock.nextConnection.targetBlock();
+                      }
+                      // Connect to the end of the stack
+                      if (lastBlock.nextConnection && newBlock.previousConnection) {
+                        lastBlock.nextConnection.connect(newBlock.previousConnection);
+                        connected = true;
+                        console.log('[SSE CREATE] Connected to end of stack in input:', inputName);
+                        break;
+                      }
+                    }
+                  }
+                }
+                
+                // If not connected to statement input, try value inputs
+                if (!connected) {
+                  // Try all inputs
+                  const inputs = parentBlock.inputList;
+                  for (const input of inputs) {
+                    if (input.type === Blockly.INPUT_VALUE && input.connection && !input.connection.targetBlock()) {
+                      if (newBlock.outputConnection) {
+                        input.connection.connect(newBlock.outputConnection);
+                        connected = true;
+                        console.log('[SSE CREATE] Connected to value input:', input.name);
+                        break;
+                      }
+                    }
+                  }
+                }
+                
+                if (!connected) {
+                  console.warn('[SSE CREATE] Could not find suitable connection point on parent block');
+                }
+              } else {
+                console.warn('[SSE CREATE] Parent block not found:', data.under_block_id);
+              }
+            }
+            
             success = true;
             console.log('[SSE CREATE] Successfully created block with children:', blockId, newBlock.type);
           } else {
@@ -597,6 +756,10 @@ const observer = new ResizeObserver(() => {
 observer.observe(blocklyDiv);
 
 const updateCode = () => {
+  // Initialize the Python generator with the workspace before generating code
+  // This ensures the Names database is properly set up for control flow blocks
+  pythonGenerator.init(ws);
+  
   // Instead of using workspaceToCode which processes ALL blocks,
   // manually process only blocks connected to create_mcp or func_def
   let code = '';