@tanstack/ai-code-mode 0.3.8 → 0.3.10

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

@@ -1,24 +1,37 @@
-import { renderLazyCatalogEntry } from "@tanstack/ai";
 import { toolsToBindings } from "./bindings/tool-to-binding.js";
 import { generateTypeStubs } from "./type-generator/json-schema-to-ts.js";
+import { renderLazyCatalogEntry } from "@tanstack/ai";
+//#region src/create-system-prompt.ts
+/**
+* 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],
+* })
+* ```
+*/
 function createCodeModeSystemPrompt(config) {
-  const { tools } = config;
-  const include = config.lazyToolsConfig?.includeDescription ?? "none";
-  const eagerTools = tools.filter((t) => !t.lazy);
-  const lazyTools = tools.filter((t) => t.lazy);
-  const bindings = toolsToBindings(eagerTools, "external_");
-  const typeStubs = generateTypeStubs(bindings);
-  const functionDocs = Object.entries(bindings).map(([name, binding]) => `- \`${name}(input)\`: ${binding.description}`).join("\n");
-  const discoverableSection = lazyTools.length > 0 ? `
-
-### Discoverable APIs
-
-These additional functions are available but not yet documented. Before calling \`external_<name>\` for any of them inside \`execute_typescript\`, call the \`discover_tools\` tool with their names to get full TypeScript signatures:
-
-${lazyTools.map(
-    (t) => `- ${renderLazyCatalogEntry(`external_${t.name}`, t.description, include)}`
-  ).join("\n")}` : "";
-  return `## Code Execution Tool
+	const { tools } = config;
+	const include = config.lazyToolsConfig?.includeDescription ?? "none";
+	const eagerTools = tools.filter((t) => !t.lazy);
+	const lazyTools = tools.filter((t) => t.lazy);
+	const bindings = toolsToBindings(eagerTools, "external_");
+	const typeStubs = generateTypeStubs(bindings);
+	return `## Code Execution Tool
 
 You have access to \`execute_typescript\` which runs TypeScript code in a sandboxed environment.
 
@@ -36,13 +49,19 @@ For simple operations, prefer calling tools directly.
 
 Inside your TypeScript code, you can call these async functions:
 
-${functionDocs}
+${Object.entries(bindings).map(([name, binding]) => `- \`${name}(input)\`: ${binding.description}`).join("\n")}
 
 ### Type Definitions
 
 \`\`\`typescript
 ${typeStubs}
-\`\`\`${discoverableSection}
+\`\`\`${lazyTools.length > 0 ? `
+
+### Discoverable APIs
+
+These additional functions are available but not yet documented. Before calling \`external_<name>\` for any of them inside \`execute_typescript\`, call the \`discover_tools\` tool with their names to get full TypeScript signatures:
+
+${lazyTools.map((t) => `- ${renderLazyCatalogEntry(`external_${t.name}`, t.description, include)}`).join("\n")}` : ""}
 
 ### Example
 
