Fixes; prompt improvements

project/blocks.txt

@@ -1,60 +1,60 @@
 # AI
-llm_call(inputs(MODEL: "gpt-3.5-turbo-0125/gpt-4o-2024-08-06/gpt-5-mini-2025-08-07/gpt-5-2025-08-07/gpt-4o-search-preview-2025-03-11", PROMPT: value))
+VALUE: llm_call(inputs(MODEL: "gpt-3.5-turbo-0125/gpt-4o-2024-08-06/gpt-5-mini-2025-08-07/gpt-5-2025-08-07/gpt-4o-search-preview-2025-03-11", PROMPT: value))
 
 # 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
+VALUE: in_json(inputs(NAME: value, JSON: value)) // NAME is the value you want to extract from the JSON
+VALUE: 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
+VALUE: call_api(inputs(METHOD: "GET/POST/PUT/DELETE", URL: value, HEADERS: value)) // HEADERS is optional
 
 # Logic
-controls_if(inputs(IF: value, IFELSEN0: value, ELSE)) // IF is REQUIRED (the condition). IFELSEN0, IFELSEN1, etc are OPTIONAL (additional else-if conditions). ELSE is OPTIONAL (no value needed, just include the word). DO NOT use input_name with controls_if creation; specify all conditions in the inputs. After creating, use input_name to place statements: "DO0" (IF then-statements), "DO1" (first ELSE-IF then-statements), "ELSE" (final else statements)
-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))
+STATEMENT: controls_if(inputs(IF: value, IFELSEN0: value, ELSE)) // IF is REQUIRED (the condition). IFELSEN0, IFELSEN1, etc are OPTIONAL (additional else-if conditions). ELSE is OPTIONAL (no value needed, just include the word). DO NOT use input_name with controls_if creation; specify all conditions in the inputs. After creating, use input_name to place statements: "DO0" (IF then-statements), "DO1" (first ELSE-IF then-statements), "ELSE" (final else statements)
+VALUE: logic_negate(inputs())
+VALUE: logic_boolean(inputs(BOOL: "TRUE/FALSE"))
+VALUE: logic_null(inputs())
+VALUE: logic_compare(inputs(OP: "EQ/NEQ/LT/LTE/GT/GTE", A: value, B: value))
+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_for(inputs(VAR: value, FROM: value, TO: value, BY: value)) // VAR is a variable ID. BY is the increment amount
-controls_forEach(inputs(VAR: value), LIST: value) // VAR is a variable ID
-controls_flow_statements(inputs(FLOW: "CONTINUE/BREAK")) // Must go **inside** of a loop
+STATEMENT: controls_repeat_ext(inputs(TIMES: value))
+STATEMENT: controls_whileUntil(inputs(MODE: "WHILE/UNTIL", BOOL: value))
+STATEMENT: controls_for(inputs(VAR: value, FROM: value, TO: value, BY: value)) // VAR is a variable ID. BY is the increment amount
+STATEMENT: controls_forEach(inputs(VAR: value), LIST: value) // VAR is a variable ID
+STATEMENT: 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))
+VALUE: math_number(inputs(NUM: value))
+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
+VALUE: math_single(inputs(OP: "ROOT/ABS/NEG/LN/LOG10/EXP/POW10", NUM: value)) // EXP is e^num
+VALUE: math_number_property(inputs(PROPERTY: "EVEN/ODD/PRIME/WHOLE/POSITIVE/NEGATIVE", NUMBER_TO_CHECK: value)) // Boolean output
+VALUE: math_round(inputs(OP: "ROUND/ROUNDUP/ROUNDDOWN", NUM: value))
+VALUE: math_modulo(inputs(DIVIDEND: value, DIVISOR: value))
+VALUE: math_constrain(VALUE: value, LOW: value, HIGH: value)
+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_getSubstring(inputs(WHERE1: "FROM_START/FROM_END/FIRST", WHERE2: "FROM_START/FROM_END/FIRST", STRING: value, AT1: value, AT2: value)) // For AT1 and AT2, only use them if the associated WHEREN is not "FROM_START"
-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
+VALUE: text(inputs(TEXT: value))
+VALUE: text_length(VALUE: value)
+VALUE: text_join(inputs(ADDN: value)) // N starts at 0; you can make as many N as you want
+VALUE: text_isEmpty(inputs(VALUE: value)) // Boolean output
+VALUE: text_changeCase(inputs(CASE: "UPPERCASE/LOWERCASE/TITLECASE", TEXT: value))
+VALUE: text_getSubstring(inputs(WHERE1: "FROM_START/FROM_END/FIRST", WHERE2: "FROM_START/FROM_END/FIRST", STRING: value, AT1: value, AT2: value)) // For AT1 and AT2, only use them if the associated WHEREN is not "FROM_START"
+VALUE: text_reverse(inputs(TEXT: value))
+VALUE: text_count(inputs(SUB: value, TEXT: value)) // Integer output
+VALUE: text_replace(inputs(FROM: value, TO: value, TEXT: value))
+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)) // Boolean output
-lists_indexOf(inputs(END: "FIRST/LAST", VALUE: value, FIND: value))
-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
+VALUE: lists_length(inputs(VALUE: value))
+VALUE: lists_isEmpty(inputs(VALUE: value)) // Boolean output
+VALUE: lists_indexOf(inputs(END: "FIRST/LAST", VALUE: value, FIND: value))
+VALUE: lists_reverse(inputs(LIST: value))
+VALUE: lists_create_with(inputs(ADDN: value)) // N starts at 0; you can make as many N as you want
+VALUE: lists_sort(inputs(TYPE: "NUMERIC/TEXT/IGNORE_CASE", DIRECTION: "1/-1")) // For direction, 1 is ascending, -1 is descending
 
 # Variables
