@granular-software/sdk 0.1.0

package/dist/adapters/anthropic.mjs

@@ -0,0 +1,72 @@
+// src/adapters/anthropic.ts
+function toAnthropicTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  }));
+}
+function toolUsesToJobCode(contentBlocks, customImports = "") {
+  const toolUses = contentBlocks.filter((b) => b.type === "tool_use");
+  if (toolUses.length === 0) {
+    return null;
+  }
+  let code = `
+        import { tools } from './sandbox-tools';
+        ${customImports}
+        const results = [];
+    `;
+  toolUses.forEach((use) => {
+    code += `
+        try {
+            const result_${use.id.replace(/-/g, "_")} = await tools.${use.name}(${JSON.stringify(use.input)});
+            results.push({ 
+                type: 'tool_result',
+                tool_use_id: "${use.id}", 
+                content: result_${use.id.replace(/-/g, "_")} 
+            });
+        } catch (error) {
+           results.push({ 
+                type: 'tool_result',
+                tool_use_id: "${use.id}", 
+                content: String(error),
+                is_error: true
+            });
+        }
+        `;
+  });
+  code += `return results;`;
+  return code;
+}
+function createCodegenTool(domainDocumentation) {
+  return {
+    name: "execute_sandbox_code",
+    description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from "./sandbox-tools":
+
+${domainDocumentation}
+
+Write complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,
+    input_schema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: 'TypeScript code to execute. Must import tools from "./sandbox-tools" and use await for all tool calls.'
+        }
+      },
+      required: ["code"]
+    }
+  };
+}
+async function executeCodegenToolUse(toolUse, environment) {
+  if (toolUse.name !== "execute_sandbox_code") {
+    throw new Error(`Unknown tool: ${toolUse.name}`);
+  }
+  const input = toolUse.input;
+  const job = await environment.submitJob(input.code);
+  return job.result;
+}
+
+export { createCodegenTool, executeCodegenToolUse, toAnthropicTools, toolUsesToJobCode };
+//# sourceMappingURL=anthropic.mjs.map
+//# sourceMappingURL=anthropic.mjs.map

package/dist/adapters/anthropic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/anthropic.ts"],"names":[],"mappings":";AA2BO,SAAS,iBAAiB,KAAA,EAAqD;AAClF,EAAA,OAAO,KAAA,CAAM,IAAI,CAAA,IAAA,MAAS;AAAA,IACtB,MAAM,IAAA,CAAK,IAAA;AAAA,IACX,aAAa,IAAA,CAAK,WAAA;AAAA,IAClB,cAAc,IAAA,CAAK;AAAA,GACvB,CAAE,CAAA;AACN;AASO,SAAS,iBAAA,CAAkB,aAAA,EAAqF,aAAA,GAAgB,EAAA,EAAmB;AACtJ,EAAA,MAAM,WAAW,aAAA,CAAc,MAAA,CAAO,CAAA,CAAA,KAAK,CAAA,CAAE,SAAS,UAAU,CAAA;AAEhE,EAAA,IAAI,QAAA,CAAS,WAAW,CAAA,EAAG;AACvB,IAAA,OAAO,IAAA;AAAA,EACX;AAEA,EAAA,IAAI,IAAA,GAAO;AAAA;AAAA,QAAA,EAEL,aAAa;AAAA;AAAA,IAAA,CAAA;AAInB,EAAA,QAAA,CAAS,OAAA,CAAQ,CAAC,GAAA,KAAQ;AACtB,IAAA,IAAA,IAAQ;AAAA;AAAA,yBAAA,EAEW,GAAA,CAAI,EAAA,CAAG,OAAA,CAAQ,IAAA,EAAM,GAAG,CAAC,CAAA,eAAA,EAAkB,GAAA,CAAI,IAAI,CAAA,CAAA,EAAI,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAC,CAAA;AAAA;AAAA;AAAA,8BAAA,EAG3E,IAAI,EAAE,CAAA;AAAA,gCAAA,EACJ,GAAA,CAAI,EAAA,CAAG,OAAA,CAAQ,IAAA,EAAM,GAAG,CAAC,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,8BAAA,EAK3B,IAAI,EAAE,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAAA,CAAA;AAAA,EAMlC,CAAC,CAAA;AAED,EAAA,IAAA,IAAQ,CAAA,eAAA,CAAA;AACR,EAAA,OAAO,IAAA;AACX;AAYO,SAAS,kBAAkB,mBAAA,EAAsD;AACpF,EAAA,OAAO;AAAA,IACH,IAAA,EAAM,sBAAA;AAAA,IACN,WAAA,EAAa,CAAA;;AAAA,EAEnB,mBAAmB;;AAAA,sGAAA,CAAA;AAAA,IAGb,YAAA,EAAc;AAAA,MACV,IAAA,EAAM,QAAA;AAAA,MACN,UAAA,EAAY;AAAA,QACR,IAAA,EAAM;AAAA,UACF,IAAA,EAAM,QAAA;AAAA,UACN,WAAA,EAAa;AAAA;AACjB,OACJ;AAAA,MACA,QAAA,EAAU,CAAC,MAAM;AAAA;AACrB,GACJ;AACJ;AASA,eAAsB,qBAAA,CAClB,SACA,WAAA,EACgB;AAChB,EAAA,IAAI,OAAA,CAAQ,SAAS,sBAAA,EAAwB;AACzC,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,cAAA,EAAiB,OAAA,CAAQ,IAAI,CAAA,CAAE,CAAA;AAAA,EACnD;AAEA,EAAA,MAAM,QAAQ,OAAA,CAAQ,KAAA;AACtB,EAAA,MAAM,GAAA,GAAM,MAAM,WAAA,CAAY,SAAA,CAAU,MAAM,IAAI,CAAA;AAClD,EAAA,OAAO,GAAA,CAAI,MAAA;AACf","file":"anthropic.mjs","sourcesContent":["import type { ToolWithHandler } from '../types';\n\n/**\n * Anthropic tool_use block from message response\n */\nexport interface AnthropicToolUseBlock {\n    type: 'tool_use';\n    id: string;\n    name: string;\n    input: unknown;\n}\n\n/**\n * Anthropic tool definition\n */\nexport interface AnthropicToolDefinition {\n    name: string;\n    description?: string;\n    input_schema: Record<string, unknown>;\n}\n\n/**\n * Helper to convert Granular tools to Anthropic tool definitions\n * \n * @param tools - Array of Granular tools\n * @returns Array of Anthropic tool definitions\n */\nexport function toAnthropicTools(tools: ToolWithHandler[]): AnthropicToolDefinition[] {\n    return tools.map(tool => ({\n        name: tool.name,\n        description: tool.description,\n        input_schema: tool.inputSchema,\n    }));\n}\n\n/**\n * Helper to convert Anthropic tool calls to job code for Granular\n * \n * @param contentBlocks - Array of content blocks from Anthropic response\n * @param customImports - Optional imports to add to top of job\n * @returns generated job code, or null if no tool uses found\n */\nexport function toolUsesToJobCode(contentBlocks: Array<{ type: string; id?: string; name?: string; input?: unknown }>, customImports = ''): string | null {\n    const toolUses = contentBlocks.filter(b => b.type === 'tool_use') as AnthropicToolUseBlock[];\n\n    if (toolUses.length === 0) {\n        return null;\n    }\n\n    let code = `\n        import { tools } from './sandbox-tools';\n        ${customImports}\n        const results = [];\n    `;\n\n    toolUses.forEach((use) => {\n        code += `\n        try {\n            const result_${use.id.replace(/-/g, '_')} = await tools.${use.name}(${JSON.stringify(use.input)});\n            results.push({ \n                type: 'tool_result',\n                tool_use_id: \"${use.id}\", \n                content: result_${use.id.replace(/-/g, '_')} \n            });\n        } catch (error) {\n           results.push({ \n                type: 'tool_result',\n                tool_use_id: \"${use.id}\", \n                content: String(error),\n                is_error: true\n            });\n        }\n        `;\n    });\n\n    code += `return results;`;\n    return code;\n}\n\n/**\n * Create a single \"codegen tool\" for LLM consumption.\n * \n * Instead of passing N individual tools to the LLM, this returns a single\n * tool that accepts TypeScript code. The LLM writes code that uses the\n * available tools, and the code is executed in the sandbox.\n * \n * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())\n * @returns A single Anthropic tool definition\n */\nexport function createCodegenTool(domainDocumentation: string): AnthropicToolDefinition {\n    return {\n        name: 'execute_sandbox_code',\n        description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from \"./sandbox-tools\":\n\n${domainDocumentation}\n\nWrite complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,\n        input_schema: {\n            type: 'object',\n            properties: {\n                code: {\n                    type: 'string',\n                    description: 'TypeScript code to execute. Must import tools from \"./sandbox-tools\" and use await for all tool calls.',\n                },\n            },\n            required: ['code'],\n        },\n    };\n}\n\n/**\n * Helper to execute a codegen tool use block.\n * \n * @param toolUse - The tool_use block from the Anthropic response\n * @param environment - The connected Granular environment\n * @returns The job result\n */\nexport async function executeCodegenToolUse(\n    toolUse: AnthropicToolUseBlock,\n    environment: { submitJob: (code: string) => Promise<{ result: Promise<unknown> }> }\n): Promise<unknown> {\n    if (toolUse.name !== 'execute_sandbox_code') {\n        throw new Error(`Unknown tool: ${toolUse.name}`);\n    }\n\n    const input = toolUse.input as { code: string };\n    const job = await environment.submitJob(input.code);\n    return job.result;\n}\n"]}