@@ -70,7 +89,7 @@ return { warmestCity: warmest.location, temperature: warmest.temperature };
 - Each execution is independent (no shared state between calls)
 `;
 }
-export {
-  createCodeModeSystemPrompt
-};
-//# sourceMappingURL=create-system-prompt.js.map
+//#endregion
+export { createCodeModeSystemPrompt };
+
+//# sourceMappingURL=create-system-prompt.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"create-system-prompt.js","sources":["../../src/create-system-prompt.ts"],"sourcesContent":["import { renderLazyCatalogEntry } from '@tanstack/ai'\nimport { 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  const include = config.lazyToolsConfig?.includeDescription ?? 'none'\n\n  const eagerTools = tools.filter((t) => !t.lazy)\n  const lazyTools = tools.filter((t) => t.lazy)\n\n  // Only eager tools get full type stubs + doc lines.\n  const bindings = toolsToBindings(eagerTools, 'external_')\n  const typeStubs = generateTypeStubs(bindings)\n\n  const functionDocs = Object.entries(bindings)\n    .map(([name, binding]) => `- \\`${name}(input)\\`: ${binding.description}`)\n    .join('\\n')\n\n  const discoverableSection =\n    lazyTools.length > 0\n      ? `\n\n### Discoverable APIs\n\nThese additional functions are available but not yet documented. Before calling \\`external_<name>\\` for any of them inside \\`execute_typescript\\`, call the \\`discover_tools\\` tool with their names to get full TypeScript signatures:\n\n${lazyTools\n  .map(\n    (t) =>\n      `- ${renderLazyCatalogEntry(`external_${t.name}`, t.description, include)}`,\n  )\n  .join('\\n')}`\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\\`\\`\\`${discoverableSection}\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":";;;AA2BO,SAAS,2BAA2B,QAAoC;AAC7E,QAAM,EAAE,UAAU;AAClB,QAAM,UAAU,OAAO,iBAAiB,sBAAsB;AAE9D,QAAM,aAAa,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI;AAC9C,QAAM,YAAY,MAAM,OAAO,CAAC,MAAM,EAAE,IAAI;AAG5C,QAAM,WAAW,gBAAgB,YAAY,WAAW;AACxD,QAAM,YAAY,kBAAkB,QAAQ;AAE5C,QAAM,eAAe,OAAO,QAAQ,QAAQ,EACzC,IAAI,CAAC,CAAC,MAAM,OAAO,MAAM,OAAO,IAAI,cAAc,QAAQ,WAAW,EAAE,EACvE,KAAK,IAAI;AAEZ,QAAM,sBACJ,UAAU,SAAS,IACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMN,UACC;AAAA,IACC,CAAC,MACC,KAAK,uBAAuB,YAAY,EAAE,IAAI,IAAI,EAAE,aAAa,OAAO,CAAC;AAAA,EAAA,EAE5E,KAAK,IAAI,CAAC,KACL;AAEN,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,QACH,mBAAmB;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;AA2B3B;"}
+{"version":3,"file":"create-system-prompt.js","names":[],"sources":["../../src/create-system-prompt.ts"],"sourcesContent":["import { renderLazyCatalogEntry } from '@tanstack/ai'\nimport { 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  const include = config.lazyToolsConfig?.includeDescription ?? 'none'\n\n  const eagerTools = tools.filter((t) => !t.lazy)\n  const lazyTools = tools.filter((t) => t.lazy)\n\n  // Only eager tools get full type stubs + doc lines.\n  const bindings = toolsToBindings(eagerTools, 'external_')\n  const typeStubs = generateTypeStubs(bindings)\n\n  const functionDocs = Object.entries(bindings)\n    .map(([name, binding]) => `- \\`${name}(input)\\`: ${binding.description}`)\n    .join('\\n')\n\n  const discoverableSection =\n    lazyTools.length > 0\n      ? `\n\n### Discoverable APIs\n\nThese additional functions are available but not yet documented. Before calling \\`external_<name>\\` for any of them inside \\`execute_typescript\\`, call the \\`discover_tools\\` tool with their names to get full TypeScript signatures:\n\n${lazyTools\n  .map(\n    (t) =>\n      `- ${renderLazyCatalogEntry(`external_${t.name}`, t.description, include)}`,\n  )\n  .join('\\n')}`\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\\`\\`\\`${discoverableSection}\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,2BAA2B,QAAoC;CAC7E,MAAM,EAAE,UAAU;CAClB,MAAM,UAAU,OAAO,iBAAiB,sBAAsB;CAE9D,MAAM,aAAa,MAAM,QAAQ,MAAM,CAAC,EAAE,IAAI;CAC9C,MAAM,YAAY,MAAM,QAAQ,MAAM,EAAE,IAAI;CAG5C,MAAM,WAAW,gBAAgB,YAAY,WAAW;CACxD,MAAM,YAAY,kBAAkB,QAAQ;CAsB5C,OAAO;;;;;;;;;;;;;;;;;;EApBc,OAAO,QAAQ,QAAQ,CAAC,CAC1C,KAAK,CAAC,MAAM,aAAa,OAAO,KAAK,aAAa,QAAQ,aAAa,CAAC,CACxE,KAAK,IAoCR,EAAa;;;;;EAKb,UAAU;QAtCR,UAAU,SAAS,IACf;;;;;;EAMN,UACC,KACE,MACC,KAAK,uBAAuB,YAAY,EAAE,QAAQ,EAAE,aAAa,OAAO,GAC5E,CAAC,CACA,KAAK,IAAI,MACJ,GA0BoB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2B5B"}

package/dist/esm/index.js

@@ -1,25 +1,10 @@
+import { createEventAwareBindings, toolToBinding, toolsToBindings } from "./bindings/tool-to-binding.js";
+import { stripTypeScript } from "./strip-typescript.js";
 import { createCodeModeTool } from "./create-code-mode-tool.js";
+import { generateTypeStubs, jsonSchemaToTypeScript } from "./type-generator/json-schema-to-ts.js";
 import { createCodeModeSystemPrompt } from "./create-system-prompt.js";
-import { createCodeMode } from "./create-code-mode.js";
 import { createDiscoveryTool } from "./create-discovery-tool.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,
-  createDiscoveryTool,
-  createEventAwareBindings,
-  generateAgentName,
-  generateTypeStubs,
-  jsonSchemaToTypeScript,
-  stripTypeScript,
-  toolToBinding,
-  toolsToBindings,
-  wrapCode
-};
-//# sourceMappingURL=index.js.map
+export { InMemoryAgentStore, createCodeMode, createCodeModeSystemPrompt, createCodeModeTool, createDiscoveryTool, createEventAwareBindings, generateAgentName, generateTypeStubs, jsonSchemaToTypeScript, stripTypeScript, toolToBinding, toolsToBindings, wrapCode };

