@granular-software/sdk 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@granular-software/sdk",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "TypeScript SDK and CLI for Granular - define, build, and deploy AI sandboxes",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -10,30 +10,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
-    },
-    "./mastra": {
-      "types": "./dist/adapters/mastra.d.ts",
-      "import": "./dist/adapters/mastra.mjs",
-      "require": "./dist/adapters/mastra.js"
-    },
-    "./langchain": {
-      "types": "./dist/adapters/langchain.d.ts",
-      "import": "./dist/adapters/langchain.mjs",
-      "require": "./dist/adapters/langchain.js"
-    },
-    "./openai": {
-      "types": "./dist/adapters/openai.d.ts",
-      "import": "./dist/adapters/openai.mjs",
-      "require": "./dist/adapters/openai.js"
-    },
-    "./anthropic": {
-      "types": "./dist/adapters/anthropic.d.ts",
-      "import": "./dist/adapters/anthropic.mjs",
-      "require": "./dist/adapters/anthropic.js"
     }
   },
   "bin": {
-    "granular": "./dist/cli/index.js"
+    "granular": "dist/cli/index.js"
   },
   "files": [
     "dist",
@@ -57,17 +37,14 @@
     "ai",
     "agent",
     "tools",
-    "sandbox",
-    "mastra",
-    "langchain",
-    "openai",
-    "anthropic"
+    "sandbox"
   ],
   "author": "Granular Team",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/granular-dev/granular-sdk"
+    "url": "git+https://github.com/ahirel/granular-software.git",
+    "directory": "packages/granular-sdk"
   },
   "dependencies": {
     "@automerge/automerge": "^3.2.1",
@@ -79,36 +56,13 @@
     "zod-to-json-schema": "^3.25.1"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.10.0",
-    "@langchain/core": "^0.1.0",
     "@types/commander": "^2.12.5",
     "@types/node": "^25.2.3",
     "@types/ws": "^8.18.1",
-    "openai": "^4.0.0",
-    "tsup": "^8.0.0",
+    "tsup": "8.5.0",
     "typescript": "^5.0.0",
     "zod": "3.25.76"
   },
-  "peerDependencies": {
-    "@mastra/core": ">=0.1.0",
-    "@langchain/core": ">=0.1.0",
-    "openai": ">=4.0.0",
-    "@anthropic-ai/sdk": ">=0.10.0"
-  },
-  "peerDependenciesMeta": {
-    "@mastra/core": {
-      "optional": true
-    },
-    "@langchain/core": {
-      "optional": true
-    },
-    "openai": {
-      "optional": true
-    },
-    "@anthropic-ai/sdk": {
-      "optional": true
-    }
-  },
   "engines": {
     "node": ">=18.0.0"
   }

package/dist/adapters/anthropic.d.mts

@@ -1,64 +0,0 @@
-import { T as ToolWithHandler } from '../types-C0AVRsVR.mjs';
-
-/**
- * Anthropic tool_use block from message response
- */
-interface AnthropicToolUseBlock {
-    type: 'tool_use';
-    id: string;
-    name: string;
-    input: unknown;
-}
-/**
- * Anthropic tool definition
- */
-interface AnthropicToolDefinition {
-    name: string;
-    description?: string;
-    input_schema: Record<string, unknown>;
-}
-/**
- * Helper to convert Granular tools to Anthropic tool definitions
- *
- * @param tools - Array of Granular tools
- * @returns Array of Anthropic tool definitions
- */
-declare function toAnthropicTools(tools: ToolWithHandler[]): AnthropicToolDefinition[];
-/**
- * Helper to convert Anthropic tool calls to job code for Granular
- *
- * @param contentBlocks - Array of content blocks from Anthropic response
- * @param customImports - Optional imports to add to top of job
- * @returns generated job code, or null if no tool uses found
- */
-declare function toolUsesToJobCode(contentBlocks: Array<{
-    type: string;
-    id?: string;
-    name?: string;
-    input?: unknown;
-}>, customImports?: string): string | null;
-/**
- * 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 Anthropic tool definition
- */
-declare function createCodegenTool(domainDocumentation: string): AnthropicToolDefinition;
-/**
- * Helper to execute a codegen tool use block.
- *
- * @param toolUse - The tool_use block from the Anthropic response
- * @param environment - The connected Granular environment
- * @returns The job result
- */
-declare function executeCodegenToolUse(toolUse: AnthropicToolUseBlock, environment: {
-    submitJob: (code: string) => Promise<{
-        result: Promise<unknown>;
-    }>;
-}): Promise<unknown>;
-
-export { type AnthropicToolDefinition, type AnthropicToolUseBlock, createCodegenTool, executeCodegenToolUse, toAnthropicTools, toolUsesToJobCode };