-variables_get(inputs(VAR: value)) // VAR is a variable ID
-variables_set(inputs(VAR: value, VALUE: value)) // VAR is a variable ID
-math_change(inputs(VAR: value, DELTA: value)) // VAR is a variable ID. To use this, you MUST have used `variables_set` before this
+VALUE: variables_get(inputs(VAR: value)) // VAR is a variable ID
+VALUE: variables_set(inputs(VAR: value, VALUE: value)) // VAR is a variable ID
+VALUE: math_change(inputs(VAR: value, DELTA: value)) // VAR is a variable ID. To use this, you MUST have used `variables_set` before this
 
 # MCP Block inputs
-input_reference_NAME(inputs()) // Replace "NAME" with the name of the MCP block input. Any inputs for the one MCP block can have their blocks made with this. You may ONLY use this if the MCP has an input with this name. If needed you must create inputs and outputs first for the MCP block
+VALUE: input_reference_NAME(inputs()) // Replace "NAME" with the name of the MCP block input. Any inputs for the one MCP block can have their blocks made with this. You may ONLY use this if the MCP has an input with this name. If needed you must create inputs and outputs first for the MCP block

project/chat.py

@@ -548,13 +548,13 @@ def create_gradio_interface():
     SYSTEM_PROMPT = f"""You are an AI assistant that helps users build **MCP servers** using Blockly blocks.
 
     You'll receive the workspace state in this format:
-    `blockId | block_name(inputs(input_name: value))`
+    `blockId → block_name(inputs(input_name: value))`
 
-    Block ID parsing: Block IDs are everything before ` | ` (space-pipe-space). IDs are always complex/long strings.
-    Example: `?fHZRh^|us|9bECO![$= | text(inputs(TEXT: "hello"))`, ID is `?fHZRh^|us|9bECO![$=`
+    Block ID parsing: Block IDs are everything before ` → ` (space-arrow-space). IDs are always complex/long strings.
+    Example: `?fHZRh^|us|9bECO![$= → text(inputs(TEXT: "hello"))`, ID is `?fHZRh^|us|9bECO![$=`
     
     Special cases:
-    - `create_mcp` and `func_def` use `blockId | block_name(inputs(input_name: type), outputs(output_name: value))`
+    - `create_mcp` and `func_def` use `blockId → block_name(inputs(input_name: type), outputs(output_name: value))`
     - Indentation or nesting shows logic hierarchy (like loops or conditionals).
 
     ---
@@ -579,11 +579,11 @@ def create_gradio_interface():
     ---
 
     ### Deleting Blocks
-    - Each block starts with its ID, like `blockId | block_name(...)`.
+    - Each block starts with its ID, like `blockId → block_name(...)`.
     - To delete a block, specify its block ID.
     - Any block except the main `create_mcp` block can be deleted.
 
-    `blockId | code`
+    `blockId → code`
 
     Use the exact ID from the workspace.
 
@@ -597,16 +597,9 @@ def create_gradio_interface():
     You cannot create a `create_mcp` block, but you may edit its inputs using the `edit_mcp` tool.
 
     ### Block Types: Statement vs Value
-    **Statement blocks** are containers that hold other blocks inside them. They can have blocks above or below them:
-    - Loops (repeat, while, for)
-    - Conditionals (if/else)
-    - Any block that wraps other blocks
+    **Statement blocks** (loops, conditionals, any container) hold other blocks inside them and require sequential creation to get the container's ID first.
     
-    **Value blocks** produce a value and plug into another block's input:
-    - Math blocks (math_number, math_arithmetic)
-    - Text blocks (text, text_join)
-    - Logic blocks (logic_compare, logic_operation)
-    - Any block that outputs a result for something else to use
+    **Value blocks** (math, text, logic, comparison) produce values that plug into inputs and must be built entirely in one nested create_block call.
 
     ### How to Place Blocks
     
@@ -636,21 +629,20 @@ def create_gradio_interface():
     - `input_name: "DO1"`: first ELSE-IF branch
     - `input_name: "ELSE"`: ELSE branch
 
+    YOU CANNOT EDIT THE IF BLOCK LATER. IF YOU WILL NEED TO HAVE AN ELSE OR IFELSE LATER, YOU MUST CREATE IT WITH ALL BRANCHES FROM THE START.
+
     **Placement types** - use `blockID` and `type` parameters:
     
     - `type: "under"` - For statement blocks inside containers. Create the container first, then create statement blocks using the container's ID.
       Example: Create a loop first, then use `blockID: loopID, type: "under"` to place code inside it.
-      Also for stackable blocks: create one, get its ID, then create the next one with the previous block's ID and `type: "under"`.
-      **Optional: use `input_name` to specify which statement input to place the block in (e.g., "DO0", "DO1", "ELSE" for IF blocks).**
-      Example: `create_block(text_append(...), blockID: ifBlockID, type: "under", input_name: "DO0")` places the block in the first THEN branch of an IF block.
-      **CRITICAL: When using `type: "under"`, `input_name` must ONLY contain "DO0", "DO1", "ELSE", or other statement input names. NEVER use R0, R1, R2, etc. with `type: "under"`.**
+      Optional: use `input_name` for statement input names only (e.g., "DO0", "DO1", "ELSE" for IF blocks).
+      Example: `create_block(text_append(...), blockID: ifBlockID, type: "under", input_name: "DO0")` places the block in the IF branch.
     
-    - `type: "input"` - ONLY for value blocks placed in MCP output slots. Provide `input_name` with the output slot name (R0, R1, R2, etc).
+    - `type: "input"` - ONLY for value blocks placed in MCP output slots (R0, R1, R2, etc).
       Example: `text(inputs(TEXT: "hello"))` with `type: "input", input_name: "R0"` places the text block in the MCP's first output slot.
-    **CRITICAL:** NEVER use `type: "input"` and `input_name` for standalone value expressions that aren't being assigned to an MCP output. Only use these parameters
-    if the workspace shows the create_mcp block has explicit outputs defined (you will see `outputs(...)` in the state). If you cannot see outputs defined in the MCP
-    block, do NOT use `type: "input"` at all.
-    **CRITICAL: NEVER combine `type: "under"` with `input_name: "R0"`, `"R1"`, `"R2"`, etc. These R-numbered slots are only for `type: "input"` when placing into MCP outputs.**
+      Requirement: The create_mcp block must have explicit outputs defined (you will see `outputs(...)` in the workspace state). Do not use this if outputs are not visible.
+    
+    Key rule: Statement input names (DO0, DO1, ELSE) are for `type: "under"`. Output slot names (R0, R1, R2) are for `type: "input"`. Never mix them.
       
     **Value block nesting** - For value blocks inside other blocks: nest them directly in the create_block command (do not use `blockID` or `type`).
     Example: `math_arithmetic(inputs(A: math_number(inputs(NUM: 5)), B: math_number(inputs(NUM: 3))))`
@@ -671,6 +663,10 @@ def create_gradio_interface():
     - WRONG: `math_single(inputs(OP: ROOT, NUM: value)`
     - CORRECT: `math_single(inputs(OP: "ROOT", NUM: value)`
     
+    **Variable IDs must always be quoted with double quotes**, even if they look like identifiers. Variable IDs often contain special characters like parentheses, pipes, and semicolons. ALWAYS quote the variable ID:
+    - WRONG: variables_set(inputs(VAR: ..., VALUE: ...))
+    - CORRECT: variables_set(inputs(VAR: "...", VALUE: ...))
+
     For value inputs, never use raw values. Always wrap in a block:
     - WRONG: `math_arithmetic(inputs(A: 5, B: "hi"))`
     - RIGHT: `math_arithmetic(inputs(A: math_number(inputs(NUM: 5)), B: text(inputs(TEXT: "hi"))))`
@@ -682,7 +678,7 @@ def create_gradio_interface():
     ### Variables
     Variables appear as:
 
-    `varId | varName`
+    `varId → varName`
 
     ---
 
@@ -721,6 +717,29 @@ def create_gradio_interface():
 
     ---
 
+    ## EVERY VALUE MUST HAVE A DESTINATION
+
+    Before constructing ANY expression block (text_join, math operations, etc.), identify where it goes:
+    - Assigned to a variable (via set_var block)
+    - Passed as input to another block (nested in the create_block call)
+    - Placed in an MCP output slot (using type: "input" and input_name: "R#")
+
+    Do NOT create orphaned expression blocks with no destination. They serve no purpose.
+
+    Always build the container/assignment block FIRST, then construct the value expression INSIDE it, both in a single call.
+
+    ### No Early Returns in Conditionals
+
+    Blockly does not support early returns from within conditional branches. You MUST use a variable to store the result and return that variable in the MCP output:
+
+    1. Create a variable
+    2. In each branch, use a `set_var` block to assign the value to that variable. The VALUE input of set_var must contain your text_join or expression.
+    3. Return the variable as an MCP output
+    
+    Always collect results in a variable first; never create expression blocks that exist outside a set_var or MCP output.
+
+    ---
+
     Tool responses appear under the assistant role, but they are not part of your own words. Never treat tool output as
     something you said, and never fabricate or echo fake tool outputs.
 
@@ -738,20 +757,27 @@ def create_gradio_interface():
     This is for *your own* understanding: work out the logic *before* translating to blocks.
     Example: `for item in items: result = process(item); output = combine(result)`
 
-    3. **Create a build order**: which blocks are top-level, which nest inside others, which are value expressions that must be built in one call.
+    3. **Create a detailed, step-by-step to-do list**:  
+    List every action you will take, in exact order, with no omissions. Build from the outside in: create outer containers first, then add inner blocks inside them.
 
-    4. **Check the create_mcp block state:** Before using `type: "input"` and `input_name: "R0"`, verify that the create_mcp block has outputs defined in the workspace state. If you do not see `outputs(...)` in the create_mcp block, do NOT use these parameters.
+    For every step, explicitly specify:  
+    - What action you will perform  
+    - Which block you are acting on  
+    - Which input or output slot you are using  
+    - All parameters involved (including type and input_name)  
+    - Every variable used and where it is used
 
-    5. **Understand MCP block placement:** When placing blocks under the MCP block itself (as opposed to inside its outputs):
-       - Use `type: "under"` with the MCP's `blockID`
-       - Do NOT use `input_name: "R0"`, `"R1"`, etc. (those are only for output slots)
-       - The MCP block is a statement container, not an output slot
-       - If you're defining what the MCP returns, you must either create output blocks inside the MCP, or edit the MCP block to add outputs first
+    For every IF statement you create, you must explicitly state:  
+    - The number of IFELSE branches (0, 1, 2, etc.)  
+    - The number of ELSE branches (0 or 1)  
+    - The exact condition that causes each branch to activate
 
-    6. Perform the actions in order without asking for approval or asking to wait for intermediate results.
+    THESE DECLARATIONS ARE REQUIRED EVERY TIME AN IF STATEMENT IS MENTIONED, AND YOU MUST ALWAYS PROVIDE EXACTLY THREE INTEGERS WITH NO EXCEPTIONS OR SUBSTITUTIONS. FAILURE TO DO SO IMMEDIATELY INVALIDATES THE RESPONSE IN ITS ENTIRETY.
+    YOU MUST HAVE EXPLICITLY SAID THESE THREE VALUES NO MATTER WHAT. THIS IS NON-NEGOTIABLE. THIS IS A HARD REQUIREMENT. ALWAYS SAY THIS, EVERY SINGLE TIME, NO MATTER WHAT.
 
-    """
+    4. **Check the create_mcp block state:** Before using `type: "input"` and `input_name: "R0"`, verify that the create_mcp block has outputs defined in the workspace state. If you do not see `outputs(...)` in the create_mcp block, do NOT use these parameters.
 