package/dist/esm/strip-typescript.js

@@ -1,49 +1,67 @@
 import { transform } from "sucrase";
-const WRAPPER_START = "___TANSTACK_WRAPPER_START___";
-const WRAPPER_END = "___TANSTACK_WRAPPER_END___";
+//#region src/strip-typescript.ts
+var WRAPPER_START = "___TANSTACK_WRAPPER_START___";
+var WRAPPER_END = "___TANSTACK_WRAPPER_END___";
+/**
+* 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
+*/
 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;
+	const transformed = transform(`async function ${WRAPPER_START}() {\n${code}\n}; ${WRAPPER_END}`, {
+		transforms: ["typescript"],
+		disableESTransforms: true
+	}).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");
+	return codeBeforeEndMarker.substring(0, closingBraceIndex).trim();
 }
-export {
-  stripTypeScript
-};
-//# sourceMappingURL=strip-typescript.js.map
+//#endregion
+export { stripTypeScript };
+
+//# sourceMappingURL=strip-typescript.js.map

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

@@ -1 +1 @@
-{"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;"}
+{"version":3,"file":"strip-typescript.js","names":[],"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"],"mappings":";;AAGA,IAAM,gBAAgB;AACtB,IAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDpB,eAAsB,gBAAgB,MAA+B;CAanE,MAAM,cARS,UAAU,kBAFa,cAAc,QAAQ,KAAK,OAAO,eAElC;EAEpC,YAAY,CAAC,YAAY;EAEzB,qBAAqB;CACvB,CAGoB,CAAA,CAAO;CAG3B,MAAM,gBAAgB,YAAY,QAAQ,kBAAkB,cAAc,GAAG;CAC7E,IAAI,kBAAkB,IACpB,MAAM,IAAI,MACR,+EACF;CAIF,MAAM,YAAY,YAAY,QAAQ,KAAK,aAAa;CACxD,IAAI,cAAc,IAChB,MAAM,IAAI,MACR,sEACF;CAIF,MAAM,iBAAiB,YAAY,QAAQ,WAAW;CACtD,IAAI,mBAAmB,IACrB,MAAM,IAAI,MACR,mEACF;CAKF,MAAM,sBAAsB,YAAY,UACtC,YAAY,GACZ,cACF;CAIA,MAAM,oBAAoB,oBAAoB,YAAY,GAAG;CAE7D,IAAI,sBAAsB,IACxB,MAAM,IAAI,MACR,sEACF;CAQF,OAJqB,oBAClB,UAAU,GAAG,iBAAiB,CAAC,CAC/B,KAEI;AACT"}

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

@@ -1,100 +1,90 @@
+//#region src/type-generator/json-schema-to-ts.ts
+/**
+* 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.
+*/
 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");