package/dist/adapters/anthropic.d.ts

@@ -1,64 +0,0 @@
-import { T as ToolWithHandler } from '../types-C0AVRsVR.js';
-
-/**
- * Anthropic tool_use block from message response
- */
-interface AnthropicToolUseBlock {
-    type: 'tool_use';
-    id: string;
-    name: string;
-    input: unknown;
-}
-/**
- * Anthropic tool definition
- */
-interface AnthropicToolDefinition {
-    name: string;
-    description?: string;
-    input_schema: Record<string, unknown>;
-}
-/**
- * Helper to convert Granular tools to Anthropic tool definitions
- *
- * @param tools - Array of Granular tools
- * @returns Array of Anthropic tool definitions
- */
-declare function toAnthropicTools(tools: ToolWithHandler[]): AnthropicToolDefinition[];
-/**
- * Helper to convert Anthropic tool calls to job code for Granular
- *
- * @param contentBlocks - Array of content blocks from Anthropic response
- * @param customImports - Optional imports to add to top of job
- * @returns generated job code, or null if no tool uses found
- */
-declare function toolUsesToJobCode(contentBlocks: Array<{
-    type: string;
-    id?: string;
-    name?: string;
-    input?: unknown;
-}>, customImports?: string): string | null;
-/**
- * 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 Anthropic tool definition
- */
-declare function createCodegenTool(domainDocumentation: string): AnthropicToolDefinition;
-/**
- * Helper to execute a codegen tool use block.
- *
- * @param toolUse - The tool_use block from the Anthropic response
- * @param environment - The connected Granular environment
- * @returns The job result
- */
-declare function executeCodegenToolUse(toolUse: AnthropicToolUseBlock, environment: {
-    submitJob: (code: string) => Promise<{
-        result: Promise<unknown>;
-    }>;
-}): Promise<unknown>;
-
-export { type AnthropicToolDefinition, type AnthropicToolUseBlock, createCodegenTool, executeCodegenToolUse, toAnthropicTools, toolUsesToJobCode };

package/dist/adapters/anthropic.js

@@ -1,77 +0,0 @@
-'use strict';
-
-// 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;
-}
-
-exports.createCodegenTool = createCodegenTool;
-exports.executeCodegenToolUse = executeCodegenToolUse;
-exports.toAnthropicTools = toAnthropicTools;
-exports.toolUsesToJobCode = toolUsesToJobCode;
-//# sourceMappingURL=anthropic.js.map
-//# sourceMappingURL=anthropic.js.map

package/dist/adapters/anthropic.js.map

@@ -1 +0,0 @@
-{"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.js","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/anthropic.mjs

@@ -1,72 +0,0 @@
-// 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

@@ -1 +0,0 @@
-{"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

@@ -1,31 +0,0 @@
-import { StructuredTool } from '@langchain/core/tools';
-import { T as ToolWithHandler } from '../types-C0AVRsVR.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

@@ -1,31 +0,0 @@
-import { StructuredTool } from '@langchain/core/tools';
-import { T as ToolWithHandler } from '../types-C0AVRsVR.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

@@ -1,49 +0,0 @@
-'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

@@ -1 +0,0 @@
-{"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

@@ -1,46 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-import { T as ToolWithHandler } from '../types-C0AVRsVR.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

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-import { T as ToolWithHandler } from '../types-C0AVRsVR.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

@@ -1,26 +0,0 @@
-'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