@tanstack/ai-code-mode 0.2.12 → 0.3.0

package/dist/esm/create-code-mode-tool.d.ts

@@ -1,50 +0,0 @@
-import { z } from 'zod';
-import { ServerTool } from '@tanstack/ai';
-import { CodeModeToolConfig } from './types.js';
-/**
- * Schema for the execute_typescript tool input
- */
-declare const executeTypescriptInputSchema: z.ZodObject<{
-    typescriptCode: z.ZodString;
-}, z.core.$strip>;
-/**
- * Schema for the execute_typescript tool output
- */
-declare const executeTypescriptOutputSchema: z.ZodObject<{
-    success: z.ZodBoolean;
-    result: z.ZodOptional<z.ZodUnknown>;
-    logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    error: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        line: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ExecuteTypescriptInput = z.infer<typeof executeTypescriptInputSchema>;
-export type ExecuteTypescriptOutput = z.infer<typeof executeTypescriptOutputSchema>;
-/**
- * Create an execute_typescript tool that can be used alongside other agent tools.
- *
- * This tool allows an LLM to execute TypeScript code in a secure sandbox.
- * Tools passed in the config become `external_*` functions available inside the sandbox.
- *
- * @example
- * ```typescript
- * import { createCodeMode } from '@tanstack/ai-code-mode'
- * import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'
- *
- * const { tool, systemPrompt } = createCodeMode({
- *   driver: createNodeIsolateDriver(),
- *   tools: [weatherTool, dbTool],  // Become external_fetchWeather, external_dbQuery
- *   timeout: 30000,
- * })
- *
- * chat({
- *   systemPrompts: [myPrompt, systemPrompt],
- *   tools: [tool, searchTool, emailTool],
- *   messages,
- * })
- * ```
- */
-export declare function createCodeModeTool(config: CodeModeToolConfig): ServerTool<typeof executeTypescriptInputSchema, typeof executeTypescriptOutputSchema, 'execute_typescript'>;
-export {};

package/dist/esm/create-code-mode-tool.js

@@ -1,143 +0,0 @@
-import { z } from "zod";
-import { toolDefinition } from "@tanstack/ai";
-import { toolsToBindings, createEventAwareBindings } from "./bindings/tool-to-binding.js";
-import { stripTypeScript } from "./strip-typescript.js";
-const executeTypescriptInputSchema = z.object({
-  typescriptCode: z.string().describe(
-    "TypeScript code to execute in the sandbox. Use external_* functions to call available APIs. Return a value to pass results back."
-  )
-});
-const executeTypescriptOutputSchema = z.object({
-  success: z.boolean().describe("Whether execution completed without errors"),
-  result: z.unknown().optional().describe("Return value from the executed code"),
-  logs: z.array(z.string()).optional().describe("Console output captured during execution"),
-  error: z.object({
-    message: z.string(),
-    name: z.string().optional(),
-    line: z.number().optional()
-  }).optional().describe("Error details if execution failed")
-});
-function createCodeModeTool(config) {
-  const {
-    driver,
-    tools,
-    timeout = 3e4,
-    memoryLimit = 128,
-    getSkillBindings,
-    transpile = stripTypeScript
-  } = config;
-  if (tools.length === 0) {
-    throw new Error("At least one tool must be provided to createCodeModeTool");
-  }
-  const staticBindings = toolsToBindings(tools, "external_");
-  const definition = toolDefinition({
-    name: "execute_typescript",
-    description: buildToolDescription(tools),
-    inputSchema: executeTypescriptInputSchema,
-    outputSchema: executeTypescriptOutputSchema
-  });
-  return definition.server(
-    async (input, toolContext) => {
-      const { typescriptCode } = input;
-      const emitCustomEvent = toolContext?.emitCustomEvent || (() => {
-      });
-      if (!typescriptCode || typeof typescriptCode !== "string") {
-        return {
-          success: false,
-          error: {
-            message: "typescriptCode must be a non-empty string",
-            name: "ValidationError"
-          }
-        };
-      }
-      let isolateContext = null;
-      emitCustomEvent("code_mode:execution_started", {
-        timestamp: Date.now(),
-        codeLength: typescriptCode.length
-      });
-      try {
-        let strippedCode;
-        try {
-          strippedCode = await transpile(typescriptCode);
-        } catch (error) {
-          return {
-            success: false,
-            error: {
-              message: error instanceof Error ? error.message : String(error),
-              name: "TypeScriptError"
-            }
-          };
-        }
-        const skillBindings = getSkillBindings ? await getSkillBindings() : {};
-        const allBindings = { ...staticBindings, ...skillBindings };
-        const eventAwareBindings = createEventAwareBindings(
-          allBindings,
-          emitCustomEvent
-        );
-        isolateContext = await driver.createContext({
-          bindings: eventAwareBindings,
-          timeout,
-          memoryLimit
-        });
-        const executionResult = await isolateContext.execute(strippedCode);
-        if (executionResult.logs && executionResult.logs.length > 0) {
-          for (const log of executionResult.logs) {
-            let level = "log";
-            let message = log;
-            if (log.startsWith("ERROR: ")) {
-              level = "error";
-              message = log.slice(7);
-            } else if (log.startsWith("WARN: ")) {
-              level = "warn";
-              message = log.slice(6);
-            } else if (log.startsWith("INFO: ")) {
-              level = "info";
-              message = log.slice(6);
-            }
-            emitCustomEvent("code_mode:console", {
-              level,
-              message,
-              timestamp: Date.now()
-            });
-          }
-        }
-        if (executionResult.success) {
-          return {
-            success: true,
-            result: executionResult.value,
-            logs: executionResult.logs
-          };
-        } else {
-          return {
-            success: false,
-            error: executionResult.error ? {
-              message: executionResult.error.message,
-              name: executionResult.error.name
-            } : { message: "Unknown execution error" },
-            logs: executionResult.logs
-          };
-        }
-      } catch (error) {
-        return {
-          success: false,
-          error: {
-            message: error instanceof Error ? error.message : String(error),
-            name: error instanceof Error ? error.name : "Error"
-          }
-        };
-      } finally {
-        if (isolateContext) {
-          await isolateContext.dispose();
-        }
-      }
-    }
-  );
-}
-function buildToolDescription(tools) {
-  const externalFunctions = tools.map((t) => `external_${t.name}`).join(", ");
-  return `Execute TypeScript code in a secure sandbox environment. The code can use these external API functions: ${externalFunctions}. All external_* calls are async and must be awaited. Return a value to pass results back. Use console.log() for debugging.`;
-}
-export {
-  createCodeModeTool
-};
-//# sourceMappingURL=create-code-mode-tool.js.map

package/dist/esm/create-code-mode-tool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-code-mode-tool.js","sources":["../../src/create-code-mode-tool.ts"],"sourcesContent":["import { z } from 'zod'\nimport { toolDefinition } from '@tanstack/ai'\nimport {\n  createEventAwareBindings,\n  toolsToBindings,\n} from './bindings/tool-to-binding'\nimport { stripTypeScript } from './strip-typescript'\nimport type { ServerTool, ToolExecutionContext } from '@tanstack/ai'\nimport type {\n  CodeModeTool,\n  CodeModeToolConfig,\n  CodeModeToolResult,\n  IsolateContext,\n} from './types'\n\n/**\n * Schema for the execute_typescript tool input\n */\nconst executeTypescriptInputSchema = z.object({\n  typescriptCode: z\n    .string()\n    .describe(\n      'TypeScript code to execute in the sandbox. ' +\n        'Use external_* functions to call available APIs. ' +\n        'Return a value to pass results back.',\n    ),\n})\n\n/**\n * Schema for the execute_typescript tool output\n */\nconst executeTypescriptOutputSchema = z.object({\n  success: z.boolean().describe('Whether execution completed without errors'),\n  result: z\n    .unknown()\n    .optional()\n    .describe('Return value from the executed code'),\n  logs: z\n    .array(z.string())\n    .optional()\n    .describe('Console output captured during execution'),\n  error: z\n    .object({\n      message: z.string(),\n      name: z.string().optional(),\n      line: z.number().optional(),\n    })\n    .optional()\n    .describe('Error details if execution failed'),\n})\n\nexport type ExecuteTypescriptInput = z.infer<\n  typeof executeTypescriptInputSchema\n>\nexport type ExecuteTypescriptOutput = z.infer<\n  typeof executeTypescriptOutputSchema\n>\n\n/**\n * Create an execute_typescript tool that can be used alongside other agent tools.\n *\n * This tool allows an LLM to execute TypeScript code in a secure sandbox.\n * Tools passed in the config become `external_*` functions available inside the sandbox.\n *\n * @example\n * ```typescript\n * import { createCodeMode } from '@tanstack/ai-code-mode'\n * import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'\n *\n * const { tool, systemPrompt } = createCodeMode({\n *   driver: createNodeIsolateDriver(),\n *   tools: [weatherTool, dbTool],  // Become external_fetchWeather, external_dbQuery\n *   timeout: 30000,\n * })\n *\n * chat({\n *   systemPrompts: [myPrompt, systemPrompt],\n *   tools: [tool, searchTool, emailTool],\n *   messages,\n * })\n * ```\n */\nexport function createCodeModeTool(\n  config: CodeModeToolConfig,\n): ServerTool<\n  typeof executeTypescriptInputSchema,\n  typeof executeTypescriptOutputSchema,\n  'execute_typescript'\n> {\n  const {\n    driver,\n    tools,\n    timeout = 30000,\n    memoryLimit = 128,\n    getSkillBindings,\n    transpile = stripTypeScript,\n  } = config\n\n  // Validate tools\n  if (tools.length === 0) {\n    throw new Error('At least one tool must be provided to createCodeModeTool')\n  }\n\n  // Transform tools to bindings with external_ prefix (static bindings)\n  const staticBindings = toolsToBindings(tools, 'external_')\n\n  // Create the tool definition\n  const definition = toolDefinition({\n    name: 'execute_typescript' as const,\n    description: buildToolDescription(tools),\n    inputSchema: executeTypescriptInputSchema,\n    outputSchema: executeTypescriptOutputSchema,\n  })\n\n  // Return server tool with execute function that accepts context\n  return definition.server(\n    async (\n      input,\n      toolContext?: ToolExecutionContext,\n    ): Promise<CodeModeToolResult> => {\n      const { typescriptCode } = input\n\n      // Get emitCustomEvent from context or use no-op\n      const emitCustomEvent = toolContext?.emitCustomEvent || (() => {})\n\n      if (!typescriptCode || typeof typescriptCode !== 'string') {\n        return {\n          success: false,\n          error: {\n            message: 'typescriptCode must be a non-empty string',\n            name: 'ValidationError',\n          },\n        }\n      }\n\n      // Create a fresh sandbox context for this execution\n      let isolateContext: IsolateContext | null = null\n\n      // Emit execution started event immediately\n      emitCustomEvent('code_mode:execution_started', {\n        timestamp: Date.now(),\n        codeLength: typescriptCode.length,\n      })\n\n      try {\n        // Step 1: Strip TypeScript (also serves as syntax validation via the\n        // transpiler — sucrase by default, or a user-supplied `transpile`)\n        let strippedCode: string\n        try {\n          strippedCode = await transpile(typescriptCode)\n        } catch (error) {\n          // Type/syntax error from the transpiler\n          return {\n            success: false,\n            error: {\n              message: error instanceof Error ? error.message : String(error),\n              name: 'TypeScriptError',\n            },\n          }\n        }\n\n        // Step 2: Get dynamic skill bindings if available\n        const skillBindings = getSkillBindings ? await getSkillBindings() : {}\n\n        // Step 3: Merge static and dynamic bindings, then wrap with event awareness\n        const allBindings = { ...staticBindings, ...skillBindings }\n        const eventAwareBindings = createEventAwareBindings(\n          allBindings,\n          emitCustomEvent,\n        )\n\n        // Step 4: Create sandbox context with event-aware bindings\n        isolateContext = await driver.createContext({\n          bindings: eventAwareBindings,\n          timeout,\n          memoryLimit,\n        })\n\n        // Step 5: Execute the code in the sandbox\n        const executionResult = await isolateContext.execute(strippedCode)\n\n        // Emit console logs as custom events\n        if (executionResult.logs && executionResult.logs.length > 0) {\n          for (const log of executionResult.logs) {\n            // Parse log level from prefix (added by sandbox console implementation)\n            let level: 'log' | 'warn' | 'error' | 'info' = 'log'\n            let message = log\n\n            if (log.startsWith('ERROR: ')) {\n              level = 'error'\n              message = log.slice(7)\n            } else if (log.startsWith('WARN: ')) {\n              level = 'warn'\n              message = log.slice(6)\n            } else if (log.startsWith('INFO: ')) {\n              level = 'info'\n              message = log.slice(6)\n            }\n\n            emitCustomEvent('code_mode:console', {\n              level,\n              message,\n              timestamp: Date.now(),\n            })\n          }\n        }\n\n        if (executionResult.success) {\n          return {\n            success: true,\n            result: executionResult.value,\n            logs: executionResult.logs,\n          }\n        } else {\n          return {\n            success: false,\n            error: executionResult.error\n              ? {\n                  message: executionResult.error.message,\n                  name: executionResult.error.name,\n                }\n              : { message: 'Unknown execution error' },\n            logs: executionResult.logs,\n          }\n        }\n      } catch (error) {\n        return {\n          success: false,\n          error: {\n            message: error instanceof Error ? error.message : String(error),\n            name: error instanceof Error ? error.name : 'Error',\n          },\n        }\n      } finally {\n        // Always clean up the sandbox context\n        if (isolateContext) {\n          await isolateContext.dispose()\n        }\n      }\n    },\n  )\n}\n\n/**\n * Build the tool description including available external functions\n */\nfunction buildToolDescription(tools: Array<CodeModeTool>): string {\n  const externalFunctions = tools.map((t) => `external_${t.name}`).join(', ')\n\n  return (\n    `Execute TypeScript code in a secure sandbox environment. ` +\n    `The code can use these external API functions: ${externalFunctions}. ` +\n    `All external_* calls are async and must be awaited. ` +\n    `Return a value to pass results back. Use console.log() for debugging.`\n  )\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/create-code-mode.d.ts

@@ -1,41 +0,0 @@
-import { CodeModeToolConfig } from './types.js';
-/**
- * Create both the `execute_typescript` tool and its matching system prompt
- * from a single config object.
- *
- * This is the recommended way to set up Code Mode — it ensures the tool and
- * system prompt always stay in sync.
- *
- * @example
- * ```typescript
- * import { createCodeMode } from '@tanstack/ai-code-mode'
- * import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'
- *
- * const { tool, systemPrompt } = createCodeMode({
- *   driver: createNodeIsolateDriver(),
- *   tools: [weatherTool, dbTool],
- *   timeout: 30000,
- * })
- *
- * chat({
- *   systemPrompts: [myPrompt, systemPrompt],
- *   tools: [tool, ...otherTools],
- *   messages,
- * })
- * ```
- */
-export declare function createCodeMode(config: CodeModeToolConfig): {
-    tool: import('@tanstack/ai').ServerTool<import('zod').ZodObject<{
-        typescriptCode: import('zod').ZodString;
-    }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
-        success: import('zod').ZodBoolean;
-        result: import('zod').ZodOptional<import('zod').ZodUnknown>;
-        logs: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString>>;
-        error: import('zod').ZodOptional<import('zod').ZodObject<{
-            message: import('zod').ZodString;
-            name: import('zod').ZodOptional<import('zod').ZodString>;
-            line: import('zod').ZodOptional<import('zod').ZodNumber>;
-        }, import('zod/v4/core').$strip>>;
-    }, import('zod/v4/core').$strip>, "execute_typescript", unknown>;
-    systemPrompt: string;
-};

package/dist/esm/create-code-mode.js

@@ -1,12 +0,0 @@
-import { createCodeModeTool } from "./create-code-mode-tool.js";
-import { createCodeModeSystemPrompt } from "./create-system-prompt.js";
-function createCodeMode(config) {
-  return {
-    tool: createCodeModeTool(config),
-    systemPrompt: createCodeModeSystemPrompt(config)
-  };
-}
-export {
-  createCodeMode
-};
-//# sourceMappingURL=create-code-mode.js.map

package/dist/esm/create-code-mode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-code-mode.js","sources":["../../src/create-code-mode.ts"],"sourcesContent":["import { createCodeModeTool } from './create-code-mode-tool'\nimport { createCodeModeSystemPrompt } from './create-system-prompt'\nimport type { CodeModeToolConfig } from './types'\n\n/**\n * Create both the `execute_typescript` tool and its matching system prompt\n * from a single config object.\n *\n * This is the recommended way to set up Code Mode — it ensures the tool and\n * system prompt always stay in sync.\n *\n * @example\n * ```typescript\n * import { createCodeMode } from '@tanstack/ai-code-mode'\n * import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'\n *\n * const { tool, systemPrompt } = createCodeMode({\n *   driver: createNodeIsolateDriver(),\n *   tools: [weatherTool, dbTool],\n *   timeout: 30000,\n * })\n *\n * chat({\n *   systemPrompts: [myPrompt, systemPrompt],\n *   tools: [tool, ...otherTools],\n *   messages,\n * })\n * ```\n */\nexport function createCodeMode(config: CodeModeToolConfig) {\n  return {\n    tool: createCodeModeTool(config),\n    systemPrompt: createCodeModeSystemPrompt(config),\n  }\n}\n"],"names":[],"mappings":";;AA6BO,SAAS,eAAe,QAA4B;AACzD,SAAO;AAAA,IACL,MAAM,mBAAmB,MAAM;AAAA,IAC/B,cAAc,2BAA2B,MAAM;AAAA,EAAA;AAEnD;"}

package/dist/esm/create-system-prompt.d.ts

@@ -1,24 +0,0 @@
-import { CodeModeToolConfig } from './types.js';
-/**
- * Create a system prompt snippet that documents the execute_typescript tool
- * and all available external_* functions.
- *
- * Add this to your system prompts array when using createCodeModeTool.
- *
- * @example
- * ```typescript
- * import { createCodeMode } from '@tanstack/ai-code-mode'
- * import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'
- *
- * const { tool, systemPrompt } = createCodeMode({
- *   driver: createNodeIsolateDriver(),
- *   tools: [weatherTool, dbTool],
- * })
- *
- * chat({
- *   systemPrompts: ['You are a helpful assistant.', systemPrompt],
- *   tools: [tool, ...otherTools],
- * })
- * ```
- */
-export declare function createCodeModeSystemPrompt(config: CodeModeToolConfig): string;

package/dist/esm/create-system-prompt.js

@@ -1,66 +0,0 @@
-import { toolsToBindings } from "./bindings/tool-to-binding.js";
-import { generateTypeStubs } from "./type-generator/json-schema-to-ts.js";
-function createCodeModeSystemPrompt(config) {
-  const { tools } = config;
-  const bindings = toolsToBindings(tools, "external_");
-  const typeStubs = generateTypeStubs(bindings);
-  const functionDocs = Object.entries(bindings).map(([name, binding]) => {
-    const doc = `- \`${name}(input)\`: ${binding.description}`;
-    return doc;
-  }).join("\n");
-  return `## Code Execution Tool
-
-You have access to \`execute_typescript\` which runs TypeScript code in a sandboxed environment.
-
-### When to Use
-
-Use \`execute_typescript\` when you need to:
-- Process data with loops, conditionals, or complex logic
-- Make multiple API calls in parallel (Promise.all)
-- Transform, filter, or aggregate data
-- Perform calculations or data analysis
-
-For simple operations, prefer calling tools directly.
-
-### Available External APIs
-
-Inside your TypeScript code, you can call these async functions:
-
-${functionDocs}
-
-### Type Definitions
-
-\`\`\`typescript
-${typeStubs}
-\`\`\`
-
-### Example
-
-\`\`\`typescript
-// Fetch weather for multiple cities in parallel
-const cities = ["Tokyo", "Paris", "NYC"];
-const results = await Promise.all(
-  cities.map(city => external_fetchWeather({ location: city }))
-);
-
-// Find the warmest city
-const warmest = results.reduce((prev, curr) => 
-  curr.temperature > prev.temperature ? curr : prev
-);
-
-return { warmestCity: warmest.location, temperature: warmest.temperature };
-\`\`\`
-
-### Important Notes
-
-- All \`external_*\` calls are async - always use \`await\`
-- Return a value to pass results back to you
-- Use \`console.log()\` for debugging (logs are captured)
-- The sandbox is isolated - no network access or file system
-- Each execution is independent (no shared state between calls)
-`;
-}
-export {
-  createCodeModeSystemPrompt
-};
-//# sourceMappingURL=create-system-prompt.js.map

package/dist/esm/create-system-prompt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-system-prompt.js","sources":["../../src/create-system-prompt.ts"],"sourcesContent":["import { toolsToBindings } from './bindings/tool-to-binding'\nimport { generateTypeStubs } from './type-generator/json-schema-to-ts'\nimport type { CodeModeToolConfig } from './types'\n\n/**\n * Create a system prompt snippet that documents the execute_typescript tool\n * and all available external_* functions.\n *\n * Add this to your system prompts array when using createCodeModeTool.\n *\n * @example\n * ```typescript\n * import { createCodeMode } from '@tanstack/ai-code-mode'\n * import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'\n *\n * const { tool, systemPrompt } = createCodeMode({\n *   driver: createNodeIsolateDriver(),\n *   tools: [weatherTool, dbTool],\n * })\n *\n * chat({\n *   systemPrompts: ['You are a helpful assistant.', systemPrompt],\n *   tools: [tool, ...otherTools],\n * })\n * ```\n */\nexport function createCodeModeSystemPrompt(config: CodeModeToolConfig): string {\n  const { tools } = config\n\n  // Transform tools to bindings with external_ prefix to generate correct type stubs\n  const bindings = toolsToBindings(tools, 'external_')\n\n  // Generate TypeScript type stubs for the external functions\n  const typeStubs = generateTypeStubs(bindings)\n\n  // Build function documentation\n  const functionDocs = Object.entries(bindings)\n    .map(([name, binding]) => {\n      const doc = `- \\`${name}(input)\\`: ${binding.description}`\n      return doc\n    })\n    .join('\\n')\n\n  return `## Code Execution Tool\n\nYou have access to \\`execute_typescript\\` which runs TypeScript code in a sandboxed environment.\n\n### When to Use\n\nUse \\`execute_typescript\\` when you need to:\n- Process data with loops, conditionals, or complex logic\n- Make multiple API calls in parallel (Promise.all)\n- Transform, filter, or aggregate data\n- Perform calculations or data analysis\n\nFor simple operations, prefer calling tools directly.\n\n### Available External APIs\n\nInside your TypeScript code, you can call these async functions:\n\n${functionDocs}\n\n### Type Definitions\n\n\\`\\`\\`typescript\n${typeStubs}\n\\`\\`\\`\n\n### Example\n\n\\`\\`\\`typescript\n// Fetch weather for multiple cities in parallel\nconst cities = [\"Tokyo\", \"Paris\", \"NYC\"];\nconst results = await Promise.all(\n  cities.map(city => external_fetchWeather({ location: city }))\n);\n\n// Find the warmest city\nconst warmest = results.reduce((prev, curr) => \n  curr.temperature > prev.temperature ? curr : prev\n);\n\nreturn { warmestCity: warmest.location, temperature: warmest.temperature };\n\\`\\`\\`\n\n### Important Notes\n\n- All \\`external_*\\` calls are async - always use \\`await\\`\n- Return a value to pass results back to you\n- Use \\`console.log()\\` for debugging (logs are captured)\n- The sandbox is isolated - no network access or file system\n- Each execution is independent (no shared state between calls)\n`\n}\n"],"names":[],"mappings":";;AA0BO,SAAS,2BAA2B,QAAoC;AAC7E,QAAM,EAAE,UAAU;AAGlB,QAAM,WAAW,gBAAgB,OAAO,WAAW;AAGnD,QAAM,YAAY,kBAAkB,QAAQ;AAG5C,QAAM,eAAe,OAAO,QAAQ,QAAQ,EACzC,IAAI,CAAC,CAAC,MAAM,OAAO,MAAM;AACxB,UAAM,MAAM,OAAO,IAAI,cAAc,QAAQ,WAAW;AACxD,WAAO;AAAA,EACT,CAAC,EACA,KAAK,IAAI;AAEZ,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBP,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA,EAKZ,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BX;"}

package/dist/esm/index.d.ts

@@ -1,10 +0,0 @@
-export { createCodeModeTool } from './create-code-mode-tool.js';
-export type { ExecuteTypescriptInput, ExecuteTypescriptOutput, } from './create-code-mode-tool.js';
-export { createCodeModeSystemPrompt } from './create-system-prompt.js';
-export { createCodeMode } from './create-code-mode.js';
-export { InMemoryAgentStore, generateAgentName, type AgentSession, type AgentStore, } from './agent-store.js';
-export { toolToBinding, toolsToBindings, createEventAwareBindings, } from './bindings/tool-to-binding.js';
-export { generateTypeStubs, jsonSchemaToTypeScript, type TypeGeneratorOptions, } from './type-generator/json-schema-to-ts.js';
-export { stripTypeScript } from './strip-typescript.js';
-export { wrapCode } from './code-wrapper.js';
-export type { CodeModeToolConfig, CodeModeToolResult, IsolateDriver, IsolateConfig, IsolateContext, ExecutionResult, NormalizedError, ToolBinding, CodeModeTool, ToolExecutionContext, } from './types.js';

package/dist/esm/index.js

@@ -1,23 +0,0 @@
-import { createCodeModeTool } from "./create-code-mode-tool.js";
-import { createCodeModeSystemPrompt } from "./create-system-prompt.js";
-import { createCodeMode } from "./create-code-mode.js";
-import { InMemoryAgentStore, generateAgentName } from "./agent-store.js";
-import { createEventAwareBindings, toolToBinding, toolsToBindings } from "./bindings/tool-to-binding.js";
-import { generateTypeStubs, jsonSchemaToTypeScript } from "./type-generator/json-schema-to-ts.js";
-import { stripTypeScript } from "./strip-typescript.js";
-import { wrapCode } from "./code-wrapper.js";
-export {
-  InMemoryAgentStore,
-  createCodeMode,
-  createCodeModeSystemPrompt,
-  createCodeModeTool,
-  createEventAwareBindings,
-  generateAgentName,
-  generateTypeStubs,
-  jsonSchemaToTypeScript,
-  stripTypeScript,
-  toolToBinding,
-  toolsToBindings,
-  wrapCode
-};
-//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/esm/strip-typescript.d.ts

@@ -1,44 +0,0 @@
-/**
- * Strip TypeScript syntax from code, converting it to plain JavaScript.
- *
- * This is a safety net to ensure that even if an LLM generates TypeScript
- * code with type annotations, it will be converted to valid JavaScript
- * before being sent to the sandbox for execution.
- *
- * Uses sucrase's pure-JavaScript `transform`, which strips the TypeScript
- * syntax that LLM-generated snippets use in practice:
- * - Type annotations (: string, : number, etc.)
- * - Generic types (Array<T>, Record<K, V>, etc.)
- * - Interface and type declarations
- * - Type assertions
- * - Enums (converted to JavaScript objects)
- *
- * Unlike esbuild, sucrase has no native binary and pulls in no Node-only
- * built-ins on its `transform` path, so this module is safe to bundle for
- * browsers and edge runtimes (Cloudflare Workers/Pages etc.).
- *
- * Limitations vs esbuild: sucrase is a type-stripper, not a down-leveler.
- * `disableESTransforms` leaves modern ECMAScript syntax untouched (the sandbox
- * engines are modern), and sucrase does NOT compile a few exotic constructs:
- * - TypeScript value `namespace`/`module` blocks are DROPPED (not emitted as an
- *   IIFE), so referencing the namespace at runtime throws `ReferenceError`.
- * - Decorators and the `accessor` keyword pass through un-lowered, so the
- *   sandbox sees invalid syntax.
- * - Post-ES2022 syntax (`using` declarations, RegExp `/v`·`/d` flags) is passed
- *   through; it runs on modern V8/Node sandboxes but may fail on older engines
- *   (e.g. QuickJS).
- * If you need any of these, supply a heavier (Node-only) transpiler via the
- * `transpile` option on `createCodeModeTool`.
- *
- * The code is wrapped in an async function before transformation to allow
- * top-level `return` and `await` statements, then unwrapped after.
- *
- * Note on errors: sucrase reports syntax errors with a position relative to the
- * *wrapped* code (offset by the one-line wrapper prefix), so any line numbers
- * surfaced downstream (e.g. `CodeModeToolResult.error.line`) are approximate.
- *
- * @param code - TypeScript or JavaScript code
- * @returns Plain JavaScript code with all type syntax removed
- * @throws Error if sucrase fails (e.g., syntax error) or wrapper extraction fails
- */
-export declare function stripTypeScript(code: string): Promise<string>;

package/dist/esm/strip-typescript.js

@@ -1,49 +0,0 @@
-import { transform } from "sucrase";
-const WRAPPER_START = "___TANSTACK_WRAPPER_START___";
-const WRAPPER_END = "___TANSTACK_WRAPPER_END___";
-async function stripTypeScript(code) {
-  const wrappedCode = `async function ${WRAPPER_START}() {
-${code}
-}; ${WRAPPER_END}`;
-  const result = transform(wrappedCode, {
-    // Only strip/lower TypeScript-specific syntax...
-    transforms: ["typescript"],
-    // ...and leave modern ECMAScript syntax untouched for the sandbox engines.
-    disableESTransforms: true
-  });
-  const transformed = result.code;
-  const functionStart = transformed.indexOf(`async function ${WRAPPER_START}()`);
-  if (functionStart === -1) {
-    throw new Error(
-      "[stripTypeScript] Could not find wrapper function start in transformed output"
-    );
-  }
-  const openBrace = transformed.indexOf("{", functionStart);
-  if (openBrace === -1) {
-    throw new Error(
-      "[stripTypeScript] Could not find opening brace in transformed output"
-    );
-  }
-  const endMarkerIndex = transformed.indexOf(WRAPPER_END);
-  if (endMarkerIndex === -1) {
-    throw new Error(
-      "[stripTypeScript] Could not find end marker in transformed output"
-    );
-  }
-  const codeBeforeEndMarker = transformed.substring(
-    openBrace + 1,
-    endMarkerIndex
-  );
-  const closingBraceIndex = codeBeforeEndMarker.lastIndexOf("}");
-  if (closingBraceIndex === -1) {
-    throw new Error(
-      "[stripTypeScript] Could not find closing brace in transformed output"
-    );
-  }
-  const functionBody = codeBeforeEndMarker.substring(0, closingBraceIndex).trim();
-  return functionBody;
-}
-export {
-  stripTypeScript
-};
-//# sourceMappingURL=strip-typescript.js.map

package/dist/esm/strip-typescript.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strip-typescript.js","sources":["../../src/strip-typescript.ts"],"sourcesContent":["import { transform } from 'sucrase'\n\n// Unique markers for wrapping/unwrapping code\nconst WRAPPER_START = '___TANSTACK_WRAPPER_START___'\nconst WRAPPER_END = '___TANSTACK_WRAPPER_END___'\n\n/**\n * Strip TypeScript syntax from code, converting it to plain JavaScript.\n *\n * This is a safety net to ensure that even if an LLM generates TypeScript\n * code with type annotations, it will be converted to valid JavaScript\n * before being sent to the sandbox for execution.\n *\n * Uses sucrase's pure-JavaScript `transform`, which strips the TypeScript\n * syntax that LLM-generated snippets use in practice:\n * - Type annotations (: string, : number, etc.)\n * - Generic types (Array<T>, Record<K, V>, etc.)\n * - Interface and type declarations\n * - Type assertions\n * - Enums (converted to JavaScript objects)\n *\n * Unlike esbuild, sucrase has no native binary and pulls in no Node-only\n * built-ins on its `transform` path, so this module is safe to bundle for\n * browsers and edge runtimes (Cloudflare Workers/Pages etc.).\n *\n * Limitations vs esbuild: sucrase is a type-stripper, not a down-leveler.\n * `disableESTransforms` leaves modern ECMAScript syntax untouched (the sandbox\n * engines are modern), and sucrase does NOT compile a few exotic constructs:\n * - TypeScript value `namespace`/`module` blocks are DROPPED (not emitted as an\n *   IIFE), so referencing the namespace at runtime throws `ReferenceError`.\n * - Decorators and the `accessor` keyword pass through un-lowered, so the\n *   sandbox sees invalid syntax.\n * - Post-ES2022 syntax (`using` declarations, RegExp `/v`·`/d` flags) is passed\n *   through; it runs on modern V8/Node sandboxes but may fail on older engines\n *   (e.g. QuickJS).\n * If you need any of these, supply a heavier (Node-only) transpiler via the\n * `transpile` option on `createCodeModeTool`.\n *\n * The code is wrapped in an async function before transformation to allow\n * top-level `return` and `await` statements, then unwrapped after.\n *\n * Note on errors: sucrase reports syntax errors with a position relative to the\n * *wrapped* code (offset by the one-line wrapper prefix), so any line numbers\n * surfaced downstream (e.g. `CodeModeToolResult.error.line`) are approximate.\n *\n * @param code - TypeScript or JavaScript code\n * @returns Plain JavaScript code with all type syntax removed\n * @throws Error if sucrase fails (e.g., syntax error) or wrapper extraction fails\n */\n// sucrase's transform is synchronous, but we keep the published Promise-returning\n// signature so existing `await stripTypeScript(...)` callers (and a custom async\n// `transpile` hook) stay source-compatible across this swap.\n// eslint-disable-next-line @typescript-eslint/require-await\nexport async function stripTypeScript(code: string): Promise<string> {\n  // Wrap the code in an async function to allow top-level return/await.\n  // This is necessary because top-level `return` is invalid outside a function.\n  const wrappedCode = `async function ${WRAPPER_START}() {\\n${code}\\n}; ${WRAPPER_END}`\n\n  const result = transform(wrappedCode, {\n    // Only strip/lower TypeScript-specific syntax...\n    transforms: ['typescript'],\n    // ...and leave modern ECMAScript syntax untouched for the sandbox engines.\n    disableESTransforms: true,\n  })\n\n  // Extract the code from inside the wrapper function\n  const transformed = result.code\n\n  // Find the function declaration start\n  const functionStart = transformed.indexOf(`async function ${WRAPPER_START}()`)\n  if (functionStart === -1) {\n    throw new Error(\n      '[stripTypeScript] Could not find wrapper function start in transformed output',\n    )\n  }\n\n  // Find the opening brace of the function\n  const openBrace = transformed.indexOf('{', functionStart)\n  if (openBrace === -1) {\n    throw new Error(\n      '[stripTypeScript] Could not find opening brace in transformed output',\n    )\n  }\n\n  // Find the end marker (regardless of formatting)\n  const endMarkerIndex = transformed.indexOf(WRAPPER_END)\n  if (endMarkerIndex === -1) {\n    throw new Error(\n      '[stripTypeScript] Could not find end marker in transformed output',\n    )\n  }\n\n  // Find the closing brace of the function (last } before the end marker)\n  // We need to find the } that matches the function opening\n  const codeBeforeEndMarker = transformed.substring(\n    openBrace + 1,\n    endMarkerIndex,\n  )\n\n  // Find the last } before the end marker, accounting for the semicolon\n  // The code will be: ...function body...}; WRAPPER_END or ...};\\nWRAPPER_END\n  const closingBraceIndex = codeBeforeEndMarker.lastIndexOf('}')\n\n  if (closingBraceIndex === -1) {\n    throw new Error(\n      '[stripTypeScript] Could not find closing brace in transformed output',\n    )\n  }\n\n  // Extract the function body (between { and })\n  const functionBody = codeBeforeEndMarker\n    .substring(0, closingBraceIndex)\n    .trim()\n\n  return functionBody\n}\n"],"names":[],"mappings":";AAGA,MAAM,gBAAgB;AACtB,MAAM,cAAc;AAiDpB,eAAsB,gBAAgB,MAA+B;AAGnE,QAAM,cAAc,kBAAkB,aAAa;AAAA,EAAS,IAAI;AAAA,KAAQ,WAAW;AAEnF,QAAM,SAAS,UAAU,aAAa;AAAA;AAAA,IAEpC,YAAY,CAAC,YAAY;AAAA;AAAA,IAEzB,qBAAqB;AAAA,EAAA,CACtB;AAGD,QAAM,cAAc,OAAO;AAG3B,QAAM,gBAAgB,YAAY,QAAQ,kBAAkB,aAAa,IAAI;AAC7E,MAAI,kBAAkB,IAAI;AACxB,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AAGA,QAAM,YAAY,YAAY,QAAQ,KAAK,aAAa;AACxD,MAAI,cAAc,IAAI;AACpB,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AAGA,QAAM,iBAAiB,YAAY,QAAQ,WAAW;AACtD,MAAI,mBAAmB,IAAI;AACzB,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AAIA,QAAM,sBAAsB,YAAY;AAAA,IACtC,YAAY;AAAA,IACZ;AAAA,EAAA;AAKF,QAAM,oBAAoB,oBAAoB,YAAY,GAAG;AAE7D,MAAI,sBAAsB,IAAI;AAC5B,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AAGA,QAAM,eAAe,oBAClB,UAAU,GAAG,iBAAiB,EAC9B,KAAA;AAEH,SAAO;AACT;"}

package/dist/esm/type-generator/json-schema-to-ts.d.ts

@@ -1,31 +0,0 @@
-import { ToolBinding } from '../types.js';
-/**
- * Options for type stub generation
- */
-export interface TypeGeneratorOptions {
-    /**
-     * Include JSDoc comments with descriptions
-     * @default true
-     */
-    includeDescriptions?: boolean;
-}
-/**
- * Generate TypeScript type stubs for all tool bindings
- *
- * These stubs are included in the LLM system prompt so it knows
- * the exact type signatures of available tools.
- *
- * Tool names match the actual function names injected into the sandbox.
- */
-export declare function generateTypeStubs(bindings: Record<string, ToolBinding>, options?: TypeGeneratorOptions): string;
-interface TypeResult {
-    name: string;
-    declaration: string;
-}
-/**
- * Convert a JSON Schema to a TypeScript type
- *
- * Supports basic types: string, number, boolean, object, array
- */
-export declare function jsonSchemaToTypeScript(schema: Record<string, unknown>, typeName: string): TypeResult;
-export {};

package/dist/esm/type-generator/json-schema-to-ts.js

@@ -1,100 +0,0 @@
-function generateTypeStubs(bindings, options = {}) {
-  const { includeDescriptions = true } = options;
-  const declarations = [];
-  for (const [name, binding] of Object.entries(bindings)) {
-    const inputTypeName = `${capitalize(name)}Input`;
-    const outputTypeName = `${capitalize(name)}Output`;
-    const inputType = jsonSchemaToTypeScript(binding.inputSchema, inputTypeName);
-    if (inputType.declaration) {
-      declarations.push(inputType.declaration);
-    }
-    let outputTypeRef = "unknown";
-    if (binding.outputSchema) {
-      const outputType = jsonSchemaToTypeScript(
-        binding.outputSchema,
-        outputTypeName
-      );
-      if (outputType.declaration) {
-        declarations.push(outputType.declaration);
-      }
-      outputTypeRef = outputType.name;
-    }
-    const description = includeDescriptions && binding.description ? `/** ${binding.description} */
-` : "";
-    declarations.push(
-      `${description}declare function ${name}(input: ${inputType.name}): Promise<${outputTypeRef}>;`
-    );
-  }
-  return declarations.join("\n\n");
-}
-function jsonSchemaToTypeScript(schema, typeName) {
-  const type = schemaToType(schema);
-  if (schema.type === "object" && schema.properties && Object.keys(schema.properties).length > 0) {
-    return {
-      name: typeName,
-      declaration: `interface ${typeName} ${type}`
-    };
-  }
-  return {
-    name: type,
-    declaration: ""
-  };
-}
-function schemaToType(schema) {
-  if (typeof schema !== "object") {
-    return "unknown";
-  }
-  const schemaType = schema.type;
-  if (schemaType === "string") return "string";
-  if (schemaType === "number" || schemaType === "integer") return "number";
-  if (schemaType === "boolean") return "boolean";
-  if (schemaType === "null") return "null";
-  if (schemaType === "array") {
-    const items = schema.items;
-    const itemType = items ? schemaToType(items) : "unknown";
-    return `Array<${itemType}>`;
-  }
-  if (schemaType === "object" && schema.properties) {
-    const properties = schema.properties;
-    const required = new Set(
-      schema.required ?? []
-    );
-    const props = Object.entries(properties).map(([key, propSchema]) => {
-      const optional = required.has(key) ? "" : "?";
-      const propType = schemaToType(propSchema);
-      const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
-      return `  ${safeName}${optional}: ${propType};`;
-    }).join("\n");
-    return `{
-${props}
-}`;
-  }
-  if (schema.enum) {
-    const enumValues = schema.enum;
-    return enumValues.map((v) => JSON.stringify(v)).join(" | ");
-  }
-  if (schema.anyOf || schema.oneOf) {
-    const variants = schema.anyOf || schema.oneOf;
-    return variants.map((v) => schemaToType(v)).join(" | ");
-  }
-  if (Array.isArray(schemaType)) {
-    return schemaType.map((t) => {
-      if (t === "string") return "string";
-      if (t === "number" || t === "integer") return "number";
-      if (t === "boolean") return "boolean";
-      if (t === "null") return "null";
-      if (t === "array") return "Array<unknown>";
-      if (t === "object") return "object";
-      return "unknown";
-    }).join(" | ");
-  }
-  return "unknown";
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-export {
-  generateTypeStubs,
-  jsonSchemaToTypeScript
-};
-//# sourceMappingURL=json-schema-to-ts.js.map