@tanstack/ai-code-mode 0.2.13 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-code-mode",
-  "version": "0.2.13",
+  "version": "0.3.0",
   "description": "Secure TypeScript Code Mode for TanStack AI agents to execute sandboxed tool orchestration programs.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -54,12 +54,12 @@
   },
   "peerDependencies": {
     "zod": "^3.0.0 || ^4.0.0",
-    "@tanstack/ai": "0.35.0"
+    "@tanstack/ai": "0.36.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
     "zod": "^4.2.0",
-    "@tanstack/ai": "0.35.0"
+    "@tanstack/ai": "0.36.0"
   },
   "scripts": {
     "build": "vite build",

package/skills/ai-code-mode/SKILL.md

@@ -15,6 +15,7 @@ sources:
   - 'TanStack/ai:docs/code-mode/code-mode-isolates.md'
   - 'TanStack/ai:docs/code-mode/code-mode-with-skills.md'
   - 'TanStack/ai:docs/code-mode/client-integration.md'
+  - 'TanStack/ai:docs/code-mode/lazy-tools.md'
 ---
 
 > **Note**: This skill requires familiarity with ai-core and ai-core/chat-experience. Code Mode is always used on top of a chat experience.
@@ -328,6 +329,84 @@ Skill-specific events (when using `codeModeWithSkills`):
 | `code_mode:skill_error`  | Skill failed       | `skill`, `error`, `duration`  |
 | `skill:registered`       | New skill saved    | `id`, `name`, `description`   |
 
+### 4. Lazy Tools
+
+When a large tool catalog would bloat the `execute_typescript` system prompt, mark low-priority tools `lazy: true`. Lazy tools are kept out of the full type-stub documentation and listed in a compact "Discoverable APIs" catalog instead. All sandbox bindings are always injected — `lazy` defers documentation, not callability.
+
+**Marking a tool lazy:**
+
+```typescript
+import { toolDefinition } from '@tanstack/ai'
+import { z } from 'zod'
+
+const rarelyUsedTool = toolDefinition({
+  name: 'fetchStocks',
+  description: 'Get stock prices for a ticker. Returns a price quote.',
+  inputSchema: z.object({ ticker: z.string() }),
+  outputSchema: z.object({ price: z.number() }),
+  lazy: true, // <-- opt out of full system-prompt documentation
+}).server(async ({ ticker }) => {
+  // ...
+  return { price: 0 }
+})
+```
+
+**`createCodeMode` return shape:**
+
+`createCodeMode()` returns `{ tool, discoveryTool, tools, systemPrompt }`. When lazy tools are present `discoveryTool` is a `discover_tools` server tool; otherwise it is `null`. Always spread `tools` (not just `tool`) into `chat()` so the discovery tool is registered:
+
+```typescript
+import { chat } from '@tanstack/ai'
+import { createCodeMode } from '@tanstack/ai-code-mode'
+import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'
+import { openaiText } from '@tanstack/ai-openai'
+
+const { tools, systemPrompt } = createCodeMode({
+  driver: createNodeIsolateDriver(),
+  tools: [eagerTool, rarelyUsedTool], // rarelyUsedTool has lazy: true
+})
+
+const stream = chat({
+  adapter: openaiText('gpt-5.5'),
+  systemPrompts: ['You are a helpful assistant.', systemPrompt],
+  tools: [...tools, ...otherTools], // spread tools, not just tool
+  messages,
+})
+```
+
+`tools` equals `[tool]` when there are no lazy tools (backward compatible) and `[tool, discoveryTool]` when lazy tools exist.
+
+**`discover_tools` flow:**
+
+When the model encounters a lazy tool it has not seen before, it calls `discover_tools` with the bare name (no `external_` prefix). The tool returns each requested tool's TypeScript type stub and description. The model then writes correctly-typed `external_<name>` calls inside `execute_typescript`.
+
+```text
+Model sees: "Discoverable APIs: external_fetchStocks"
+Model calls: discover_tools({ toolNames: ["fetchStocks"] })
+Response:    { tools: [{ name: "external_fetchStocks", description: "...", typeStub: "declare function external_fetchStocks(...)" }] }
+Model writes inside execute_typescript: const result = await external_fetchStocks({ ticker: "AAPL" })
+```
+
+**`lazyToolsConfig.includeDescription`:**
+
+Control how much of each lazy tool's description appears in the Discoverable APIs catalog (the pre-discovery list):
+
+| Value              | Catalog entry                                                     |
+| ------------------ | ----------------------------------------------------------------- |
+| `'none'`           | `external_fetchStocks` (name only — default)                      |
+| `'first-sentence'` | `external_fetchStocks — Get stock prices.`                        |
+| `'full'`           | `external_fetchStocks — Get stock prices. Returns a price quote.` |
+
+```typescript
+const { tools, systemPrompt } = createCodeMode({
+  driver: createNodeIsolateDriver(),
+  tools: [eagerTool, rarelyUsedTool],
+  lazyToolsConfig: { includeDescription: 'first-sentence' },
+})
+```
+
+The same `lazyToolsConfig` option is accepted by plain `chat()` for its own lazy-tool discovery catalog (see `ai-core/tool-calling/SKILL.md`).
+
 ## Common Mistakes
 
 ### CRITICAL: Passing API keys or secrets to the sandbox environment

package/src/create-code-mode-tool.ts

@@ -245,11 +245,17 @@ export function createCodeModeTool(
  * Build the tool description including available external functions
  */
 function buildToolDescription(tools: Array<CodeModeTool>): string {
-  const externalFunctions = tools.map((t) => `external_${t.name}`).join(', ')
+  const eager = tools.filter((t) => !t.lazy)
+  const hasLazy = tools.some((t) => t.lazy)
+  const externalFunctions = eager.map((t) => `external_${t.name}`).join(', ')
+
+  const discoverable = hasLazy
+    ? ` Additional functions can be discovered via the discover_tools tool.`
+    : ''
 
   return (
     `Execute TypeScript code in a secure sandbox environment. ` +
-    `The code can use these external API functions: ${externalFunctions}. ` +
+    `The code can use these external API functions: ${externalFunctions}.${discoverable} ` +
     `All external_* calls are async and must be awaited. ` +
     `Return a value to pass results back. Use console.log() for debugging.`
   )

package/src/create-code-mode.ts

@@ -1,35 +1,45 @@
 import { createCodeModeTool } from './create-code-mode-tool'
 import { createCodeModeSystemPrompt } from './create-system-prompt'
-import type { CodeModeToolConfig } from './types'
+import { createDiscoveryTool } from './create-discovery-tool'
+import type { CodeModeToolConfig, CreateCodeModeResult } from './types'
 
 /**
- * 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.
+ * Create the `execute_typescript` tool, its matching system prompt, and (when
+ * any tools are marked `lazy: true`) a `discover_tools` companion tool.
  *
  * @example
  * ```typescript
  * import { createCodeMode } from '@tanstack/ai-code-mode'
  * import { createNodeIsolateDriver } from '@tanstack/ai-isolate-node'
  *
- * const { tool, systemPrompt } = createCodeMode({
+ * const { tools, systemPrompt } = createCodeMode({
  *   driver: createNodeIsolateDriver(),
- *   tools: [weatherTool, dbTool],
- *   timeout: 30000,
+ *   tools: [weatherTool, rarelyUsedTool], // mark rarelyUsedTool lazy: true
  * })
  *
  * chat({
  *   systemPrompts: [myPrompt, systemPrompt],
- *   tools: [tool, ...otherTools],
+ *   tools: [...tools, ...otherTools],
  *   messages,
  * })
  * ```
  */
-export function createCodeMode(config: CodeModeToolConfig) {
+export function createCodeMode(
+  config: CodeModeToolConfig,
+): CreateCodeModeResult {
+  const tool = createCodeModeTool(config)
+  const systemPrompt = createCodeModeSystemPrompt(config)
+
+  const lazyTools = config.tools.filter((t) => t.lazy)
+  const discoveryTool =
+    lazyTools.length > 0
+      ? createDiscoveryTool(lazyTools, config.lazyToolsConfig)
+      : null
+
   return {
-    tool: createCodeModeTool(config),
-    systemPrompt: createCodeModeSystemPrompt(config),
+    tool,
+    discoveryTool,
+    tools: discoveryTool ? [tool, discoveryTool] : [tool],
+    systemPrompt,
   }
 }

package/src/create-discovery-tool.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod'
+import { renderLazyCatalogEntry, toolDefinition } from '@tanstack/ai'
+import { toolToBinding } from './bindings/tool-to-binding'
+import { generateTypeStubs } from './type-generator/json-schema-to-ts'
+import type { LazyToolsConfig, ServerTool } from '@tanstack/ai'
+import type { CodeModeTool } from './types'
+
+const discoverInputSchema = z.object({
+  toolNames: z
+    .array(z.string())
+    .describe(
+      'Names of tools to discover, exactly as shown in the Discoverable APIs ' +
+        'catalog. The external_ prefix is optional — both "external_fetchStocks" ' +
+        'and "fetchStocks" resolve.',
+    ),
+})
+
+const discoverOutputSchema = z.object({
+  tools: z.array(
+    z.object({
+      name: z
+        .string()
+        .describe('The sandbox function name, e.g. external_fetchStocks'),
+      description: z.string(),
+      typeStub: z.string().describe('TypeScript declaration for the function'),
+    }),
+  ),
+  errors: z.array(z.string()).optional(),
+})
+
+const EXTERNAL_PREFIX = 'external_'
+
+/**
+ * Strip a single leading `external_` prefix so the model can pass either the
+ * catalog name (`external_fetchStocks`) or the bare name (`fetchStocks`).
+ */
+function stripExternalPrefix(name: string): string {
+  return name.startsWith(EXTERNAL_PREFIX)
+    ? name.slice(EXTERNAL_PREFIX.length)
+    : name
+}
+
+/**
+ * Build the `discover_tools` sibling tool for Code Mode lazy tools. The model
+ * calls it with lazy tool names and receives each one's TypeScript type stub +
+ * description, which it can then use to write correctly-typed `external_*`
+ * calls inside `execute_typescript`. The bindings themselves are always present
+ * in the sandbox — this only reveals documentation.
+ *
+ * Tools are catalogued in `external_<name>` form to match the "Discoverable
+ * APIs" section of the Code Mode system prompt; lookups tolerate either form.
+ * `lazyToolsConfig.includeDescription` controls how much of each tool's
+ * description appears in this tool's own catalog (mirroring the system prompt).
+ */
+export function createDiscoveryTool(
+  lazyTools: Array<CodeModeTool>,
+  lazyToolsConfig?: LazyToolsConfig,
+): ServerTool<
+  typeof discoverInputSchema,
+  typeof discoverOutputSchema,
+  'discover_tools'
+> {
+  const lazyMap = new Map(lazyTools.map((t) => [t.name, t]))
+  const include = lazyToolsConfig?.includeDescription ?? 'none'
+  const catalog = lazyTools
+    .map((t) =>
+      renderLazyCatalogEntry(
+        `${EXTERNAL_PREFIX}${t.name}`,
+        t.description,
+        include,
+      ),
+    )
+    .join(', ')
+
+  return toolDefinition({
+    name: 'discover_tools' as const,
+    description:
+      `Discover full TypeScript signatures for additional sandbox APIs before ` +
+      `using them inside execute_typescript. Discoverable tools: [${catalog}]. ` +
+      `Pass the names exactly as shown (the external_ prefix is optional).`,
+    inputSchema: discoverInputSchema,
+    outputSchema: discoverOutputSchema,
+  }).server(async ({ toolNames }) => {
+    const tools: Array<{
+      name: string
+      description: string
+      typeStub: string
+    }> = []
+    const errors: Array<string> = []
+
+    for (const name of toolNames) {
+      const tool = lazyMap.get(stripExternalPrefix(name))
+      if (!tool) {
+        errors.push(`Unknown tool: '${name}'. Discoverable tools: [${catalog}]`)
+        continue
+      }
+      const binding = toolToBinding(tool, EXTERNAL_PREFIX)
+      const typeStub = generateTypeStubs({ [binding.name]: binding })
+      tools.push({
+        name: binding.name,
+        description: tool.description,
+        typeStub,
+      })
+    }
+
+    return errors.length > 0 ? { tools, errors } : { tools }
+  })
+}

package/src/create-system-prompt.ts

@@ -1,3 +1,4 @@
+import { renderLazyCatalogEntry } from '@tanstack/ai'
 import { toolsToBindings } from './bindings/tool-to-binding'
 import { generateTypeStubs } from './type-generator/json-schema-to-ts'
 import type { CodeModeToolConfig } from './types'
@@ -26,21 +27,35 @@ import type { CodeModeToolConfig } from './types'
  */
 export function createCodeModeSystemPrompt(config: CodeModeToolConfig): string {
   const { tools } = config
+  const include = config.lazyToolsConfig?.includeDescription ?? 'none'
 
-  // Transform tools to bindings with external_ prefix to generate correct type stubs
-  const bindings = toolsToBindings(tools, 'external_')
+  const eagerTools = tools.filter((t) => !t.lazy)
+  const lazyTools = tools.filter((t) => t.lazy)
 
-  // Generate TypeScript type stubs for the external functions
+  // Only eager tools get full type stubs + doc lines.
+  const bindings = toolsToBindings(eagerTools, 'external_')
   const typeStubs = generateTypeStubs(bindings)
 
-  // Build function documentation
   const functionDocs = Object.entries(bindings)
-    .map(([name, binding]) => {
-      const doc = `- \`${name}(input)\`: ${binding.description}`
-      return doc
-    })
+    .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
 
 You have access to \`execute_typescript\` which runs TypeScript code in a sandboxed environment.
@@ -65,7 +80,7 @@ ${functionDocs}
 
 \`\`\`typescript
 ${typeStubs}
-\`\`\`
+\`\`\`${discoverableSection}
 
 ### Example
 
@@ -77,7 +92,7 @@ const results = await Promise.all(
 );
 
 // Find the warmest city
-const warmest = results.reduce((prev, curr) => 
+const warmest = results.reduce((prev, curr) =>
   curr.temperature > prev.temperature ? curr : prev
 );
 

package/src/index.ts

@@ -7,6 +7,7 @@ export type {
 
 export { createCodeModeSystemPrompt } from './create-system-prompt'
 export { createCodeMode } from './create-code-mode'
+export { createDiscoveryTool } from './create-discovery-tool'
 
 export {
   InMemoryAgentStore,
@@ -39,6 +40,7 @@ export { wrapCode } from './code-wrapper'
 export type {
   // Tool-based API types
   CodeModeToolConfig,
+  CreateCodeModeResult,
   CodeModeToolResult,
   // Isolate driver interfaces (used by driver packages)
   IsolateDriver,

package/src/types.ts

@@ -1,4 +1,5 @@
 import type {
+  LazyToolsConfig,
   SchemaInput,
   ServerTool,
   ToolExecutionContext,
@@ -196,6 +197,14 @@ export interface CodeModeToolConfig {
    */
   getSkillBindings?: () => Promise<Record<string, ToolBinding>>
 
+  /**
+   * Optional lazy-tool discovery config. Tools marked `lazy: true` are kept out
+   * of the system prompt's full documentation and listed in a Discoverable APIs
+   * catalog instead; this tunes how much of each lazy tool's description that
+   * catalog shows. Optional — defaults to `{ includeDescription: 'none' }`.
+   */
+  lazyToolsConfig?: LazyToolsConfig
+
   /**
    * Optional escape hatch to swap out the TypeScript-stripping step.
    *
@@ -264,3 +273,19 @@ export interface CodeModeToolResult {
       }
     | undefined
 }
+
+/**
+ * Return shape of `createCodeMode`. `tool` (execute_typescript) and
+ * `systemPrompt` are preserved for backward compatibility; `discoveryTool` and
+ * `tools` are additive. Spread `tools` into `chat({ tools })`.
+ */
+export interface CreateCodeModeResult {
+  /** The execute_typescript tool. */
+  tool: ServerTool<SchemaInput, SchemaInput, 'execute_typescript'>
+  /** The discover_tools tool, or null when there are no lazy tools. */
+  discoveryTool: ServerTool<SchemaInput, SchemaInput, 'discover_tools'> | null
+  /** [tool] or [tool, discoveryTool] — the array to spread into chat({ tools }). */
+  tools: Array<ServerTool<SchemaInput, SchemaInput, string>>
+  /** The matching system prompt. */
+  systemPrompt: string
+}

package/dist/esm/agent-store.d.ts

@@ -1,21 +0,0 @@
-export interface AgentSession {
-    name: string;
-    systemPrompt: string;
-    memory: Record<string, unknown>;
-    createdAt: number;
-    lastUsedAt: number;
-}
-export interface AgentStore {
-    get: (name: string) => Promise<AgentSession | null>;
-    set: (name: string, session: AgentSession) => Promise<void>;
-    delete: (name: string) => Promise<void>;
-    list: () => Promise<Array<string>>;
-}
-export declare class InMemoryAgentStore implements AgentStore {
-    private readonly sessions;
-    get(name: string): Promise<AgentSession | null>;
-    set(name: string, session: AgentSession): Promise<void>;
-    delete(name: string): Promise<void>;
-    list(): Promise<Array<string>>;
-}
-export declare function generateAgentName(): string;

package/dist/esm/agent-store.js

@@ -1,29 +0,0 @@
-class InMemoryAgentStore {
-  sessions = /* @__PURE__ */ new Map();
-  get(name) {
-    return Promise.resolve(this.sessions.get(name) ?? null);
-  }
-  set(name, session) {
-    this.sessions.set(name, session);
-    return Promise.resolve();
-  }
-  delete(name) {
-    this.sessions.delete(name);
-    return Promise.resolve();
-  }
-  list() {
-    return Promise.resolve(Array.from(this.sessions.keys()));
-  }
-}
-function generateAgentName() {
-  const hex = Array.from(
-    { length: 8 },
-    () => Math.floor(Math.random() * 16).toString(16)
-  ).join("");
-  return `agent_${hex}`;
-}
-export {
-  InMemoryAgentStore,
-  generateAgentName
-};
-//# sourceMappingURL=agent-store.js.map

package/dist/esm/agent-store.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-store.js","sources":["../../src/agent-store.ts"],"sourcesContent":["export interface AgentSession {\n  name: string\n  systemPrompt: string\n  memory: Record<string, unknown>\n  createdAt: number\n  lastUsedAt: number\n}\n\nexport interface AgentStore {\n  get: (name: string) => Promise<AgentSession | null>\n  set: (name: string, session: AgentSession) => Promise<void>\n  delete: (name: string) => Promise<void>\n  list: () => Promise<Array<string>>\n}\n\nexport class InMemoryAgentStore implements AgentStore {\n  private readonly sessions = new Map<string, AgentSession>()\n\n  get(name: string): Promise<AgentSession | null> {\n    return Promise.resolve(this.sessions.get(name) ?? null)\n  }\n\n  set(name: string, session: AgentSession): Promise<void> {\n    this.sessions.set(name, session)\n    return Promise.resolve()\n  }\n\n  delete(name: string): Promise<void> {\n    this.sessions.delete(name)\n    return Promise.resolve()\n  }\n\n  list(): Promise<Array<string>> {\n    return Promise.resolve(Array.from(this.sessions.keys()))\n  }\n}\n\nexport function generateAgentName(): string {\n  const hex = Array.from({ length: 8 }, () =>\n    Math.floor(Math.random() * 16).toString(16),\n  ).join('')\n  return `agent_${hex}`\n}\n"],"names":[],"mappings":"AAeO,MAAM,mBAAyC;AAAA,EACnC,+BAAe,IAAA;AAAA,EAEhC,IAAI,MAA4C;AAC9C,WAAO,QAAQ,QAAQ,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI;AAAA,EACxD;AAAA,EAEA,IAAI,MAAc,SAAsC;AACtD,SAAK,SAAS,IAAI,MAAM,OAAO;AAC/B,WAAO,QAAQ,QAAA;AAAA,EACjB;AAAA,EAEA,OAAO,MAA6B;AAClC,SAAK,SAAS,OAAO,IAAI;AACzB,WAAO,QAAQ,QAAA;AAAA,EACjB;AAAA,EAEA,OAA+B;AAC7B,WAAO,QAAQ,QAAQ,MAAM,KAAK,KAAK,SAAS,KAAA,CAAM,CAAC;AAAA,EACzD;AACF;AAEO,SAAS,oBAA4B;AAC1C,QAAM,MAAM,MAAM;AAAA,IAAK,EAAE,QAAQ,EAAA;AAAA,IAAK,MACpC,KAAK,MAAM,KAAK,WAAW,EAAE,EAAE,SAAS,EAAE;AAAA,EAAA,EAC1C,KAAK,EAAE;AACT,SAAO,SAAS,GAAG;AACrB;"}

package/dist/esm/bindings/tool-to-binding.d.ts

@@ -1,25 +0,0 @@
-import { ToolExecutionContext } from '@tanstack/ai';
-import { CodeModeTool, ToolBinding } from '../types.js';
-/**
- * Convert an array of TanStack AI tools to a Record of ToolBindings
- *
- * @param tools - Array of tools to convert
- * @param prefix - Optional prefix to add to binding names (e.g., 'external_')
- */
-export declare function toolsToBindings(tools: Array<CodeModeTool>, prefix?: string): Record<string, ToolBinding>;
-/**
- * Convert a single TanStack AI tool to a ToolBinding
- *
- * @param tool - Tool to convert
- * @param prefix - Optional prefix to add to binding name (e.g., 'external_')
- * @throws Error if the tool doesn't have an execute function
- */
-export declare function toolToBinding(tool: CodeModeTool, prefix?: string): ToolBinding;
-/**
- * Create event-aware bindings that emit custom events for each external function call.
- * Wraps each binding's execute function to emit events before and after execution.
- *
- * @param bindings - Original tool bindings
- * @param emitCustomEvent - Callback to emit custom events to the stream
- */
-export declare function createEventAwareBindings(bindings: Record<string, ToolBinding>, emitCustomEvent: ToolExecutionContext['emitCustomEvent']): Record<string, ToolBinding>;

package/dist/esm/bindings/tool-to-binding.js

@@ -1,94 +0,0 @@
-import { convertSchemaToJsonSchema, isStandardSchema, parseWithStandardSchema } from "@tanstack/ai";
-function toolsToBindings(tools, prefix = "") {
-  const bindings = {};
-  for (const tool of tools) {
-    const bindingName = `${prefix}${tool.name}`;
-    bindings[bindingName] = toolToBinding(tool, prefix);
-  }
-  return bindings;
-}
-function toolToBinding(tool, prefix = "") {
-  const inputSchema = convertSchemaToJsonSchema(tool.inputSchema) || {
-    type: "object",
-    properties: {}
-  };
-  const outputSchema = tool.outputSchema ? convertSchemaToJsonSchema(tool.outputSchema) : void 0;
-  if (typeof tool.execute !== "function") {
-    throw new Error(
-      `Tool "${tool.name}" does not have an execute function. Code Mode requires server tools with implementations.`
-    );
-  }
-  const toolExecute = tool.execute;
-  const execute = async (args, context) => {
-    let input = args;
-    if (tool.inputSchema && isStandardSchema(tool.inputSchema)) {
-      try {
-        input = parseWithStandardSchema(tool.inputSchema, args);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Validation failed";
-        throw new Error(
-          `Input validation failed for tool ${tool.name}: ${message}`
-        );
-      }
-    }
-    let result = await Promise.resolve(toolExecute(input, context));
-    if (tool.outputSchema && isStandardSchema(tool.outputSchema)) {
-      try {
-        result = parseWithStandardSchema(tool.outputSchema, result);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Validation failed";
-        throw new Error(
-          `Output validation failed for tool ${tool.name}: ${message}`
-        );
-      }
-    }
-    return result;
-  };
-  return {
-    name: `${prefix}${tool.name}`,
-    description: tool.description,
-    inputSchema,
-    outputSchema,
-    execute
-  };
-}
-function createEventAwareBindings(bindings, emitCustomEvent) {
-  const wrapped = {};
-  for (const [name, binding] of Object.entries(bindings)) {
-    wrapped[name] = {
-      ...binding,
-      execute: async (args) => {
-        emitCustomEvent("code_mode:external_call", {
-          function: name,
-          args,
-          timestamp: Date.now()
-        });
-        const startTime = Date.now();
-        try {
-          const toolContext = { emitCustomEvent };
-          const result = await binding.execute(args, toolContext);
-          emitCustomEvent("code_mode:external_result", {
-            function: name,
-            result,
-            duration: Date.now() - startTime
-          });
-          return result;
-        } catch (error) {
-          emitCustomEvent("code_mode:external_error", {
-            function: name,
-            error: error instanceof Error ? error.message : String(error),
-            duration: Date.now() - startTime
-          });
-          throw error;
-        }
-      }
-    };
-  }
-  return wrapped;
-}
-export {
-  createEventAwareBindings,
-  toolToBinding,
-  toolsToBindings
-};
-//# sourceMappingURL=tool-to-binding.js.map

package/dist/esm/bindings/tool-to-binding.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-to-binding.js","sources":["../../../src/bindings/tool-to-binding.ts"],"sourcesContent":["import {\n  convertSchemaToJsonSchema,\n  isStandardSchema,\n  parseWithStandardSchema,\n} from '@tanstack/ai'\nimport type { ToolExecutionContext } from '@tanstack/ai'\nimport type { CodeModeTool, ToolBinding } from '../types'\n\n/**\n * Convert an array of TanStack AI tools to a Record of ToolBindings\n *\n * @param tools - Array of tools to convert\n * @param prefix - Optional prefix to add to binding names (e.g., 'external_')\n */\nexport function toolsToBindings(\n  tools: Array<CodeModeTool>,\n  prefix: string = '',\n): Record<string, ToolBinding> {\n  const bindings: Record<string, ToolBinding> = {}\n\n  for (const tool of tools) {\n    const bindingName = `${prefix}${tool.name}`\n    bindings[bindingName] = toolToBinding(tool, prefix)\n  }\n\n  return bindings\n}\n\n/**\n * Convert a single TanStack AI tool to a ToolBinding\n *\n * @param tool - Tool to convert\n * @param prefix - Optional prefix to add to binding name (e.g., 'external_')\n * @throws Error if the tool doesn't have an execute function\n */\nexport function toolToBinding(\n  tool: CodeModeTool,\n  prefix: string = '',\n): ToolBinding {\n  // Convert schemas (Zod or Standard Schema) to JSON Schema\n  const inputSchema = convertSchemaToJsonSchema(tool.inputSchema) || {\n    type: 'object',\n    properties: {},\n  }\n\n  const outputSchema = tool.outputSchema\n    ? convertSchemaToJsonSchema(tool.outputSchema)\n    : undefined\n\n  if (typeof tool.execute !== 'function') {\n    throw new Error(\n      `Tool \"${tool.name}\" does not have an execute function. ` +\n        `Code Mode requires server tools with implementations.`,\n    )\n  }\n\n  const toolExecute = tool.execute\n  const execute = async (args: unknown, context?: ToolExecutionContext) => {\n    let input = args\n    if (tool.inputSchema && isStandardSchema(tool.inputSchema)) {\n      try {\n        input = parseWithStandardSchema(tool.inputSchema, args)\n      } catch (error) {\n        const message =\n          error instanceof Error ? error.message : 'Validation failed'\n        throw new Error(\n          `Input validation failed for tool ${tool.name}: ${message}`,\n        )\n      }\n    }\n\n    let result = await Promise.resolve(toolExecute(input, context))\n\n    if (tool.outputSchema && isStandardSchema(tool.outputSchema)) {\n      try {\n        result = parseWithStandardSchema(tool.outputSchema, result)\n      } catch (error) {\n        const message =\n          error instanceof Error ? error.message : 'Validation failed'\n        throw new Error(\n          `Output validation failed for tool ${tool.name}: ${message}`,\n        )\n      }\n    }\n\n    return result\n  }\n\n  return {\n    name: `${prefix}${tool.name}`,\n    description: tool.description,\n    inputSchema,\n    outputSchema,\n    execute,\n  }\n}\n\n/**\n * Create event-aware bindings that emit custom events for each external function call.\n * Wraps each binding's execute function to emit events before and after execution.\n *\n * @param bindings - Original tool bindings\n * @param emitCustomEvent - Callback to emit custom events to the stream\n */\nexport function createEventAwareBindings(\n  bindings: Record<string, ToolBinding>,\n  emitCustomEvent: ToolExecutionContext['emitCustomEvent'],\n): Record<string, ToolBinding> {\n  const wrapped: Record<string, ToolBinding> = {}\n\n  for (const [name, binding] of Object.entries(bindings)) {\n    wrapped[name] = {\n      ...binding,\n      execute: async (args: unknown) => {\n        // Emit call event\n        emitCustomEvent('code_mode:external_call', {\n          function: name,\n          args,\n          timestamp: Date.now(),\n        })\n\n        const startTime = Date.now()\n        try {\n          // Create context for the underlying tool so it can also emit events\n          const toolContext: ToolExecutionContext = { emitCustomEvent }\n          const result = await binding.execute(args, toolContext)\n\n          // Emit result event\n          emitCustomEvent('code_mode:external_result', {\n            function: name,\n            result,\n            duration: Date.now() - startTime,\n          })\n\n          return result\n        } catch (error) {\n          // Emit error event\n          emitCustomEvent('code_mode:external_error', {\n            function: name,\n            error: error instanceof Error ? error.message : String(error),\n            duration: Date.now() - startTime,\n          })\n          throw error\n        }\n      },\n    }\n  }\n\n  return wrapped\n}\n"],"names":[],"mappings":";AAcO,SAAS,gBACd,OACA,SAAiB,IACY;AAC7B,QAAM,WAAwC,CAAA;AAE9C,aAAW,QAAQ,OAAO;AACxB,UAAM,cAAc,GAAG,MAAM,GAAG,KAAK,IAAI;AACzC,aAAS,WAAW,IAAI,cAAc,MAAM,MAAM;AAAA,EACpD;AAEA,SAAO;AACT;AASO,SAAS,cACd,MACA,SAAiB,IACJ;AAEb,QAAM,cAAc,0BAA0B,KAAK,WAAW,KAAK;AAAA,IACjE,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,EAAC;AAGf,QAAM,eAAe,KAAK,eACtB,0BAA0B,KAAK,YAAY,IAC3C;AAEJ,MAAI,OAAO,KAAK,YAAY,YAAY;AACtC,UAAM,IAAI;AAAA,MACR,SAAS,KAAK,IAAI;AAAA,IAAA;AAAA,EAGtB;AAEA,QAAM,cAAc,KAAK;AACzB,QAAM,UAAU,OAAO,MAAe,YAAmC;AACvE,QAAI,QAAQ;AACZ,QAAI,KAAK,eAAe,iBAAiB,KAAK,WAAW,GAAG;AAC1D,UAAI;AACF,gBAAQ,wBAAwB,KAAK,aAAa,IAAI;AAAA,MACxD,SAAS,OAAO;AACd,cAAM,UACJ,iBAAiB,QAAQ,MAAM,UAAU;AAC3C,cAAM,IAAI;AAAA,UACR,oCAAoC,KAAK,IAAI,KAAK,OAAO;AAAA,QAAA;AAAA,MAE7D;AAAA,IACF;AAEA,QAAI,SAAS,MAAM,QAAQ,QAAQ,YAAY,OAAO,OAAO,CAAC;AAE9D,QAAI,KAAK,gBAAgB,iBAAiB,KAAK,YAAY,GAAG;AAC5D,UAAI;AACF,iBAAS,wBAAwB,KAAK,cAAc,MAAM;AAAA,MAC5D,SAAS,OAAO;AACd,cAAM,UACJ,iBAAiB,QAAQ,MAAM,UAAU;AAC3C,cAAM,IAAI;AAAA,UACR,qCAAqC,KAAK,IAAI,KAAK,OAAO;AAAA,QAAA;AAAA,MAE9D;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,MAAM,GAAG,MAAM,GAAG,KAAK,IAAI;AAAA,IAC3B,aAAa,KAAK;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AASO,SAAS,yBACd,UACA,iBAC6B;AAC7B,QAAM,UAAuC,CAAA;AAE7C,aAAW,CAAC,MAAM,OAAO,KAAK,OAAO,QAAQ,QAAQ,GAAG;AACtD,YAAQ,IAAI,IAAI;AAAA,MACd,GAAG;AAAA,MACH,SAAS,OAAO,SAAkB;AAEhC,wBAAgB,2BAA2B;AAAA,UACzC,UAAU;AAAA,UACV;AAAA,UACA,WAAW,KAAK,IAAA;AAAA,QAAI,CACrB;AAED,cAAM,YAAY,KAAK,IAAA;AACvB,YAAI;AAEF,gBAAM,cAAoC,EAAE,gBAAA;AAC5C,gBAAM,SAAS,MAAM,QAAQ,QAAQ,MAAM,WAAW;AAGtD,0BAAgB,6BAA6B;AAAA,YAC3C,UAAU;AAAA,YACV;AAAA,YACA,UAAU,KAAK,QAAQ;AAAA,UAAA,CACxB;AAED,iBAAO;AAAA,QACT,SAAS,OAAO;AAEd,0BAAgB,4BAA4B;AAAA,YAC1C,UAAU;AAAA,YACV,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAAA,YAC5D,UAAU,KAAK,QAAQ;AAAA,UAAA,CACxB;AACD,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,IAAA;AAAA,EAEJ;AAEA,SAAO;AACT;"}

package/dist/esm/code-wrapper.d.ts

@@ -1,9 +0,0 @@
-/**
- * Wrap user code in an async IIFE to support top-level await
- *
- * The code is wrapped so that:
- * 1. Top-level await works
- * 2. Return values are captured and serialized (for isolate boundary transfer)
- * 3. Errors propagate correctly
- */
-export declare function wrapCode(code: string): string;

package/dist/esm/code-wrapper.js

@@ -1,18 +0,0 @@
-function wrapCode(code) {
-  return `
-(async function() {
-  try {
-    const __userResult = await (async function() {
-${code}
-    })();
-    return JSON.stringify(__userResult);
-  } catch (__error) {
-    throw __error;
-  }
-})()
-`;
-}
-export {
-  wrapCode
-};
-//# sourceMappingURL=code-wrapper.js.map

package/dist/esm/code-wrapper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"code-wrapper.js","sources":["../../src/code-wrapper.ts"],"sourcesContent":["/**\n * Wrap user code in an async IIFE to support top-level await\n *\n * The code is wrapped so that:\n * 1. Top-level await works\n * 2. Return values are captured and serialized (for isolate boundary transfer)\n * 3. Errors propagate correctly\n */\nexport function wrapCode(code: string): string {\n  // Results must be serialized to JSON because objects can't be transferred\n  // directly across the isolate boundary in isolated-vm\n  return `\n(async function() {\n  try {\n    const __userResult = await (async function() {\n${code}\n    })();\n    return JSON.stringify(__userResult);\n  } catch (__error) {\n    throw __error;\n  }\n})()\n`\n}\n"],"names":[],"mappings":"AAQO,SAAS,SAAS,MAAsB;AAG7C,SAAO;AAAA;AAAA;AAAA;AAAA,EAIP,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQN;"}