Fixes

project/blocks.txt

@@ -13,7 +13,7 @@ logic_operation(inputs(OP: "AND/OR", A: value, B: value))
 
 # Math
 math_number(inputs(NUM: value))
-math_arithmetic(inputs(OP: "ADD/MINUS/MULTIPLY/DIVIDE/POWER", A: value, B: 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
 
 # Text
 text(inputs(TEXT: value))

project/chat.py

@@ -457,9 +457,8 @@ To call a tool, use this exact format (no newline after the opening backticks):
 
 ---
 
-### Running MCPs
-You can execute MCPs directly.  
-End your message (and say nothing after) with:
+### Running MCP
+You can execute the MCP directly:
 
 ```run
 create_mcp(input_name=value)
@@ -480,6 +479,15 @@ blockId
 
 You can delete any block except the main `create_mcp` block.
 
+Remember, you give the blockId. Never put the code for it!
+You can see the ID to the left of each block it will be a jarble of characters
+looking something like:
+
+`blockId | code`
+
+Each block has its own ID, and you need to use the ID specifically from
+the correct block.
+
 ---
 
 ### Creating Blocks
@@ -488,17 +496,16 @@ To create a block, specify its type and parameters (if any).
 End your message (and say nothing after) with:
 
 ```create
-block_type(parameters)
+block_name(inputs(value_name: value))
+```
+
+If you want to create a block inside of a block, do it like this:
+
+```create
+block_name(inputs(value_name: block_name2(inputs(value_name2: value))))
 ```
 
-Examples:
-- `print_text("Hello World")` - creates a print block with text
-- `text("some text")` - creates a text block
-- `math_number(42)` - creates a number block
-- `logic_boolean(true)` - creates a boolean block
-- `mcp_tool("tool_name")` - creates an MCP tool block
-- `controls_if()` - creates an if block
-- `lists_create_empty()` - creates an empty list block
+Where you specify inputs() per block, even if it's inside of another block.
 
 List of blocks:
 
@@ -506,15 +513,15 @@ List of blocks:
 
 ---
 
+Remember, this is not the standard tool format. You must follow the one outlined above.
+
+Never say that you are going to run a tool and don't run it. You need to put tool calls in the same
+message or your messages will end (see below).
+
 Additionally, if you ever send a message without a tool call, your response will end. So, if you want to
 call more tools after something you have to keep calling them. Any pause in tool callings ends the loop.
 
-REMEMBER, AS YOU SEE BELOW, THE NAME MUST BE DIRECTLY AFTER THE ``` AND CANNOT HAVE A NEW LINE IN BETWEEN
-THIS IS A REQUIREMENT. NAME MUST BE ON THE EXACT SAME LINE AS THE BACKTICKS.
-
-```name
-(arguments_here)
-```
+For deleting blocks, don't forget that you use the **blockId** and **not** the code for it.
 """
     
     def chat_with_context(message, history):
@@ -569,7 +576,7 @@ THIS IS A REQUIREMENT. NAME MUST BE ON THE EXACT SAME LINE AS THE BACKTICKS.
             
             try:
                 response = client.chat.completions.create(
-                    model="gpt-3.5-turbo",
+                    model="gpt-4o-2024-08-06",
                     messages=[
                         {"role": "system", "content": full_system_prompt},
                         *temp_history,
@@ -582,21 +589,21 @@ THIS IS A REQUIREMENT. NAME MUST BE ON THE EXACT SAME LINE AS THE BACKTICKS.
                 # Define action patterns and their handlers
                 action_patterns = {
                     'run': {
-                        'pattern': r'```run\n(.+?)\n```',
+                        'pattern': r'```(?:\n)?run\n(.+?)\n```',
                         'label': 'MCP',
                         'result_label': 'MCP Execution Result',
                         'handler': lambda content: execute_mcp(content),
                         'next_prompt': "Please respond to the MCP execution result above and provide any relevant information to the user. If you need to run another MCP, delete, or create blocks, you can do so."
                     },
                     'delete': {
-                        'pattern': r'```delete\n(.+?)\n```',
+                        'pattern': r'```(?:\n)?delete\n(.+?)\n```',
                         'label': 'DELETE',
                         'result_label': 'Delete Operation',
                         'handler': lambda content: delete_block(content.strip()),
                         'next_prompt': "Please respond to the delete operation result above. If you need to run an MCP, delete more code, or create blocks, you can do so."
                     },
                     'create': {
-                        'pattern': r'```create\n(.+?)\n```',
+                        'pattern': r'```(?:\n)?create\n(.+?)\n```',
                         'label': 'CREATE',
                         'result_label': 'Create Operation',
                         'handler': lambda content: create_block(content.strip()),

project/src/generators/chat.js

@@ -143,6 +143,50 @@ forBlock['input_reference'] = function(block, generator) {
 // Register the forBlock definitions with the chat generator
 Object.assign(chatGenerator.forBlock, forBlock);
 
+// Override workspaceToCode to include standalone value blocks
+chatGenerator.workspaceToCode = function(workspace) {
+  if (!workspace) {
+    // Backwards compatibility from before there could be multiple workspaces.
+    console.warn('No workspace specified in workspaceToCode call.  Guessing.');
+    workspace = Blockly.getMainWorkspace();
+  }
+  let code = [];
+  const blocks = workspace.getTopBlocks(true);
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    // Process ALL top-level blocks, including value blocks
+    if (block.outputConnection) {
+      // This is a value block - check if it's connected
+      if (!block.outputConnection.isConnected()) {
+        // Standalone value block - get its code
+        const line = this.blockToCode(block, true);
+        if (Array.isArray(line)) {
+          // Value blocks return [code, order], extract just the code
+          const blockCode = line[0];
+          if (blockCode) {
+            code.push(blockCode);
+          }
+        } else if (line) {
+          code.push(line);
+        }
+      }
+    } else {
+      // Regular statement block
+      const line = this.blockToCode(block);
+      if (Array.isArray(line)) {
+        // Shouldn't happen for statement blocks, but handle it anyway
+        code.push(line[0]);
+      } else if (line) {
+        code.push(line);
+      }
+    }
+  }
+  code = code.join('\n');  // Blank line between each section.
+  // Strip trailing whitespace
+  code = code.replace(/\n\s*$/g, '\n');
+  return code;
+};
+
 // Override blockToCode to provide a catch-all handler
 const originalBlockToCode = chatGenerator.blockToCode.bind(chatGenerator);
 chatGenerator.blockToCode = function(block, opt_thisOnly) {
@@ -230,9 +274,20 @@ chatGenerator.blockToCode = function(block, opt_thisOnly) {
     // Return appropriate format based on whether it's a value or statement block
     if (block.outputConnection) {
       // This is a value block (can be plugged into inputs)
-      // For value blocks, don't include the ID in the returned value
-      const valueCode = `${blockType}(inputs(${inputs.join(', ')}))`;
-      return [valueCode, this.ORDER_ATOMIC];
+      // Check if this block is connected to another block's input
+      const isConnectedToInput = block.outputConnection && block.outputConnection.isConnected();
+      
+      if (isConnectedToInput) {
+        // When used as input to another block, don't include the ID
+        const valueCode = `${blockType}(inputs(${inputs.join(', ')}))`;
+        return [valueCode, this.ORDER_ATOMIC];
+      } else {
+        // When standalone (not connected), include the ID
+        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];
+      }
     } else {
       // This is a statement block (has prev/next connections)
       const fullCode = code + (statements ? '\n' + statements : '');

project/src/index.js

@@ -330,125 +330,208 @@ const setupCreationStream = () => {
         let blockId = null;
         
         try {
-          // Parse the block specification
-          // Expected format: "block_type(param1, param2, ...)"
-          const match = data.block_spec.match(/^(\w+)\s*\((.*)\)$/);
-          
-          if (!match) {
-            throw new Error(`Invalid block specification format: ${data.block_spec}`);
-          }
-          
-          const blockType = match[1];
-          const paramsStr = match[2].trim();
-          
-          // Create the block based on its type
-          let newBlock = null;
-          
-          switch (blockType) {
-            case 'print_text':
-              newBlock = ws.newBlock('print_text');
-              // Set the text value if provided
-              if (paramsStr) {
-                // Remove quotes from string parameters
-                const text = paramsStr.replace(/^["']|["']$/g, '');
-                newBlock.setFieldValue(text, 'TEXT');
-              }
-              break;
+          // Parse and create blocks recursively
+          function parseAndCreateBlock(spec, shouldPosition = false) {
+            // Match block_name(inputs(...))
+            const blockMatch = spec.match(/^(\w+)\s*\((.+)\)$/s);
+            
+            if (!blockMatch) {
+              throw new Error(`Invalid block specification format: ${spec}`);
+            }
+            
+            const blockType = blockMatch[1];
+            const content = blockMatch[2].trim();
+            
+            console.log('[SSE CREATE] Parsing block:', blockType, 'with content:', content);
+            
+            // Check if this has inputs() wrapper
+            let inputsContent = content;
+            if (content.startsWith('inputs(') && content.endsWith(')')) {
+              inputsContent = content.slice(7, -1); // Remove 'inputs(' and ')'
+            }
+            
+            // Create the block
+            const newBlock = ws.newBlock(blockType);
+            
+            if (inputsContent) {
+              // Parse the inputs content
+              const inputs = parseInputs(inputsContent);
+              console.log('[SSE CREATE] Parsed inputs:', inputs);
               
-            case 'mcp_tool':
-              newBlock = ws.newBlock('mcp_tool');
-              // Parse tool name if provided
-              if (paramsStr) {
-                const toolName = paramsStr.replace(/^["']|["']$/g, '');
-                newBlock.setFieldValue(toolName, 'TOOL');
+              // 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);
+                    
+                    // 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, '');
+                    
+                    // 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(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);
+                  }
+                }
               }
-              break;
+            }
+            
+            // Initialize the block (renders it)
+            newBlock.initSvg();
+            
+            // Only position the top-level block
+            if (shouldPosition) {
+              // Find a good position that doesn't overlap existing blocks
+              const existingBlocks = ws.getAllBlocks();
+              let x = 50;
+              let y = 50;
               
-            case 'text':
-              newBlock = ws.newBlock('text');
-              if (paramsStr) {
-                const text = paramsStr.replace(/^["']|["']$/g, '');
-                newBlock.setFieldValue(text, 'TEXT');
+              // Simple positioning: stack new blocks vertically
+              if (existingBlocks.length > 0) {
+                const lastBlock = existingBlocks[existingBlocks.length - 1];
+                const lastPos = lastBlock.getRelativeToSurfaceXY();
+                y = lastPos.y + lastBlock.height + 20;
               }
-              break;
               
-            case 'math_number':
-              newBlock = ws.newBlock('math_number');
-              if (paramsStr) {
-                const num = parseFloat(paramsStr);
-                if (!isNaN(num)) {
-                  newBlock.setFieldValue(num, 'NUM');
+              newBlock.moveBy(x, y);
+            }
+            
+            // Render the block
+            newBlock.render();
+            
+            return newBlock;
+          }
+          
+          // Helper function to parse inputs(key: value, key2: value2, ...)
+          function parseInputs(inputStr) {
+            const result = {};
+            let currentKey = '';
+            let currentValue = '';
+            let depth = 0;
+            let inQuotes = false;
+            let quoteChar = '';
+            let readingKey = true;
+            
+            for (let i = 0; i < inputStr.length; i++) {
+              const char = inputStr[i];
+              
+              // Handle quotes
+              if ((char === '"' || char === "'") && (i === 0 || inputStr[i-1] !== '\\')) {
+                if (!inQuotes) {
+                  inQuotes = true;
+                  quoteChar = char;
+                } else if (char === quoteChar) {
+                  inQuotes = false;
+                  quoteChar = '';
                 }
               }
-              break;
               
-            case 'logic_boolean':
-              newBlock = ws.newBlock('logic_boolean');
-              if (paramsStr) {
-                const bool = paramsStr.toLowerCase() === 'true' ? 'TRUE' : 'FALSE';
-                newBlock.setFieldValue(bool, 'BOOL');
+              // Handle parentheses depth (for nested blocks)
+              if (!inQuotes) {
+                if (char === '(') depth++;
+                else if (char === ')') depth--;
               }
-              break;
-              
-            case 'logic_compare':
-              newBlock = ws.newBlock('logic_compare');
-              // Could parse operator if provided
-              break;
-              
-            case 'logic_operation':
-              newBlock = ws.newBlock('logic_operation');
-              // Could parse operator if provided  
-              break;
               
-            case 'controls_if':
-              newBlock = ws.newBlock('controls_if');
-              break;
-              
-            case 'controls_whileUntil':
-              newBlock = ws.newBlock('controls_whileUntil');
-              break;
+              // Handle key-value separation
+              if (char === ':' && depth === 0 && !inQuotes && readingKey) {
+                readingKey = false;
+                currentKey = currentKey.trim();
+                continue;
+              }
               
-            case 'lists_create_with':
-              newBlock = ws.newBlock('lists_create_with');
-              break;
+              // Handle comma separation
+              if (char === ',' && depth === 0 && !inQuotes && !readingKey) {
+                // Store the key-value pair
+                currentValue = currentValue.trim();
+                
+                // Parse the value
+                if (currentValue.match(/^\w+\s*\(inputs\(/)) {
+                  // This is a nested block
+                  result[currentKey] = currentValue;
+                } else if (currentValue.match(/^-?\d+(\.\d+)?$/)) {
+                  // This is a number
+                  result[currentKey] = parseFloat(currentValue);
+                } else if (currentValue === 'true' || currentValue === 'false') {
+                  // This is a boolean
+                  result[currentKey] = currentValue === 'true';
+                } else {
+                  // This is a string (remove quotes if present)
+                  result[currentKey] = currentValue.replace(/^["']|["']$/g, '');
+                }
+                
+                // Reset for next key-value pair
+                currentKey = '';
+                currentValue = '';
+                readingKey = true;
+                continue;
+              }
               
-            case 'lists_create_empty':
-              newBlock = ws.newBlock('lists_create_empty');
-              break;
+              // Accumulate characters
+              if (readingKey) {
+                currentKey += char;
+              } else {
+                currentValue += char;
+              }
+            }
+            
+            // Handle the last key-value pair
+            if (currentKey && currentValue) {
+              currentKey = currentKey.trim();
+              currentValue = currentValue.trim();
               
-            default:
-              // Try to create as a generic block type
-              newBlock = ws.newBlock(blockType);
-              break;
+              // Parse the value
+              if (currentValue.match(/^\w+\s*\(inputs\(/)) {
+                // This is a nested block
+                result[currentKey] = currentValue;
+              } else if (currentValue.match(/^-?\d+(\.\d+)?$/)) {
+                // This is a number
+                result[currentKey] = parseFloat(currentValue);
+              } else if (currentValue === 'true' || currentValue === 'false') {
+                // This is a boolean
+                result[currentKey] = currentValue === 'true';
+              } else {
+                // This is a string (remove quotes if present)
+                result[currentKey] = currentValue.replace(/^["']|["']$/g, '');
+              }
+            }
+            
+            return result;
           }
           
+          // Create the block and all its nested children
+          const newBlock = parseAndCreateBlock(data.block_spec, true);
+          
           if (newBlock) {
-            // Initialize the block (renders it)
-            newBlock.initSvg();
-            
-            // Position it in a visible area
-            // Find a good position that doesn't overlap existing blocks
-            const existingBlocks = ws.getAllBlocks();
-            let x = 50;
-            let y = 50;
-            
-            // Simple positioning: stack new blocks vertically
-            if (existingBlocks.length > 0) {
-              const lastBlock = existingBlocks[existingBlocks.length - 1];
-              const lastPos = lastBlock.getRelativeToSurfaceXY();
-              y = lastPos.y + lastBlock.height + 20;
-            }
-            
-            newBlock.moveBy(x, y);
-            
-            // Render the block
-            newBlock.render();
-            
             blockId = newBlock.id;
             success = true;
-            console.log('[SSE CREATE] Successfully created block:', blockId, blockType);
+            console.log('[SSE CREATE] Successfully created block with children:', blockId, newBlock.type);
           } else {
-            throw new Error(`Failed to create block of type: ${blockType}`);
+            throw new Error(`Failed to create block from specification`);
           }
           
         } catch (e) {
@@ -570,6 +653,78 @@ const updateCode = () => {
     });
 };
 
+// Track if chat backend is available
+let chatBackendAvailable = false;
+let chatUpdateQueue = [];
+let chatRetryTimeout = null;
+
+// Function to check if chat backend is available
+const checkChatBackend = async () => {
+  try {
+    const response = await fetch("http://127.0.0.1:7861/update_chat", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code: "" }),
+    });
+    if (response.ok) {
+      chatBackendAvailable = true;
+      console.log("[Blockly] Chat backend is available");
+      // Process any queued updates
+      processChatUpdateQueue();
+      return true;
+    }
+  } catch (err) {
+    chatBackendAvailable = false;
+  }
+  return false;
+};
+
+// Process queued chat updates
+const processChatUpdateQueue = () => {
+  if (chatBackendAvailable && chatUpdateQueue.length > 0) {
+    const code = chatUpdateQueue.pop(); // Get the latest update
+    chatUpdateQueue = []; // Clear the queue
+    sendChatUpdate(code);
+  }
+};
+
+// Send chat update with retry logic
+const sendChatUpdate = async (code, retryCount = 0) => {
+  try {
+    const response = await fetch("http://127.0.0.1:7861/update_chat", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code }),
+    });
+    
+    if (response.ok) {
+      chatBackendAvailable = true;
+      console.log("[Blockly] Sent updated Chat code to backend");
+    } else {
+      throw new Error(`Server responded with status ${response.status}`);
+    }
+  } catch (err) {
+    console.warn(`[Blockly] Chat backend not ready (attempt ${retryCount + 1}):`, err.message);
+    chatBackendAvailable = false;
+    
+    // Queue this update for retry
+    if (retryCount < 5) {
+      const delay = Math.min(1000 * Math.pow(2, retryCount), 10000); // Exponential backoff, max 10s
+      setTimeout(() => {
+        if (!chatBackendAvailable) {
+          checkChatBackend().then(available => {
+            if (available) {
+              sendChatUpdate(code, retryCount + 1);
+            } else if (retryCount < 4) {
+              sendChatUpdate(code, retryCount + 1);
+            }
+          });
+        }
+      }, delay);
+    }
+  }
+};
+
 // Update function for the Chat generator (AI Chat tab)
 const updateChatCode = () => {
   let code = chatGenerator.workspaceToCode(ws);
@@ -582,16 +737,26 @@ const updateChatCode = () => {
     codeEl.textContent = code;
   }
 
-  // Send to the chat update endpoint
-  fetch("http://127.0.0.1:7861/update_chat", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ code }),
-  }).then(() => {
-    console.log("[Blockly] Sent updated Chat code to backend");
-  }).catch((err) => {
-    console.error("[Blockly] Error sending Chat code:", err);
-  });
+  // If backend is available, send immediately
+  if (chatBackendAvailable) {
+    sendChatUpdate(code);
+  } else {
+    // Queue the update and try to establish connection
+    chatUpdateQueue.push(code);
+    
+    // Clear any existing retry timeout
+    if (chatRetryTimeout) {
+      clearTimeout(chatRetryTimeout);
+    }
+    
+    // Try to connect to backend
+    checkChatBackend();
+    
+    // Set up periodic retry
+    chatRetryTimeout = setTimeout(() => {
+      checkChatBackend();
+    }, 2000);
+  }
 };
 
 try {
@@ -657,7 +822,18 @@ if (existingMcpBlocks.length === 0) {
 }
 
 updateCode();
-updateChatCode();
+
+// Check if chat backend is available before first update
+checkChatBackend().then(() => {
+  updateChatCode();
+});
+
+// Also set up periodic health checks for the chat backend
+setInterval(() => {
+  if (!chatBackendAvailable) {
+    checkChatBackend();
+  }
+}, 5000); // Check every 5 seconds if not connected
 
 ws.addChangeListener((e) => {
   if (e.isUiEvent) return;