package/dist/adapters/langchain.d.mts

@@ -0,0 +1,31 @@
+import { StructuredTool } from '@langchain/core/tools';
+import { T as ToolWithHandler } from '../types-D46q5WTh.mjs';
+
+/**
+ * Helper to convert LangChain tools to Granular tools.
+ *
+ * Note: Since Granular tools execute handlers in the wrapper/client process
+ * via reverse-RPC, we can just wrap the LangChain tool's call method directly.
+ *
+ * @param langchainTools - Array of LangChain StructuredTools
+ * @returns Array of Granular ToolWithHandler
+ */
+declare function fromLangChainTools(langchainTools: StructuredTool[]): ToolWithHandler[];
+/**
+ * Create a single "codegen tool" for LangChain agent consumption.
+ *
+ * Instead of passing N individual tools to the agent, this returns a single
+ * tool that accepts TypeScript code. The LLM writes code that uses the
+ * available tools, and the code is executed in the sandbox.
+ *
+ * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())
+ * @param environment - The connected Granular environment
+ * @returns A LangChain StructuredTool
+ */
+declare function createCodegenTool(domainDocumentation: string, environment: {
+    submitJob: (code: string) => Promise<{
+        result: Promise<unknown>;
+    }>;
+}): ToolWithHandler;
+
+export { createCodegenTool, fromLangChainTools };

package/dist/adapters/langchain.d.ts

@@ -0,0 +1,31 @@
+import { StructuredTool } from '@langchain/core/tools';
+import { T as ToolWithHandler } from '../types-D46q5WTh.js';
+
+/**
+ * Helper to convert LangChain tools to Granular tools.
+ *
+ * Note: Since Granular tools execute handlers in the wrapper/client process
+ * via reverse-RPC, we can just wrap the LangChain tool's call method directly.
+ *
+ * @param langchainTools - Array of LangChain StructuredTools
+ * @returns Array of Granular ToolWithHandler
+ */
+declare function fromLangChainTools(langchainTools: StructuredTool[]): ToolWithHandler[];
+/**
+ * Create a single "codegen tool" for LangChain agent consumption.
+ *
+ * Instead of passing N individual tools to the agent, this returns a single
+ * tool that accepts TypeScript code. The LLM writes code that uses the
+ * available tools, and the code is executed in the sandbox.
+ *
+ * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())
+ * @param environment - The connected Granular environment
+ * @returns A LangChain StructuredTool
+ */
+declare function createCodegenTool(domainDocumentation: string, environment: {
+    submitJob: (code: string) => Promise<{
+        result: Promise<unknown>;
+    }>;
+}): ToolWithHandler;
+
+export { createCodegenTool, fromLangChainTools };