+	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} */\n` : "";
+		declarations.push(`${description}declare function ${name}(input: ${inputType.name}): Promise<${outputTypeRef}>;`);
+	}
+	return declarations.join("\n\n");
 }
+/**
+* Convert a JSON Schema to a TypeScript type
+*
+* Supports basic types: string, number, boolean, object, array
+*/
 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: ""
-  };
+	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: ""
+	};
 }
+/**
+* Convert a JSON Schema to a TypeScript type string
+*/
 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";
+	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;
+		return `Array<${items ? schemaToType(items) : "unknown"}>`;
+	}
+	if (schemaType === "object" && schema.properties) {
+		const properties = schema.properties;
+		const required = new Set(schema.required ?? []);
+		return `{\n${Object.entries(properties).map(([key, propSchema]) => {
+			const optional = required.has(key) ? "" : "?";
+			const propType = schemaToType(propSchema);
+			return `  ${/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`}${optional}: ${propType};`;
+		}).join("\n")}\n}`;
+	}
+	if (schema.enum) return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+	if (schema.anyOf || schema.oneOf) return (schema.anyOf || schema.oneOf).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";
 }
+/**
+* Capitalize the first letter of a string
+*/
 function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
+	return str.charAt(0).toUpperCase() + str.slice(1);
 }
