@mhingston5/conduit 1.1.0 → 1.1.1

package/README.md

@@ -175,6 +175,21 @@ By default, Conduit runs in **Permissive Mode** to allow easy exploration.
 - permissive mode for exploration
 - strict mode for production agents
 
+## Code Mode Prompting Guide
+
+To get the most out of Conduit, you should guide your LLM (agent) to prefer multi-tool scripts over individual tool calls.
+
+**Recommended System Prompt Additions:**
+> You are equipped with a "Code Mode" execution environment via Conduit.
+>
+> - **Prefer `mcp.executeTypeScript`**: Use this for any task requiring multiple steps, data transformation, or logical branching.
+> - **Use `tools.*` SDK**: Within your scripts, access all upstream tools via the `tools` namespace (e.g., `await tools.github.create_issue(...)`).
+> - **Avoid JSON tool-calling overhead**: Instead of making 5 separate tool calls and waiting for 5 round-trips, write one script that orchestrates the entire operation.
+> - **Data Transformation**: Perform loops, filters, and aggregations directly in your code rather than asking the user (or yourself) to process large datasets in the chat context.
+
+Example of a high-efficiency prompt:
+*"Scan the last 50 emails for invoices, total their amounts by currency, and create a single summary ticket in Jira if the total exceeds $1000."*
+
 ---
 
 ## Design Principles

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mhingston5/conduit",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "description": "A secure Code Mode execution substrate for MCP agents",
   "main": "index.js",

package/src/gateway/gateway.service.ts

@@ -10,6 +10,66 @@ import { PolicyService, ToolIdentifier } from '../core/policy.service.js';
 import { Ajv } from 'ajv';
 import addFormats from 'ajv-formats';
 
+const BUILT_IN_TOOLS: ToolSchema[] = [
+    {
+        name: 'mcp.executeTypeScript',
+        description: 'Executes TypeScript code in a secure sandbox with access to `tools.*` SDK.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: 'The TypeScript code to execute.'
+                },
+                allowedTools: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional list of tools the script is allowed to call (e.g. ["github.*"]).'
+                }
+            },
+            required: ['code']
+        }
+    },
+    {
+        name: 'mcp.executePython',
+        description: 'Executes Python code in a secure sandbox with access to `tools.*` SDK.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: 'The Python code to execute.'
+                },
+                allowedTools: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional list of tools the script is allowed to call (e.g. ["github.*"]).'
+                }
+            },
+            required: ['code']
+        }
+    },
+    {
+        name: 'mcp.executeIsolate',
+        description: 'Executes JavaScript code in a high-speed V8 isolate (no Deno/Node APIs).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: 'The JavaScript code to execute.'
+                },
+                allowedTools: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional list of tools the script is allowed to call.'
+                }
+            },
+            required: ['code']
+        }
+    }
+];
+
 export class GatewayService {
     private logger: Logger;
     private clients: Map<string, UpstreamClient> = new Map();
@@ -110,8 +170,13 @@ export class GatewayService {
         }
 
         const parsed = this.policyService.parseToolName(toolId);
+        const toolName = parsed.name; // Use a new variable for the un-namespaced name
+
+        // Check for built-in tools
+        const builtIn = BUILT_IN_TOOLS.find(t => t.name === toolId); // Compare with the full toolId
+        if (builtIn) return builtIn;
+
         const upstreamId = parsed.namespace;
-        const toolName = parsed.name;
 
         // Ensure we have schemas for this upstream
         if (!this.schemaCache.get(upstreamId)) {
@@ -132,7 +197,7 @@ export class GatewayService {
     }
 
     async discoverTools(context: ExecutionContext): Promise<ToolSchema[]> {
-        const allTools: ToolSchema[] = [];
+        const allTools: ToolSchema[] = [...BUILT_IN_TOOLS];
 
         for (const [id, client] of this.clients.entries()) {
             let tools = this.schemaCache.get(id);

package/tests/gateway.service.test.ts

@@ -31,11 +31,21 @@ describe('GatewayService', () => {
         });
 
         const tools = await gateway.discoverTools(context);
-        expect(tools).toHaveLength(2);
+        expect(tools.length).toBeGreaterThanOrEqual(3);
+        expect(tools.find(t => t.name === 'mcp.executeTypeScript')).toBeDefined();
+        expect(tools.find(t => t.name === 'mcp.executePython')).toBeDefined();
+        expect(tools.find(t => t.name === 'mcp.executeIsolate')).toBeDefined();
         expect(tools.find(t => t.name === 'u1__t1')).toBeDefined();
         expect(tools.find(t => t.name === 'u2__t2')).toBeDefined();
     });
 
+    it('should return schema for built-in tools', async () => {
+        const schema = await gateway.getToolSchema('mcp.executeTypeScript', context);
+        expect(schema).toBeDefined();
+        expect(schema?.name).toBe('mcp.executeTypeScript');
+        expect(schema?.inputSchema.required).toContain('code');
+    });
+
     it('should route tool calls to correct upstream', async () => {
         gateway.registerUpstream({ id: 'u1', url: 'http://u1' });