package/dist/adapters/langchain.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var zodToJsonSchema = require('zod-to-json-schema');
+
+// src/adapters/langchain.ts
+function fromLangChainTools(langchainTools) {
+  return langchainTools.map((tool) => {
+    const jsonSchema = zodToJsonSchema.zodToJsonSchema(tool.schema);
+    const inputSchema = jsonSchema.properties ? jsonSchema : jsonSchema.definitions ? jsonSchema.definitions[Object.keys(jsonSchema.definitions)[0]] : jsonSchema;
+    return {
+      name: tool.name,
+      description: tool.description,
+      inputSchema,
+      handler: async (input) => {
+        return tool.invoke(input);
+      }
+    };
+  });
+}
+function createCodegenTool(domainDocumentation, environment) {
+  return {
+    name: "sess",
+    description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from "./sandbox-tools":
+
+${domainDocumentation}
+
+Write complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: 'TypeScript code to execute. Must import tools from "./sandbox-tools" and use await for all tool calls.'
+        }
+      },
+      required: ["code"]
+    },
+    handler: async (input) => {
+      const { code } = input;
+      const job = await environment.submitJob(code);
+      return job.result;
+    }
+  };
+}
+
+exports.createCodegenTool = createCodegenTool;
+exports.fromLangChainTools = fromLangChainTools;
+//# sourceMappingURL=langchain.js.map
+//# sourceMappingURL=langchain.js.map

package/dist/adapters/langchain.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/langchain.ts"],"names":["zodToJsonSchema"],"mappings":";;;;;AAcO,SAAS,mBAAmB,cAAA,EAAqD;AACpF,EAAA,OAAO,cAAA,CAAe,GAAA,CAAI,CAAC,IAAA,KAAS;AAEhC,IAAA,MAAM,UAAA,GAAkBA,+BAAA,CAAgB,IAAA,CAAK,MAAM,CAAA;AAGnD,IAAA,MAAM,WAAA,GAAc,UAAA,CAAW,UAAA,GAAa,UAAA,GAAc,WAAW,WAAA,GAAc,UAAA,CAAW,WAAA,CAAY,MAAA,CAAO,KAAK,UAAA,CAAW,WAAW,CAAA,CAAE,CAAC,CAAC,CAAA,GAAI,UAAA;AAEpJ,IAAA,OAAO;AAAA,MACH,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,aAAa,IAAA,CAAK,WAAA;AAAA,MAClB,WAAA;AAAA,MACA,OAAA,EAAS,OAAO,KAAA,KAAe;AAG3B,QAAA,OAAO,IAAA,CAAK,OAAO,KAAY,CAAA;AAAA,MACnC;AAAA,KACJ;AAAA,EACJ,CAAC,CAAA;AACL;AAaO,SAAS,iBAAA,CACZ,qBACA,WAAA,EACe;AACf,EAAA,OAAO;AAAA,IACH,IAAA,EAAM,MAAA;AAAA,IACN,WAAA,EAAa,CAAA;;AAAA,EAEnB,mBAAmB;;AAAA,sGAAA,CAAA;AAAA,IAGb,WAAA,EAAa;AAAA,MACT,IAAA,EAAM,QAAA;AAAA,MACN,UAAA,EAAY;AAAA,QACR,IAAA,EAAM;AAAA,UACF,IAAA,EAAM,QAAA;AAAA,UACN,WAAA,EAAa;AAAA;AACjB,OACJ;AAAA,MACA,QAAA,EAAU,CAAC,MAAM;AAAA,KACrB;AAAA,IACA,OAAA,EAAS,OAAO,KAAA,KAAe;AAC3B,MAAA,MAAM,EAAE,MAAK,GAAI,KAAA;AACjB,MAAA,MAAM,GAAA,GAAM,MAAM,WAAA,CAAY,SAAA,CAAU,IAAI,CAAA;AAC5C,MAAA,OAAO,GAAA,CAAI,MAAA;AAAA,IACf;AAAA,GACJ;AACJ","file":"langchain.js","sourcesContent":["import { z } from 'zod';\nimport { StructuredTool } from '@langchain/core/tools';\nimport type { ToolWithHandler } from '../types';\nimport { zodToJsonSchema } from 'zod-to-json-schema';\n\n/**\n * Helper to convert LangChain tools to Granular tools.\n * \n * Note: Since Granular tools execute handlers in the wrapper/client process\n * via reverse-RPC, we can just wrap the LangChain tool's call method directly.\n * \n * @param langchainTools - Array of LangChain StructuredTools\n * @returns Array of Granular ToolWithHandler\n */\nexport function fromLangChainTools(langchainTools: StructuredTool[]): ToolWithHandler[] {\n    return langchainTools.map((tool) => {\n        // Zod to JSON Schema conversion\n        const jsonSchema: any = zodToJsonSchema(tool.schema);\n        // Remove $schema and properties wrapper if present, simplify for tool definition\n        // This is a simplified conversion, might need adjustment based on specific Zod schemas\n        const inputSchema = jsonSchema.properties ? jsonSchema : (jsonSchema.definitions ? jsonSchema.definitions[Object.keys(jsonSchema.definitions)[0]] : jsonSchema);\n\n        return {\n            name: tool.name,\n            description: tool.description,\n            inputSchema: inputSchema as Record<string, unknown>,\n            handler: async (input: any) => {\n                // Determine if input is a string or object based on expectations\n                // LangChain tools expect specific inputs\n                return tool.invoke(input as any);\n            },\n        };\n    });\n}\n\n/**\n * Create a single \"codegen tool\" for LangChain agent consumption.\n * \n * Instead of passing N individual tools to the agent, this returns a single\n * tool that accepts TypeScript code. The LLM writes code that uses the\n * available tools, and the code is executed in the sandbox.\n * \n * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())\n * @param environment - The connected Granular environment\n * @returns A LangChain StructuredTool\n */\nexport function createCodegenTool(\n    domainDocumentation: string,\n    environment: { submitJob: (code: string) => Promise<{ result: Promise<unknown> }> }\n): ToolWithHandler {\n    return {\n        name: 'sess',\n        description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from \"./sandbox-tools\":\n\n${domainDocumentation}\n\nWrite complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,\n        inputSchema: {\n            type: 'object',\n            properties: {\n                code: {\n                    type: 'string',\n                    description: 'TypeScript code to execute. Must import tools from \"./sandbox-tools\" and use await for all tool calls.',\n                },\n            },\n            required: ['code'],\n        },\n        handler: async (input: any) => {\n            const { code } = input as { code: string };\n            const job = await environment.submitJob(code);\n            return job.result;\n        },\n    };\n}\n"]}

package/dist/adapters/langchain.mjs

@@ -0,0 +1,46 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+// src/adapters/langchain.ts
+function fromLangChainTools(langchainTools) {
+  return langchainTools.map((tool) => {
+    const jsonSchema = zodToJsonSchema(tool.schema);
+    const inputSchema = jsonSchema.properties ? jsonSchema : jsonSchema.definitions ? jsonSchema.definitions[Object.keys(jsonSchema.definitions)[0]] : jsonSchema;
+    return {
+      name: tool.name,
+      description: tool.description,
+      inputSchema,
+      handler: async (input) => {
+        return tool.invoke(input);
+      }
+    };
+  });
+}
+function createCodegenTool(domainDocumentation, environment) {
+  return {
+    name: "sess",
+    description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from "./sandbox-tools":
+
+${domainDocumentation}
+
+Write complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: 'TypeScript code to execute. Must import tools from "./sandbox-tools" and use await for all tool calls.'
+        }
+      },
+      required: ["code"]
+    },
+    handler: async (input) => {
+      const { code } = input;
+      const job = await environment.submitJob(code);
+      return job.result;
+    }
+  };
+}
+
+export { createCodegenTool, fromLangChainTools };
+//# sourceMappingURL=langchain.mjs.map
+//# sourceMappingURL=langchain.mjs.map

