Add console logs to code mode

Author: h3xxit

packages/code-mode/README.md

@@ -46,7 +46,7 @@ await client.registerManual({
 });
 
 // Now execute TypeScript code that uses the tools
-const result = await client.callToolChain(`
+const { result, logs } = await client.callToolChain(`
   // Call the add tool using hierarchical access
   const sum1 = await math_tools.add({ a: 5, b: 3 });
   console.log('First sum:', sum1.result);
@@ -64,10 +64,41 @@ const result = await client.callToolChain(`
 `);
 
 console.log('Final result:', result); // 18
+console.log('Console output:', logs); // ['First sum: 8', 'Second sum: 18', 'Add tool interface: ...']
 ```
 
 ## Advanced Usage
 
+### Console Output Capture
+
+All console output is automatically captured and returned alongside execution results:
+
+```typescript
+const { result, logs } = await client.callToolChain(`
+  console.log('Starting calculation...');
+  console.error('This will show as [ERROR]');
+  console.warn('This will show as [WARN]');
+  
+  const sum1 = await math_tools.add({ a: 5, b: 3 });
+  console.log('First sum:', sum1.result);
+  
+  const sum2 = await math_tools.add({ a: sum1.result, b: 10 });
+  console.log('Final sum:', sum2.result);
+  
+  return sum2.result;
+`);
+
+console.log('Result:', result); // 18
+console.log('Captured logs:');
+logs.forEach((log, i) => console.log(`${i + 1}: ${log}`));
+// Output:
+// 1: Starting calculation...
+// 2: [ERROR] This will show as [ERROR]
+// 3: [WARN] This will show as [WARN]
+// 4: First sum: 8
+// 5: Final sum: 18
+```
+
 ### Getting TypeScript Interfaces
 
 You can generate TypeScript interfaces for all your tools to get better IDE support:
@@ -231,13 +262,13 @@ Extends `UtcpClient` with additional code execution capabilities.
 
 #### Methods
 
-##### `callToolChain(code: string, timeout?: number): Promise<any>`
+##### `callToolChain(code: string, timeout?: number): Promise<{result: any, logs: string[]}>`
 
-Executes TypeScript code with access to all registered tools.
+Executes TypeScript code with access to all registered tools and captures console output.
 
 - **code**: TypeScript code to execute
 - **timeout**: Optional timeout in milliseconds (default: 30000)
-- **Returns**: The result of the code execution
+- **Returns**: Object containing both the execution result and captured console logs (`console.log`, `console.error`, `console.warn`, `console.info`)
 
 ##### `toolToTypeScriptInterface(tool: Tool): string`
 

packages/code-mode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utcp/code-mode",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Code execution mode for UTCP - enables executing TypeScript code chains with tool access",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

packages/code-mode/src/code_mode_utcp_client.ts

@@ -35,11 +35,10 @@ You have access to a CodeModeUtcpClient that allows you to execute TypeScript co
 - Use \`await manual.tool({ param: value })\` syntax for all tool calls
 - Tools are async functions that return promises
 - You have access to standard JavaScript globals: \`console\`, \`JSON\`, \`Math\`, \`Date\`, etc.
+- All console output (\`console.log\`, \`console.error\`, etc.) is automatically captured and returned
 - Build properly structured input objects based on interface definitions
 - Handle errors appropriately with try/catch blocks
 - Chain tool calls by using results from previous calls
-- return the results you need
-- the code you write will be wrapped in an async function and executed in a vm context
 
 ### 4. Best Practices
 - **Discover first, code second**: Always explore available tools before writing execution code
@@ -152,18 +151,19 @@ ${interfaces.join('\n\n')}`;
   }
 
   /**
-   * Executes TypeScript code with access to all registered tools as functions.
-   * The code runs in a secure VM context where each tool is available as a TypeScript function.
+   * Executes TypeScript code with access to registered tools and captures console output.
+   * The code can call tools directly as functions and has access to standard JavaScript globals.
    * 
-   * @param code TypeScript code to execute
+   * @param code TypeScript code to execute  
    * @param timeout Optional timeout in milliseconds (default: 30000)
-   * @returns The result of the code execution
+   * @returns Object containing both the execution result and captured console logs
    */