+    5. Perform the actions in order without asking for approval or asking to wait for intermediate results."""
     tools = [
         {
             "type": "function",
@@ -775,13 +801,18 @@ def create_gradio_interface():
             "parameters": {
                 "type": "object",
                 "properties": {
+                    # Throwaway parameter to get the agent to think about IF rules.
+                    "if_notes": {
+                        "type": "string",
+                        "description": "If you are going to make an if statement, YOU ARE REQUIRED TO USE THIS. Write the amount if IF/IFELSE/ELSE you will need.",
+                    },
                     "command": {
                         "type": "string",
                         "description": "The create block command using the custom DSL format.",
                     },
                     "blockID": {
                         "type": "string",
-                        "description": "The ID of the target block for placement.",
+                        "description": "The ID of the target block for placement. Do not use this if your goal is to place a block detached in the workspace.",
                     },
                     "type": {
                         "type": "string",

project/src/generators/chat.js

@@ -70,8 +70,8 @@ forBlock['create_mcp'] = function (block, generator) {
   let body = generator.statementToCode(block, 'BODY');
 
   // Construct the create_mcp call with inputs and outputs
-  // Include block ID for deletion tracking with pipe separator
-  let code = `${block.id} | create_mcp(inputs(${inputParams.join(', ')}), outputs(${outputParams.join(', ')}))`
+  // Include block ID for deletion tracking with arrow separator
+  let code = `${block.id} → create_mcp(inputs(${inputParams.join(', ')}), outputs(${outputParams.join(', ')}))`
 
   // Add the function body
   if (body) {
@@ -120,8 +120,8 @@ forBlock['func_def'] = function (block, generator) {
   let body = generator.statementToCode(block, 'BODY');
 
   // Construct the func_def call with inputs and outputs
-  // Include block ID for deletion tracking with pipe separator
-  let code = `${block.id} | ${name}(inputs(${inputParams.join(', ')}), outputs(${outputParams.join(', ')}))`
+  // Include block ID for deletion tracking with arrow separator
+  let code = `${block.id} → ${name}(inputs(${inputParams.join(', ')}), outputs(${outputParams.join(', ')}))`
 
   // Add the function body
   if (body) {
@@ -257,7 +257,7 @@ chatGenerator.blockToCode = function (block, opt_thisOnly) {
       }
 
       // Generate the controls_if call with conditions
-      let code = `${block.id} | ${blockType}(inputs(${inputs.join(', ')}))`;
+      let code = `${block.id} → ${blockType}(inputs(${inputs.join(', ')}))`;
 
       // Now get all the statement blocks with proper formatting
       // DO0, DO1, etc. are indented under the if
@@ -326,8 +326,8 @@ chatGenerator.blockToCode = function (block, opt_thisOnly) {
       }
     }
 
-    // Generate the standard format: name(inputs(...)) with block ID and pipe separator
-    const code = `${block.id} | ${blockType}(inputs(${inputs.join(', ')}))`;
+    // Generate the standard format: name(inputs(...)) with block ID and arrow separator
+    const code = `${block.id} → ${blockType}(inputs(${inputs.join(', ')}))`;
 
     // Handle statement inputs (for blocks that have a body)
     let statements = '';
@@ -359,7 +359,7 @@ chatGenerator.blockToCode = function (block, opt_thisOnly) {
         return [valueCode, this.ORDER_ATOMIC];
       } else {
         // When standalone (not connected), include the ID
-        const standaloneCode = `${block.id} | ${blockType}(inputs(${inputs.join(', ')}))`;
+        const standaloneCode = `${block.id} → ${blockType}(inputs(${inputs.join(', ')}))`;
         // For standalone value blocks, we need to return them as statement-like
         // but still maintain the value block return format for Blockly
         return [standaloneCode, this.ORDER_ATOMIC];

project/src/index.js

@@ -397,7 +397,7 @@ const setupUnifiedStream = () => {
 
         try {
           // Parse and create blocks recursively
-          function parseAndCreateBlock(spec, shouldPosition = false) {
+          function parseAndCreateBlock(spec, shouldPosition = false, placementType = null, placementBlockID = null) {
             // Match block_name(inputs(...)) with proper parenthesis matching
             const blockMatch = spec.match(/^(\w+)\s*\((.*)$/s);
 
@@ -503,6 +503,93 @@ const setupUnifiedStream = () => {
 
             console.log('[SSE CREATE] inputsContent to parse:', inputsContent);
 
+            // VALIDATION: Check for malformed input - if inputsContent contains unmatched parentheses
+            // If there are missing closing parentheses (1-2), automatically add them
+            let validateParenCount = 0;
+            let validateQuotes = false;
+            let validateQuoteChar = '';
+            for (let i = 0; i < inputsContent.length; i++) {
+              const char = inputsContent[i];
+              if ((char === '"' || char === "'") && (i === 0 || inputsContent[i - 1] !== '\\')) {
+                if (!validateQuotes) {
+                  validateQuotes = true;
+                  validateQuoteChar = char;
+                } else if (char === validateQuoteChar) {
+                  validateQuotes = false;
+                }
+              }
+              if (!validateQuotes) {
+                if (char === '(') validateParenCount++;
+                else if (char === ')') validateParenCount--;
+              }
+            }
+
+            // If parentheses are unbalanced, try to fix by adding closing parentheses
+            if (validateParenCount > 0) {
+              if (validateParenCount <= 2) {
+                console.log(`[SSE CREATE] Auto-fixing ${validateParenCount} missing closing parentheses in block '${blockType}'`);
+                
+                // Smart insertion: find the best place to insert closing parentheses
+                // Look for the last comma at depth 0 (which separates key-value pairs)
+                let bestInsertPos = inputsContent.length; // Default to end
+                let depth = 0;
+                let inQuotes = false;
+                let quoteChar = '';
+                
+                for (let i = inputsContent.length - 1; i >= 0; i--) {
+                  const char = inputsContent[i];
+                  
+                  // Handle quotes (from right to left)
+                  if ((char === '"' || char === "'") && (i === 0 || inputsContent[i - 1] !== '\\')) {
+                    if (!inQuotes) {
+                      inQuotes = true;
+                      quoteChar = char;
+                    } else if (char === quoteChar) {
+                      inQuotes = false;
+                    }
+                  }
+                  
+                  // Handle parentheses (from right to left, so reverse the logic)
+                  if (!inQuotes) {
+                    if (char === ')') depth++;
+                    else if (char === '(') depth--;
+                  }
+                  
+                  // Found the last comma at depth 0 - this separates the last nested block from following keys
+                  if (char === ',' && depth === 0 && !inQuotes) {
+                    bestInsertPos = i;
+                    break;
+                  }
+                }
+                
+                // Insert the closing parentheses at the best position
+                if (bestInsertPos < inputsContent.length && inputsContent[bestInsertPos] === ',') {
+                  // Insert right before the comma
+                  inputsContent = inputsContent.slice(0, bestInsertPos) + ')'.repeat(validateParenCount) + inputsContent.slice(bestInsertPos);
+                } else {
+                  // Fallback: insert at end
+                  inputsContent += ')'.repeat(validateParenCount);
+                }
+              } else {
+                throw new Error(`Malformed block specification for '${blockType}': too many unmatched opening parentheses (${validateParenCount}). This usually means a nested block specification is malformed. Received: ${inputsContent}`);
+              }
+            } else if (validateParenCount < 0) {
+              throw new Error(`Malformed block specification for '${blockType}': more closing parentheses than opening. Received: ${inputsContent}`);
+            }
+
+            // VALIDATION: Check if trying to place a value block under a statement block
+            // Value blocks have an output connection but no previous connection
+            if (placementType === 'under') {
+              // Check if this block type is a value block by temporarily creating it
+              const testBlock = ws.newBlock(blockType);
+              const isValueBlock = testBlock.outputConnection && !testBlock.previousConnection;
+              testBlock.dispose(true); // Remove the test block
+
+              if (isValueBlock) {
+                throw new Error(`Cannot place value block '${blockType}' under a statement block. Value blocks must be nested inside inputs of other blocks or placed in MCP outputs using type: "input".`);
+              }
+            }
+
             // Create the block
             const newBlock = ws.newBlock(blockType);
 
@@ -573,6 +660,28 @@ const setupUnifiedStream = () => {
                     }
                   }
                 }
+              } else if (blockType === 'text_join') {
+                // Special handling for text_join block (and similar blocks with ADD0, ADD1, ADD2...)
+                // Count ADD entries to determine how many items we need
+                let addCount = 0;
+                const addValues = {};
+
+                for (const [key, value] of Object.entries(inputs)) {
+                  const addMatch = key.match(/^ADD(\d+)$/);
+                  if (addMatch) {
+                    const index = parseInt(addMatch[1]);
+                    addCount = Math.max(addCount, index + 1);
+                    addValues[index] = value;
+                  }
+                }
+
+                console.log('[SSE CREATE] text_join detected with', addCount, 'items');
+
+                // Store pending text_join state to apply after initSvg()
+                if (addCount > 0) {
+                  newBlock.pendingAddCount_ = addCount;
+                  newBlock.pendingAddValues_ = addValues;
+                }
               } else if (blockType === 'controls_if') {
                 // Special handling for if/else blocks
                 // IF is required, IFELSEN0, IFELSEN1, etc are optional, ELSE is optional
@@ -723,6 +832,40 @@ const setupUnifiedStream = () => {
               }
             }
 
+            // Apply pending text_join mutations (must be after initSvg)
+            if (newBlock.type === 'text_join' && newBlock.pendingAddCount_ && newBlock.pendingAddCount_ > 0) {
+              console.log('[SSE CREATE] Applying text_join mutation with', newBlock.pendingAddCount_, 'items');
+
+              const addCount = newBlock.pendingAddCount_;
+              const addValues = newBlock.pendingAddValues_;
+
+              // Use loadExtraState if available to set the item count
+              if (typeof newBlock.loadExtraState === 'function') {
+                newBlock.loadExtraState({ itemCount: addCount });
+              } else {
+                // Fallback: set internal state
+                newBlock.itemCount_ = addCount;
+              }
+
+              // Now connect the ADD values
+              for (let i = 0; i < addCount; i++) {
+                const value = addValues[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 ADD input
+                  const input = newBlock.getInput('ADD' + i);
+                  if (input && input.connection && childBlock.outputConnection) {
+                    childBlock.outputConnection.connect(input.connection);
+                    console.log('[SSE CREATE] Connected ADD' + i + ' input');
+                  } else {
+                    console.warn('[SSE CREATE] Could not connect ADD' + i + ' input');
+                  }
+                }
+              }
+            }
+
             // Only position the top-level block
             if (shouldPosition) {
               // Find a good position that doesn't overlap existing blocks
@@ -849,7 +992,7 @@ const setupUnifiedStream = () => {
           }
 
           // Create the block and all its nested children
-          const newBlock = parseAndCreateBlock(data.block_spec, true);
+          const newBlock = parseAndCreateBlock(data.block_spec, true, data.placement_type, data.blockID);
 
           if (newBlock) {
             blockId = newBlock.id;
@@ -1131,7 +1274,7 @@ const updateCode = () => {
   }
 
   const vars = ws.getVariableMap().getAllVariables();
-  globalVarString = vars.map(v => `${v.id} | ${v.name}`).join("\n");
+  globalVarString = vars.map(v => `${v.id} → ${v.name}`).join("\n");
 
   const codeEl = document.querySelector('#generatedCode code');