-export {
-  generateTypeStubs,
-  jsonSchemaToTypeScript
-};
-//# sourceMappingURL=json-schema-to-ts.js.map
+//#endregion
+export { generateTypeStubs, jsonSchemaToTypeScript };
+
+//# sourceMappingURL=json-schema-to-ts.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"json-schema-to-ts.js","sources":["../../../src/type-generator/json-schema-to-ts.ts"],"sourcesContent":["import type { ToolBinding } from '../types'\n\n/**\n * Options for type stub generation\n */\nexport interface TypeGeneratorOptions {\n  /**\n   * Include JSDoc comments with descriptions\n   * @default true\n   */\n  includeDescriptions?: boolean\n}\n\n/**\n * Generate TypeScript type stubs for all tool bindings\n *\n * These stubs are included in the LLM system prompt so it knows\n * the exact type signatures of available tools.\n *\n * Tool names match the actual function names injected into the sandbox.\n */\nexport function generateTypeStubs(\n  bindings: Record<string, ToolBinding>,\n  options: TypeGeneratorOptions = {},\n): string {\n  const { includeDescriptions = true } = options\n\n  const declarations: Array<string> = []\n\n  for (const [name, binding] of Object.entries(bindings)) {\n    const inputTypeName = `${capitalize(name)}Input`\n    const outputTypeName = `${capitalize(name)}Output`\n\n    // Generate input type\n    const inputType = jsonSchemaToTypeScript(binding.inputSchema, inputTypeName)\n    if (inputType.declaration) {\n      declarations.push(inputType.declaration)\n    }\n\n    // Generate output type if present\n    let outputTypeRef = 'unknown'\n    if (binding.outputSchema) {\n      const outputType = jsonSchemaToTypeScript(\n        binding.outputSchema,\n        outputTypeName,\n      )\n      if (outputType.declaration) {\n        declarations.push(outputType.declaration)\n      }\n      outputTypeRef = outputType.name\n    }\n\n    // Generate function declaration matching the actual sandbox function name\n    const description =\n      includeDescriptions && binding.description\n        ? `/** ${binding.description} */\\n`\n        : ''\n\n    declarations.push(\n      `${description}declare function ${name}(input: ${inputType.name}): Promise<${outputTypeRef}>;`,\n    )\n  }\n\n  return declarations.join('\\n\\n')\n}\n\ninterface TypeResult {\n  name: string\n  declaration: string\n}\n\n/**\n * Convert a JSON Schema to a TypeScript type\n *\n * Supports basic types: string, number, boolean, object, array\n */\nexport function jsonSchemaToTypeScript(\n  schema: Record<string, unknown>,\n  typeName: string,\n): TypeResult {\n  const type = schemaToType(schema)\n\n  // For object schemas with properties, create a named interface\n  if (\n    schema.type === 'object' &&\n    schema.properties &&\n    Object.keys(schema.properties).length > 0\n  ) {\n    return {\n      name: typeName,\n      declaration: `interface ${typeName} ${type}`,\n    }\n  }\n\n  // For simple types or empty objects, create a type alias\n  return {\n    name: type,\n    declaration: '',\n  }\n}\n\n/**\n * Convert a JSON Schema to a TypeScript type string\n */\nfunction schemaToType(schema: Record<string, unknown>): string {\n  if (typeof schema !== 'object') {\n    return 'unknown'\n  }\n\n  const schemaType = schema.type\n\n  // Handle basic types\n  if (schemaType === 'string') return 'string'\n  if (schemaType === 'number' || schemaType === 'integer') return 'number'\n  if (schemaType === 'boolean') return 'boolean'\n  if (schemaType === 'null') return 'null'\n\n  // Handle arrays\n  if (schemaType === 'array') {\n    const items = schema.items as Record<string, unknown> | undefined\n    const itemType = items ? schemaToType(items) : 'unknown'\n    return `Array<${itemType}>`\n  }\n\n  // Handle objects with properties\n  if (schemaType === 'object' && schema.properties) {\n    const properties = schema.properties as Record<\n      string,\n      Record<string, unknown>\n    >\n    const required = new Set(\n      (schema.required as Array<string> | undefined) ?? [],\n    )\n\n    const props = Object.entries(properties)\n      .map(([key, propSchema]) => {\n        const optional = required.has(key) ? '' : '?'\n        const propType = schemaToType(propSchema)\n        // Handle property names that need quoting\n        const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)\n          ? key\n          : `\"${key}\"`\n        return `  ${safeName}${optional}: ${propType};`\n      })\n      .join('\\n')\n\n    return `{\\n${props}\\n}`\n  }\n\n  // Handle enums\n  if (schema.enum) {\n    const enumValues = schema.enum as Array<unknown>\n    return enumValues.map((v) => JSON.stringify(v)).join(' | ')\n  }\n\n  // Handle union types (anyOf, oneOf)\n  if (schema.anyOf || schema.oneOf) {\n    const variants = (schema.anyOf || schema.oneOf) as Array<\n      Record<string, unknown>\n    >\n    return variants.map((v) => schemaToType(v)).join(' | ')\n  }\n\n  // Handle type arrays (e.g., [\"string\", \"null\"])\n  if (Array.isArray(schemaType)) {\n    return schemaType\n      .map((t) => {\n        if (t === 'string') return 'string'\n        if (t === 'number' || t === 'integer') return 'number'\n        if (t === 'boolean') return 'boolean'\n        if (t === 'null') return 'null'\n        if (t === 'array') return 'Array<unknown>'\n        if (t === 'object') return 'object'\n        return 'unknown'\n      })\n      .join(' | ')\n  }\n\n  // Fallback for unknown schemas\n  return 'unknown'\n}\n\n/**\n * Capitalize the first letter of a string\n */\nfunction capitalize(str: string): string {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"json-schema-to-ts.js","names":[],"sources":["../../../src/type-generator/json-schema-to-ts.ts"],"sourcesContent":["import type { ToolBinding } from '../types'\n\n/**\n * Options for type stub generation\n */\nexport interface TypeGeneratorOptions {\n  /**\n   * Include JSDoc comments with descriptions\n   * @default true\n   */\n  includeDescriptions?: boolean\n}\n\n/**\n * Generate TypeScript type stubs for all tool bindings\n *\n * These stubs are included in the LLM system prompt so it knows\n * the exact type signatures of available tools.\n *\n * Tool names match the actual function names injected into the sandbox.\n */\nexport function generateTypeStubs(\n  bindings: Record<string, ToolBinding>,\n  options: TypeGeneratorOptions = {},\n): string {\n  const { includeDescriptions = true } = options\n\n  const declarations: Array<string> = []\n\n  for (const [name, binding] of Object.entries(bindings)) {\n    const inputTypeName = `${capitalize(name)}Input`\n    const outputTypeName = `${capitalize(name)}Output`\n\n    // Generate input type\n    const inputType = jsonSchemaToTypeScript(binding.inputSchema, inputTypeName)\n    if (inputType.declaration) {\n      declarations.push(inputType.declaration)\n    }\n\n    // Generate output type if present\n    let outputTypeRef = 'unknown'\n    if (binding.outputSchema) {\n      const outputType = jsonSchemaToTypeScript(\n        binding.outputSchema,\n        outputTypeName,\n      )\n      if (outputType.declaration) {\n        declarations.push(outputType.declaration)\n      }\n      outputTypeRef = outputType.name\n    }\n\n    // Generate function declaration matching the actual sandbox function name\n    const description =\n      includeDescriptions && binding.description\n        ? `/** ${binding.description} */\\n`\n        : ''\n\n    declarations.push(\n      `${description}declare function ${name}(input: ${inputType.name}): Promise<${outputTypeRef}>;`,\n    )\n  }\n\n  return declarations.join('\\n\\n')\n}\n\ninterface TypeResult {\n  name: string\n  declaration: string\n}\n\n/**\n * Convert a JSON Schema to a TypeScript type\n *\n * Supports basic types: string, number, boolean, object, array\n */\nexport function jsonSchemaToTypeScript(\n  schema: Record<string, unknown>,\n  typeName: string,\n): TypeResult {\n  const type = schemaToType(schema)\n\n  // For object schemas with properties, create a named interface\n  if (\n    schema.type === 'object' &&\n    schema.properties &&\n    Object.keys(schema.properties).length > 0\n  ) {\n    return {\n      name: typeName,\n      declaration: `interface ${typeName} ${type}`,\n    }\n  }\n\n  // For simple types or empty objects, create a type alias\n  return {\n    name: type,\n    declaration: '',\n  }\n}\n\n/**\n * Convert a JSON Schema to a TypeScript type string\n */\nfunction schemaToType(schema: Record<string, unknown>): string {\n  if (typeof schema !== 'object') {\n    return 'unknown'\n  }\n\n  const schemaType = schema.type\n\n  // Handle basic types\n  if (schemaType === 'string') return 'string'\n  if (schemaType === 'number' || schemaType === 'integer') return 'number'\n  if (schemaType === 'boolean') return 'boolean'\n  if (schemaType === 'null') return 'null'\n\n  // Handle arrays\n  if (schemaType === 'array') {\n    const items = schema.items as Record<string, unknown> | undefined\n    const itemType = items ? schemaToType(items) : 'unknown'\n    return `Array<${itemType}>`\n  }\n\n  // Handle objects with properties\n  if (schemaType === 'object' && schema.properties) {\n    const properties = schema.properties as Record<\n      string,\n      Record<string, unknown>\n    >\n    const required = new Set(\n      (schema.required as Array<string> | undefined) ?? [],\n    )\n\n    const props = Object.entries(properties)\n      .map(([key, propSchema]) => {\n        const optional = required.has(key) ? '' : '?'\n        const propType = schemaToType(propSchema)\n        // Handle property names that need quoting\n        const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)\n          ? key\n          : `\"${key}\"`\n        return `  ${safeName}${optional}: ${propType};`\n      })\n      .join('\\n')\n\n    return `{\\n${props}\\n}`\n  }\n\n  // Handle enums\n  if (schema.enum) {\n    const enumValues = schema.enum as Array<unknown>\n    return enumValues.map((v) => JSON.stringify(v)).join(' | ')\n  }\n\n  // Handle union types (anyOf, oneOf)\n  if (schema.anyOf || schema.oneOf) {\n    const variants = (schema.anyOf || schema.oneOf) as Array<\n      Record<string, unknown>\n    >\n    return variants.map((v) => schemaToType(v)).join(' | ')\n  }\n\n  // Handle type arrays (e.g., [\"string\", \"null\"])\n  if (Array.isArray(schemaType)) {\n    return schemaType\n      .map((t) => {\n        if (t === 'string') return 'string'\n        if (t === 'number' || t === 'integer') return 'number'\n        if (t === 'boolean') return 'boolean'\n        if (t === 'null') return 'null'\n        if (t === 'array') return 'Array<unknown>'\n        if (t === 'object') return 'object'\n        return 'unknown'\n      })\n      .join(' | ')\n  }\n\n  // Fallback for unknown schemas\n  return 'unknown'\n}\n\n/**\n * Capitalize the first letter of a string\n */\nfunction capitalize(str: string): string {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n}\n"],"mappings":"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"}