package/dist/adapters/langchain.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/langchain.ts"],"names":[],"mappings":";;;AAcO,SAAS,mBAAmB,cAAA,EAAqD;AACpF,EAAA,OAAO,cAAA,CAAe,GAAA,CAAI,CAAC,IAAA,KAAS;AAEhC,IAAA,MAAM,UAAA,GAAkB,eAAA,CAAgB,IAAA,CAAK,MAAM,CAAA;AAGnD,IAAA,MAAM,WAAA,GAAc,UAAA,CAAW,UAAA,GAAa,UAAA,GAAc,WAAW,WAAA,GAAc,UAAA,CAAW,WAAA,CAAY,MAAA,CAAO,KAAK,UAAA,CAAW,WAAW,CAAA,CAAE,CAAC,CAAC,CAAA,GAAI,UAAA;AAEpJ,IAAA,OAAO;AAAA,MACH,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,aAAa,IAAA,CAAK,WAAA;AAAA,MAClB,WAAA;AAAA,MACA,OAAA,EAAS,OAAO,KAAA,KAAe;AAG3B,QAAA,OAAO,IAAA,CAAK,OAAO,KAAY,CAAA;AAAA,MACnC;AAAA,KACJ;AAAA,EACJ,CAAC,CAAA;AACL;AAaO,SAAS,iBAAA,CACZ,qBACA,WAAA,EACe;AACf,EAAA,OAAO;AAAA,IACH,IAAA,EAAM,MAAA;AAAA,IACN,WAAA,EAAa,CAAA;;AAAA,EAEnB,mBAAmB;;AAAA,sGAAA,CAAA;AAAA,IAGb,WAAA,EAAa;AAAA,MACT,IAAA,EAAM,QAAA;AAAA,MACN,UAAA,EAAY;AAAA,QACR,IAAA,EAAM;AAAA,UACF,IAAA,EAAM,QAAA;AAAA,UACN,WAAA,EAAa;AAAA;AACjB,OACJ;AAAA,MACA,QAAA,EAAU,CAAC,MAAM;AAAA,KACrB;AAAA,IACA,OAAA,EAAS,OAAO,KAAA,KAAe;AAC3B,MAAA,MAAM,EAAE,MAAK,GAAI,KAAA;AACjB,MAAA,MAAM,GAAA,GAAM,MAAM,WAAA,CAAY,SAAA,CAAU,IAAI,CAAA;AAC5C,MAAA,OAAO,GAAA,CAAI,MAAA;AAAA,IACf;AAAA,GACJ;AACJ","file":"langchain.mjs","sourcesContent":["import { z } from 'zod';\nimport { StructuredTool } from '@langchain/core/tools';\nimport type { ToolWithHandler } from '../types';\nimport { zodToJsonSchema } from 'zod-to-json-schema';\n\n/**\n * Helper to convert LangChain tools to Granular tools.\n * \n * Note: Since Granular tools execute handlers in the wrapper/client process\n * via reverse-RPC, we can just wrap the LangChain tool's call method directly.\n * \n * @param langchainTools - Array of LangChain StructuredTools\n * @returns Array of Granular ToolWithHandler\n */\nexport function fromLangChainTools(langchainTools: StructuredTool[]): ToolWithHandler[] {\n    return langchainTools.map((tool) => {\n        // Zod to JSON Schema conversion\n        const jsonSchema: any = zodToJsonSchema(tool.schema);\n        // Remove $schema and properties wrapper if present, simplify for tool definition\n        // This is a simplified conversion, might need adjustment based on specific Zod schemas\n        const inputSchema = jsonSchema.properties ? jsonSchema : (jsonSchema.definitions ? jsonSchema.definitions[Object.keys(jsonSchema.definitions)[0]] : jsonSchema);\n\n        return {\n            name: tool.name,\n            description: tool.description,\n            inputSchema: inputSchema as Record<string, unknown>,\n            handler: async (input: any) => {\n                // Determine if input is a string or object based on expectations\n                // LangChain tools expect specific inputs\n                return tool.invoke(input as any);\n            },\n        };\n    });\n}\n\n/**\n * Create a single \"codegen tool\" for LangChain agent consumption.\n * \n * Instead of passing N individual tools to the agent, this returns a single\n * tool that accepts TypeScript code. The LLM writes code that uses the\n * available tools, and the code is executed in the sandbox.\n * \n * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())\n * @param environment - The connected Granular environment\n * @returns A LangChain StructuredTool\n */\nexport function createCodegenTool(\n    domainDocumentation: string,\n    environment: { submitJob: (code: string) => Promise<{ result: Promise<unknown> }> }\n): ToolWithHandler {\n    return {\n        name: 'sess',\n        description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from \"./sandbox-tools\":\n\n${domainDocumentation}\n\nWrite complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,\n        inputSchema: {\n            type: 'object',\n            properties: {\n                code: {\n                    type: 'string',\n                    description: 'TypeScript code to execute. Must import tools from \"./sandbox-tools\" and use await for all tool calls.',\n                },\n            },\n            required: ['code'],\n        },\n        handler: async (input: any) => {\n            const { code } = input as { code: string };\n            const job = await environment.submitJob(code);\n            return job.result;\n        },\n    };\n}\n"]}

package/dist/adapters/mastra.d.mts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { T as ToolWithHandler } from '../types-D46q5WTh.mjs';
+
+/**
+ * Mastra tool definition interface
+ */
+interface MastraTool {
+    id: string;
+    description?: string;
+    inputSchema?: z.ZodType<unknown>;
+    execute?: (context: {
+        context: unknown;
+    }) => Promise<unknown>;
+}
+/**
+ * Helper to convert Mastra tools to Granular tools
+ *
+ * @param mastraTools - Array of Mastra tools
+ * @returns Array of Granular ToolWithHandler
+ */
+declare function fromMastraTools(mastraTools: MastraTool[]): ToolWithHandler[];
+
+export { type MastraTool, fromMastraTools };

package/dist/adapters/mastra.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { T as ToolWithHandler } from '../types-D46q5WTh.js';
+
+/**
+ * Mastra tool definition interface
+ */
+interface MastraTool {
+    id: string;
+    description?: string;
+    inputSchema?: z.ZodType<unknown>;
+    execute?: (context: {
+        context: unknown;
+    }) => Promise<unknown>;
+}
+/**
+ * Helper to convert Mastra tools to Granular tools
+ *
+ * @param mastraTools - Array of Mastra tools
+ * @returns Array of Granular ToolWithHandler
+ */
+declare function fromMastraTools(mastraTools: MastraTool[]): ToolWithHandler[];
+
+export { type MastraTool, fromMastraTools };

package/dist/adapters/mastra.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var zodToJsonSchema = require('zod-to-json-schema');
+
+// src/adapters/mastra.ts
+function fromMastraTools(mastraTools) {
+  return mastraTools.map((tool) => {
+    const jsonSchema = tool.inputSchema ? zodToJsonSchema.zodToJsonSchema(tool.inputSchema) : {};
+    return {
+      name: tool.id,
+      // Mastra uses ID as name
+      description: tool.description || "",
+      inputSchema: jsonSchema,
+      handler: async (input) => {
+        if (tool.execute) {
+          return tool.execute({ context: input });
+        }
+        return {};
+      }
+    };
+  });
+}
+
+exports.fromMastraTools = fromMastraTools;
+//# sourceMappingURL=mastra.js.map
+//# sourceMappingURL=mastra.js.map

package/dist/adapters/mastra.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/mastra.ts"],"names":["zodToJsonSchema"],"mappings":";;;;;AAoBO,SAAS,gBAAgB,WAAA,EAA8C;AAC1E,EAAA,OAAO,WAAA,CAAY,GAAA,CAAI,CAAC,IAAA,KAAS;AAC7B,IAAA,MAAM,aAAa,IAAA,CAAK,WAAA,GAAcA,gCAAgB,IAAA,CAAK,WAAW,IAAI,EAAC;AAE3E,IAAA,OAAO;AAAA,MACH,MAAM,IAAA,CAAK,EAAA;AAAA;AAAA,MACX,WAAA,EAAa,KAAK,WAAA,IAAe,EAAA;AAAA,MACjC,WAAA,EAAa,UAAA;AAAA,MACb,OAAA,EAAS,OAAO,KAAA,KAAe;AAC3B,QAAA,IAAI,KAAK,OAAA,EAAS;AACd,UAAA,OAAO,IAAA,CAAK,OAAA,CAAQ,EAAE,OAAA,EAAS,OAAO,CAAA;AAAA,QAC1C;AACA,QAAA,OAAO,EAAC;AAAA,MACZ;AAAA,KACJ;AAAA,EACJ,CAAC,CAAA;AACL","file":"mastra.js","sourcesContent":["import { z } from 'zod';\nimport type { ToolWithHandler } from '../types';\nimport { zodToJsonSchema } from 'zod-to-json-schema';\n\n/**\n * Mastra tool definition interface\n */\nexport interface MastraTool {\n    id: string;\n    description?: string;\n    inputSchema?: z.ZodType<unknown>;\n    execute?: (context: { context: unknown }) => Promise<unknown>;\n}\n\n/**\n * Helper to convert Mastra tools to Granular tools\n * \n * @param mastraTools - Array of Mastra tools\n * @returns Array of Granular ToolWithHandler\n */\nexport function fromMastraTools(mastraTools: MastraTool[]): ToolWithHandler[] {\n    return mastraTools.map((tool) => {\n        const jsonSchema = tool.inputSchema ? zodToJsonSchema(tool.inputSchema) : {};\n\n        return {\n            name: tool.id, // Mastra uses ID as name\n            description: tool.description || '',\n            inputSchema: jsonSchema as Record<string, unknown>,\n            handler: async (input: any) => {\n                if (tool.execute) {\n                    return tool.execute({ context: input });\n                }\n                return {};\n            },\n        };\n    });\n}\n"]}

package/dist/adapters/mastra.mjs

@@ -0,0 +1,24 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+// src/adapters/mastra.ts
+function fromMastraTools(mastraTools) {
+  return mastraTools.map((tool) => {
+    const jsonSchema = tool.inputSchema ? zodToJsonSchema(tool.inputSchema) : {};
+    return {
+      name: tool.id,
+      // Mastra uses ID as name
+      description: tool.description || "",
+      inputSchema: jsonSchema,
+      handler: async (input) => {
+        if (tool.execute) {
+          return tool.execute({ context: input });
+        }
+        return {};
+      }
+    };
+  });
+}
+
+export { fromMastraTools };
+//# sourceMappingURL=mastra.mjs.map
+//# sourceMappingURL=mastra.mjs.map

package/dist/adapters/mastra.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/mastra.ts"],"names":[],"mappings":";;;AAoBO,SAAS,gBAAgB,WAAA,EAA8C;AAC1E,EAAA,OAAO,WAAA,CAAY,GAAA,CAAI,CAAC,IAAA,KAAS;AAC7B,IAAA,MAAM,aAAa,IAAA,CAAK,WAAA,GAAc,gBAAgB,IAAA,CAAK,WAAW,IAAI,EAAC;AAE3E,IAAA,OAAO;AAAA,MACH,MAAM,IAAA,CAAK,EAAA;AAAA;AAAA,MACX,WAAA,EAAa,KAAK,WAAA,IAAe,EAAA;AAAA,MACjC,WAAA,EAAa,UAAA;AAAA,MACb,OAAA,EAAS,OAAO,KAAA,KAAe;AAC3B,QAAA,IAAI,KAAK,OAAA,EAAS;AACd,UAAA,OAAO,IAAA,CAAK,OAAA,CAAQ,EAAE,OAAA,EAAS,OAAO,CAAA;AAAA,QAC1C;AACA,QAAA,OAAO,EAAC;AAAA,MACZ;AAAA,KACJ;AAAA,EACJ,CAAC,CAAA;AACL","file":"mastra.mjs","sourcesContent":["import { z } from 'zod';\nimport type { ToolWithHandler } from '../types';\nimport { zodToJsonSchema } from 'zod-to-json-schema';\n\n/**\n * Mastra tool definition interface\n */\nexport interface MastraTool {\n    id: string;\n    description?: string;\n    inputSchema?: z.ZodType<unknown>;\n    execute?: (context: { context: unknown }) => Promise<unknown>;\n}\n\n/**\n * Helper to convert Mastra tools to Granular tools\n * \n * @param mastraTools - Array of Mastra tools\n * @returns Array of Granular ToolWithHandler\n */\nexport function fromMastraTools(mastraTools: MastraTool[]): ToolWithHandler[] {\n    return mastraTools.map((tool) => {\n        const jsonSchema = tool.inputSchema ? zodToJsonSchema(tool.inputSchema) : {};\n\n        return {\n            name: tool.id, // Mastra uses ID as name\n            description: tool.description || '',\n            inputSchema: jsonSchema as Record<string, unknown>,\n            handler: async (input: any) => {\n                if (tool.execute) {\n                    return tool.execute({ context: input });\n                }\n                return {};\n            },\n        };\n    });\n}\n"]}

package/dist/adapters/openai.d.mts

@@ -0,0 +1,76 @@
+import { T as ToolWithHandler } from '../types-D46q5WTh.mjs';
+
+/**
+ * OpenAI tool call from chat completion response
+ */
+interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * OpenAI tool definition type
+ */
+interface OpenAIToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+/**
+ * Helper to convert Granular tools to OpenAI tool definitions
+ *
+ * @param tools - Array of Granular tools
+ * @returns Array of OpenAI tool definitions
+ */
+declare function toOpenAITools(tools: ToolWithHandler[]): OpenAIToolDefinition[];
+/**
+ * Helper to convert OpenAI tool calls to job code for Granular
+ *
+ * @param toolCalls - Array of tool calls from OpenAI response
+ * @param customImports - Optional imports to add to top of job
+ * @returns generated job code
+ */
+declare function toolCallsToJobCode(toolCalls: OpenAIToolCall[], customImports?: string): string;
+/**
+ * Create a single "codegen tool" for LLM consumption.
+ *
+ * Instead of passing N individual tools to the LLM, this returns a single
+ * tool that accepts TypeScript code. The LLM writes code that uses the
+ * available tools, and the code is executed in the sandbox.
+ *
+ * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())
+ * @returns A single OpenAI tool definition
+ *
+ * @example
+ * ```typescript
+ * const docs = await environment.getDomainDocumentation();
+ * const codegenTool = createCodegenTool(docs);
+ *
+ * const response = await openai.chat.completions.create({
+ *   model: 'gpt-4',
+ *   messages: [...],
+ *   tools: [codegenTool],
+ * });
+ * ```
+ */
+declare function createCodegenTool(domainDocumentation: string): OpenAIToolDefinition;
+/**
+ * Helper to execute a codegen tool call result.
+ *
+ * @param toolCall - The tool call from the OpenAI response
+ * @param environment - The connected Granular environment
+ * @returns The job result
+ */
+declare function executeCodegenToolCall(toolCall: OpenAIToolCall, environment: {
+    submitJob: (code: string) => Promise<{
+        result: Promise<unknown>;
+    }>;
+}): Promise<unknown>;
+
+export { type OpenAIToolCall, type OpenAIToolDefinition, createCodegenTool, executeCodegenToolCall, toOpenAITools, toolCallsToJobCode };

package/dist/adapters/openai.d.ts

@@ -0,0 +1,76 @@
+import { T as ToolWithHandler } from '../types-D46q5WTh.js';
+
+/**
+ * OpenAI tool call from chat completion response
+ */
+interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * OpenAI tool definition type
+ */
+interface OpenAIToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+/**
+ * Helper to convert Granular tools to OpenAI tool definitions
+ *
+ * @param tools - Array of Granular tools
+ * @returns Array of OpenAI tool definitions
+ */
+declare function toOpenAITools(tools: ToolWithHandler[]): OpenAIToolDefinition[];
+/**
+ * Helper to convert OpenAI tool calls to job code for Granular
+ *
+ * @param toolCalls - Array of tool calls from OpenAI response
+ * @param customImports - Optional imports to add to top of job
+ * @returns generated job code
+ */
+declare function toolCallsToJobCode(toolCalls: OpenAIToolCall[], customImports?: string): string;
+/**
+ * Create a single "codegen tool" for LLM consumption.
+ *
+ * Instead of passing N individual tools to the LLM, this returns a single
+ * tool that accepts TypeScript code. The LLM writes code that uses the
+ * available tools, and the code is executed in the sandbox.
+ *
+ * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())
+ * @returns A single OpenAI tool definition
+ *
+ * @example
+ * ```typescript
+ * const docs = await environment.getDomainDocumentation();
+ * const codegenTool = createCodegenTool(docs);
+ *
+ * const response = await openai.chat.completions.create({
+ *   model: 'gpt-4',
+ *   messages: [...],
+ *   tools: [codegenTool],
+ * });
+ * ```
+ */
+declare function createCodegenTool(domainDocumentation: string): OpenAIToolDefinition;
+/**
+ * Helper to execute a codegen tool call result.
+ *
+ * @param toolCall - The tool call from the OpenAI response
+ * @param environment - The connected Granular environment
+ * @returns The job result
+ */
+declare function executeCodegenToolCall(toolCall: OpenAIToolCall, environment: {
+    submitJob: (code: string) => Promise<{
+        result: Promise<unknown>;
+    }>;
+}): Promise<unknown>;
+
+export { type OpenAIToolCall, type OpenAIToolDefinition, createCodegenTool, executeCodegenToolCall, toOpenAITools, toolCallsToJobCode };

package/dist/adapters/openai.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// src/adapters/openai.ts
+function toOpenAITools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }));
+}
+function toolCallsToJobCode(toolCalls, customImports = "") {
+  if (!toolCalls || toolCalls.length === 0) {
+    return "";
+  }
+  let code = `
+        import { tools } from './sandbox-tools';
+        ${customImports}
+        const results = [];
+    `;
+  toolCalls.forEach((call) => {
+    code += `
+        try {
+            const result_${call.id.replace(/-/g, "_")} = await tools.${call.function.name}(${call.function.arguments});
+            results.push({ 
+                toolCallId: "${call.id}", 
+                tool: "${call.function.name}", 
+                result: result_${call.id.replace(/-/g, "_")} 
+            });
+        } catch (error) {
+            results.push({ 
+                toolCallId: "${call.id}", 
+                tool: "${call.function.name}", 
+                error: String(error) 
+            });
+        }
+        `;
+  });
+  code += `return results;`;
+  return code;
+}
+function createCodegenTool(domainDocumentation) {
+  return {
+    type: "function",
+    function: {
+      name: "execute_sandbox_code",
+      description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from "./sandbox-tools":
+
+${domainDocumentation}
+
+Write complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,
+      parameters: {
+        type: "object",
+        properties: {
+          code: {
+            type: "string",
+            description: 'TypeScript code to execute. Must import tools from "./sandbox-tools" and use await for all tool calls.'
+          }
+        },
+        required: ["code"]
+      }
+    }
+  };
+}
+async function executeCodegenToolCall(toolCall, environment) {
+  if (toolCall.function.name !== "execute_sandbox_code") {
+    throw new Error(`Unknown tool: ${toolCall.function.name}`);
+  }
+  const args = JSON.parse(toolCall.function.arguments);
+  const job = await environment.submitJob(args.code);
+  return job.result;
+}
+
+exports.createCodegenTool = createCodegenTool;
+exports.executeCodegenToolCall = executeCodegenToolCall;
+exports.toOpenAITools = toOpenAITools;
+exports.toolCallsToJobCode = toolCallsToJobCode;
+//# sourceMappingURL=openai.js.map
+//# sourceMappingURL=openai.js.map

package/dist/adapters/openai.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/openai.ts"],"names":[],"mappings":";;;AAgCO,SAAS,cAAc,KAAA,EAAkD;AAC5E,EAAA,OAAO,KAAA,CAAM,IAAI,CAAA,IAAA,MAAS;AAAA,IACtB,IAAA,EAAM,UAAA;AAAA,IACN,QAAA,EAAU;AAAA,MACN,MAAM,IAAA,CAAK,IAAA;AAAA,MACX,aAAa,IAAA,CAAK,WAAA;AAAA,MAClB,YAAY,IAAA,CAAK;AAAA;AACrB,GACJ,CAAE,CAAA;AACN;AASO,SAAS,kBAAA,CAAmB,SAAA,EAA6B,aAAA,GAAgB,EAAA,EAAY;AACxF,EAAA,IAAI,CAAC,SAAA,IAAa,SAAA,CAAU,MAAA,KAAW,CAAA,EAAG;AACtC,IAAA,OAAO,EAAA;AAAA,EACX;AAEA,EAAA,IAAI,IAAA,GAAO;AAAA;AAAA,QAAA,EAEL,aAAa;AAAA;AAAA,IAAA,CAAA;AAInB,EAAA,SAAA,CAAU,OAAA,CAAQ,CAAC,IAAA,KAAS;AAGxB,IAAA,IAAA,IAAQ;AAAA;AAAA,yBAAA,EAEW,IAAA,CAAK,EAAA,CAAG,OAAA,CAAQ,IAAA,EAAM,GAAG,CAAC,CAAA,eAAA,EAAkB,IAAA,CAAK,QAAA,CAAS,IAAI,CAAA,CAAA,EAAI,IAAA,CAAK,SAAS,SAAS,CAAA;AAAA;AAAA,6BAAA,EAErF,KAAK,EAAE,CAAA;AAAA,uBAAA,EACb,IAAA,CAAK,SAAS,IAAI,CAAA;AAAA,+BAAA,EACV,IAAA,CAAK,EAAA,CAAG,OAAA,CAAQ,IAAA,EAAM,GAAG,CAAC,CAAA;AAAA;AAAA;AAAA;AAAA,6BAAA,EAI5B,KAAK,EAAE,CAAA;AAAA,uBAAA,EACb,IAAA,CAAK,SAAS,IAAI,CAAA;AAAA;AAAA;AAAA;AAAA,QAAA,CAAA;AAAA,EAKvC,CAAC,CAAA;AAED,EAAA,IAAA,IAAQ,CAAA,eAAA,CAAA;AACR,EAAA,OAAO,IAAA;AACX;AAwBO,SAAS,kBAAkB,mBAAA,EAAmD;AACjF,EAAA,OAAO;AAAA,IACH,IAAA,EAAM,UAAA;AAAA,IACN,QAAA,EAAU;AAAA,MACN,IAAA,EAAM,sBAAA;AAAA,MACN,WAAA,EAAa,CAAA;;AAAA,EAEvB,mBAAmB;;AAAA,sGAAA,CAAA;AAAA,MAGT,UAAA,EAAY;AAAA,QACR,IAAA,EAAM,QAAA;AAAA,QACN,UAAA,EAAY;AAAA,UACR,IAAA,EAAM;AAAA,YACF,IAAA,EAAM,QAAA;AAAA,YACN,WAAA,EAAa;AAAA;AACjB,SACJ;AAAA,QACA,QAAA,EAAU,CAAC,MAAM;AAAA;AACrB;AACJ,GACJ;AACJ;AASA,eAAsB,sBAAA,CAClB,UACA,WAAA,EACgB;AAChB,EAAA,IAAI,QAAA,CAAS,QAAA,CAAS,IAAA,KAAS,sBAAA,EAAwB;AACnD,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,cAAA,EAAiB,QAAA,CAAS,QAAA,CAAS,IAAI,CAAA,CAAE,CAAA;AAAA,EAC7D;AAEA,EAAA,MAAM,IAAA,GAAO,IAAA,CAAK,KAAA,CAAM,QAAA,CAAS,SAAS,SAAS,CAAA;AACnD,EAAA,MAAM,GAAA,GAAM,MAAM,WAAA,CAAY,SAAA,CAAU,KAAK,IAAI,CAAA;AACjD,EAAA,OAAO,GAAA,CAAI,MAAA;AACf","file":"openai.js","sourcesContent":["import type { ToolWithHandler } from '../types';\n\n/**\n * OpenAI tool call from chat completion response\n */\nexport interface OpenAIToolCall {\n    id: string;\n    type: 'function';\n    function: {\n        name: string;\n        arguments: string;\n    };\n}\n\n/**\n * OpenAI tool definition type\n */\nexport interface OpenAIToolDefinition {\n    type: 'function';\n    function: {\n        name: string;\n        description?: string;\n        parameters?: Record<string, unknown>;\n    };\n}\n\n/**\n * Helper to convert Granular tools to OpenAI tool definitions\n * \n * @param tools - Array of Granular tools\n * @returns Array of OpenAI tool definitions\n */\nexport function toOpenAITools(tools: ToolWithHandler[]): OpenAIToolDefinition[] {\n    return tools.map(tool => ({\n        type: 'function',\n        function: {\n            name: tool.name,\n            description: tool.description,\n            parameters: tool.inputSchema,\n        },\n    }));\n}\n\n/**\n * Helper to convert OpenAI tool calls to job code for Granular\n * \n * @param toolCalls - Array of tool calls from OpenAI response\n * @param customImports - Optional imports to add to top of job\n * @returns generated job code\n */\nexport function toolCallsToJobCode(toolCalls: OpenAIToolCall[], customImports = ''): string {\n    if (!toolCalls || toolCalls.length === 0) {\n        return '';\n    }\n\n    let code = `\n        import { tools } from './sandbox-tools';\n        ${customImports}\n        const results = [];\n    `;\n\n    toolCalls.forEach((call) => {\n        // Safe argument parsing\n        // We trust OpenAI arguments are JSON, but we stringify them again for the job\n        code += `\n        try {\n            const result_${call.id.replace(/-/g, '_')} = await tools.${call.function.name}(${call.function.arguments});\n            results.push({ \n                toolCallId: \"${call.id}\", \n                tool: \"${call.function.name}\", \n                result: result_${call.id.replace(/-/g, '_')} \n            });\n        } catch (error) {\n            results.push({ \n                toolCallId: \"${call.id}\", \n                tool: \"${call.function.name}\", \n                error: String(error) \n            });\n        }\n        `;\n    });\n\n    code += `return results;`;\n    return code;\n}\n\n/**\n * Create a single \"codegen tool\" for LLM consumption.\n * \n * Instead of passing N individual tools to the LLM, this returns a single\n * tool that accepts TypeScript code. The LLM writes code that uses the\n * available tools, and the code is executed in the sandbox.\n * \n * @param domainDocumentation - Documentation of available tools (from environment.getDomainDocumentation())\n * @returns A single OpenAI tool definition\n * \n * @example\n * ```typescript\n * const docs = await environment.getDomainDocumentation();\n * const codegenTool = createCodegenTool(docs);\n * \n * const response = await openai.chat.completions.create({\n *   model: 'gpt-4',\n *   messages: [...],\n *   tools: [codegenTool],\n * });\n * ```\n */\nexport function createCodegenTool(domainDocumentation: string): OpenAIToolDefinition {\n    return {\n        type: 'function',\n        function: {\n            name: 'execute_sandbox_code',\n            description: `Execute TypeScript code in a secure sandbox environment. The code can use the following tools by importing from \"./sandbox-tools\":\n\n${domainDocumentation}\n\nWrite complete, executable TypeScript code. Use async/await for tool calls. Return results at the end.`,\n            parameters: {\n                type: 'object',\n                properties: {\n                    code: {\n                        type: 'string',\n                        description: 'TypeScript code to execute. Must import tools from \"./sandbox-tools\" and use await for all tool calls.',\n                    },\n                },\n                required: ['code'],\n            },\n        },\n    };\n}\n\n/**\n * Helper to execute a codegen tool call result.\n * \n * @param toolCall - The tool call from the OpenAI response\n * @param environment - The connected Granular environment\n * @returns The job result\n */\nexport async function executeCodegenToolCall(\n    toolCall: OpenAIToolCall,\n    environment: { submitJob: (code: string) => Promise<{ result: Promise<unknown> }> }\n): Promise<unknown> {\n    if (toolCall.function.name !== 'execute_sandbox_code') {\n        throw new Error(`Unknown tool: ${toolCall.function.name}`);\n    }\n\n    const args = JSON.parse(toolCall.function.arguments) as { code: string };\n    const job = await environment.submitJob(args.code);\n    return job.result;\n}\n"]}