-  public async callToolChain(code: string, timeout: number = 30000): Promise<any> {
+  public async callToolChain(code: string, timeout: number = 30000): Promise<{result: any, logs: string[]}> {
     const tools = await this.getTools();
 
-    // Create the execution context with tool functions
-    const context = await this.createExecutionContext(tools);
+    // Create the execution context with tool functions and log capture
+    const logs: string[] = [];
+    const context = await this.createExecutionContext(tools, logs);
 
     try {
       // Create VM context
@@ -178,7 +178,7 @@ ${interfaces.join('\n\n')}`;
 
       // Execute with timeout
       const result = await this.runWithTimeout(wrappedCode, vmContext, timeout);
-      return result;
+      return { result, logs };
     } catch (error) {
       throw new Error(`Code execution failed: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -219,16 +219,41 @@ ${interfaces.join('\n\n')}`;
   }
 
   /**
-   * Creates the execution context for the VM with tool functions and type definitions.
-   * Each tool becomes a callable function in the execution context.
+   * Creates the execution context for running TypeScript code.
+   * This context includes tool functions and basic JavaScript globals.
    * 
    * @param tools Array of tools to make available
+   * @param logs Optional array to capture console.log output
    * @returns Execution context object
    */
-  private async createExecutionContext(tools: Tool[]): Promise<Record<string, any>> {
+  private async createExecutionContext(tools: Tool[], logs?: string[]): Promise<Record<string, any>> {
+    // Create console object (either capturing logs or using standard console)
+    const consoleObj = logs ? {
+      log: (...args: any[]) => {
+        logs.push(args.map(arg => 
+          typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+        ).join(' '));
+      },
+      error: (...args: any[]) => {
+        logs.push('[ERROR] ' + args.map(arg => 
+          typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+        ).join(' '));
+      },
+      warn: (...args: any[]) => {
+        logs.push('[WARN] ' + args.map(arg => 
+          typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+        ).join(' '));
+      },
+      info: (...args: any[]) => {
+        logs.push('[INFO] ' + args.map(arg => 
+          typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+        ).join(' '));
+      }
+    } : console;
+
     const context: Record<string, any> = {
       // Add basic utilities
-      console,
+      console: consoleObj,
       JSON,
       Promise,
       Array,

packages/code-mode/tests/code_mode_utcp_client.test.ts

@@ -299,13 +299,13 @@ describe('CodeModeUtcpClient', () => {
 
   test('should execute simple code with basic operations', async () => {
     const code = `
-      const x = 10;
-      const y = 20;
-      return { sum: x + y, product: x * y };
+      const x = 5;
+      const y = 10;
+      return x + y;
     `;
 
-    const result = await client.callToolChain(code);
-    expect(result).toEqual({ sum: 30, product: 200 });
+    const { result } = await client.callToolChain(code);
+    expect(result).toBe(15);
   });
 
   test('should execute code that calls a simple tool', async () => {
@@ -317,7 +317,7 @@ describe('CodeModeUtcpClient', () => {
       return result;
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.result).toBe(40);
     expect(result.operation).toBe('addition');
 
@@ -343,7 +343,7 @@ describe('CodeModeUtcpClient', () => {
       };
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.math.result).toBe(15);
     expect(result.greeting.greeting).toBe("Good day, Alice");
     expect(result.greeting.isFormal).toBe(true);
@@ -374,7 +374,7 @@ describe('CodeModeUtcpClient', () => {
       return result;
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.processedData.processed).toBe(true);
     expect(result.processedData.users).toBeDefined();
     expect(result.metadata.itemCount).toBe(1);
@@ -400,7 +400,7 @@ describe('CodeModeUtcpClient', () => {
       };
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.statistics.sum).toBe(25);
     expect(result.statistics.count).toBe(6);
     expect(result.statistics.average).toBe(25/6);
@@ -422,7 +422,7 @@ describe('CodeModeUtcpClient', () => {
       };
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.timeData.timestamp).toBeDefined();
     expect(result.timeData.iso).toBeDefined();
     expect(result.isRecent).toBe(true);
@@ -445,7 +445,7 @@ describe('CodeModeUtcpClient', () => {
       }
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.error).toBe(true);
     expect(result.caught).toBe(true);
     expect(result.message).toContain("Test error message");
@@ -483,7 +483,7 @@ describe('CodeModeUtcpClient', () => {
       };
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.mathPi).toBe(Math.PI);
     expect(typeof result.dateNow).toBe('number');
     expect(result.arrayMethods).toBe(true);
@@ -502,7 +502,7 @@ describe('CodeModeUtcpClient', () => {
       };
     `;
 
-    const result = await client.callToolChain(code);
+    const { result } = await client.callToolChain(code);
     expect(result.hasInterfaces).toBe(true);
     expect(result.interfacesContainNamespace).toBe(true);
     expect(result.canGetSpecificInterface).toBe(true);
@@ -558,11 +558,11 @@ describe('CodeModeUtcpClient', () => {
     const result = await client.callToolChain(code, 15000);
 
     // Verify the chain worked correctly
-    expect(result.steps.arrayProcessing.sum).toBe(50);
-    expect(result.steps.addition.result).toBe(150);
-    expect(result.steps.greeting.greeting).toBe("Hey CodeMode!");
-    expect(result.steps.finalProcessing.processedData.processed).toBe(true);
-    expect(result.summary.chainCompleted).toBe(true);
+    expect(result.result.steps.arrayProcessing.sum).toBe(50);
+    expect(result.result.steps.addition.result).toBe(150);
+    expect(result.result.steps.greeting.greeting).toBe("Hey CodeMode!");
+    expect(result.result.steps.finalProcessing.processedData.processed).toBe(true);
+    expect(result.result.summary.chainCompleted).toBe(true);
 
     // Verify all tools were called in the correct order
     expect(testResults.sumArrayCalled).toBeDefined();
@@ -576,6 +576,64 @@ describe('CodeModeUtcpClient', () => {
     expect(testResults.greetCalled.name).toBe("CodeMode");
     expect(testResults.greetCalled.formal).toBe(false);
   });
+
+  test('should provide agent prompt template', () => {
+    const promptTemplate = CodeModeUtcpClient.AGENT_PROMPT_TEMPLATE;
+    
+    expect(typeof promptTemplate).toBe('string');
+    expect(promptTemplate.length).toBeGreaterThan(0);
+    expect(promptTemplate).toContain('Tool Discovery Phase');
+    expect(promptTemplate).toContain('Interface Introspection');
+    expect(promptTemplate).toContain('Code Execution Guidelines');
+    expect(promptTemplate).toContain('await manual.tool');
+    expect(promptTemplate).toContain('__interfaces');
+    expect(promptTemplate).toContain('__getToolInterface');
+    expect(promptTemplate).toContain('Discover first, code second');
+  });
+
+  test('should capture console.log output with callToolChain', async () => {
+    const code = `
+      console.log('First log message');
+      console.log('Number:', 42);
+      console.log('Object:', { name: 'test', value: 123 });
+      
+      const addResult = await test_tools.add({ a: 10, b: 20 });
+      console.log('Addition result:', addResult);
+      
+      return addResult.result;
+    `;
+    
+    const { result, logs } = await client.callToolChain(code);
+    
+    expect(result).toBe(30);
+    expect(logs).toHaveLength(4);
+    expect(logs[0]).toBe('First log message');
+    expect(logs[1]).toBe('Number: 42');
+    expect(logs[2]).toContain('"name": "test"');
+    expect(logs[2]).toContain('"value": 123');
+    expect(logs[3]).toContain('Addition result:');
+    expect(logs[3]).toContain('"result": 30');
+  });
+
+  test('should capture console error and warn with callToolChain', async () => {
+    const code = `
+      console.log('Regular log');
+      console.error('This is an error');
+      console.warn('This is a warning');
+      console.info('This is info');
+      
+      return 'done';
+    `;
+    
+    const { result, logs } = await client.callToolChain(code);
+    
+    expect(result).toBe('done');
+    expect(logs).toHaveLength(4);
+    expect(logs[0]).toBe('Regular log');
+    expect(logs[1]).toBe('[ERROR] This is an error');
+    expect(logs[2]).toBe('[WARN] This is a warning');
+    expect(logs[3]).toBe('[INFO] This is info');
+  });
 });
 
 // Export for potential manual testing