@tanstack/ai 0.0.1

package/dist/esm/tools/tool-calls.js

@@ -0,0 +1,302 @@
+class ToolCallManager {
+  constructor(tools) {
+    this.toolCallsMap = /* @__PURE__ */ new Map();
+    this.tools = tools;
+  }
+  /**
+   * Add a tool call chunk to the accumulator
+   * Handles streaming tool calls by accumulating arguments
+   */
+  addToolCallChunk(chunk) {
+    const index = chunk.index;
+    const existing = this.toolCallsMap.get(index);
+    if (!existing) {
+      if (chunk.toolCall.id && chunk.toolCall.function.name) {
+        this.toolCallsMap.set(index, {
+          id: chunk.toolCall.id,
+          type: "function",
+          function: {
+            name: chunk.toolCall.function.name,
+            arguments: chunk.toolCall.function.arguments || ""
+          }
+        });
+      }
+    } else {
+      if (chunk.toolCall.function.name && !existing.function.name) {
+        existing.function.name = chunk.toolCall.function.name;
+      }
+      if (chunk.toolCall.function.arguments) {
+        existing.function.arguments += chunk.toolCall.function.arguments;
+      }
+    }
+  }
+  /**
+   * Check if there are any complete tool calls to execute
+   */
+  hasToolCalls() {
+    return this.getToolCalls().length > 0;
+  }
+  /**
+   * Get all complete tool calls (filtered for valid ID and name)
+   */
+  getToolCalls() {
+    return Array.from(this.toolCallsMap.values()).filter(
+      (tc) => tc.id && tc.function.name && tc.function.name.trim().length > 0
+    );
+  }
+  /**
+   * Execute all tool calls and return tool result messages
+   * Also yields tool_result chunks for streaming
+   */
+  async *executeTools(doneChunk) {
+    const toolCallsArray = this.getToolCalls();
+    const toolResults = [];
+    for (const toolCall of toolCallsArray) {
+      const tool = this.tools.find((t) => t.name === toolCall.function.name);
+      let toolResultContent;
+      if (tool?.execute) {
+        try {
+          let args;
+          try {
+            args = JSON.parse(toolCall.function.arguments);
+          } catch (parseError) {
+            throw new Error(
+              `Failed to parse tool arguments as JSON: ${toolCall.function.arguments}`
+            );
+          }
+          if (tool.inputSchema) {
+            try {
+              args = tool.inputSchema.parse(args);
+            } catch (validationError) {
+              throw new Error(
+                `Input validation failed for tool ${tool.name}: ${validationError.message}`
+              );
+            }
+          }
+          let result = await tool.execute(args);
+          if (tool.outputSchema && result !== void 0 && result !== null) {
+            try {
+              result = tool.outputSchema.parse(result);
+            } catch (validationError) {
+              throw new Error(
+                `Output validation failed for tool ${tool.name}: ${validationError.message}`
+              );
+            }
+          }
+          toolResultContent = typeof result === "string" ? result : JSON.stringify(result);
+        } catch (error) {
+          toolResultContent = `Error executing tool: ${error.message}`;
+        }
+      } else {
+        toolResultContent = `Tool ${toolCall.function.name} does not have an execute function`;
+      }
+      yield {
+        type: "tool_result",
+        id: doneChunk.id,
+        model: doneChunk.model,
+        timestamp: Date.now(),
+        toolCallId: toolCall.id,
+        content: toolResultContent
+      };
+      toolResults.push({
+        role: "tool",
+        content: toolResultContent,
+        toolCallId: toolCall.id
+      });
+    }
+    return toolResults;
+  }
+  /**
+   * Clear the tool calls map for the next iteration
+   */
+  clear() {
+    this.toolCallsMap.clear();
+  }
+}
+async function executeToolCalls(toolCalls, tools, approvals = /* @__PURE__ */ new Map(), clientResults = /* @__PURE__ */ new Map()) {
+  const results = [];
+  const needsApproval = [];
+  const needsClientExecution = [];
+  const toolMap = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    toolMap.set(tool.name, tool);
+  }
+  for (const toolCall of toolCalls) {
+    const tool = toolMap.get(toolCall.function.name);
+    const toolName = toolCall.function.name;
+    if (!tool) {
+      results.push({
+        toolCallId: toolCall.id,
+        toolName,
+        result: { error: `Unknown tool: ${toolName}` },
+        state: "output-error"
+      });
+      continue;
+    }
+    let input = {};
+    const argsStr = toolCall.function.arguments.trim() || "{}";
+    {
+      try {
+        input = JSON.parse(argsStr);
+      } catch (parseError) {
+        throw new Error(`Failed to parse tool arguments as JSON: ${argsStr}`);
+      }
+    }
+    if (tool.inputSchema) {
+      try {
+        input = tool.inputSchema.parse(input);
+      } catch (validationError) {
+        results.push({
+          toolCallId: toolCall.id,
+          toolName,
+          result: {
+            error: `Input validation failed for tool ${tool.name}: ${validationError.message}`
+          },
+          state: "output-error"
+        });
+        continue;
+      }
+    }
+    if (!tool.execute) {
+      if (tool.needsApproval) {
+        const approvalId = `approval_${toolCall.id}`;
+        if (approvals.has(approvalId)) {
+          const approved = approvals.get(approvalId);
+          if (approved) {
+            if (clientResults.has(toolCall.id)) {
+              results.push({
+                toolCallId: toolCall.id,
+                toolName,
+                result: clientResults.get(toolCall.id)
+              });
+            } else {
+              needsClientExecution.push({
+                toolCallId: toolCall.id,
+                toolName,
+                input
+              });
+            }
+          } else {
+            results.push({
+              toolCallId: toolCall.id,
+              toolName,
+              result: { error: "User declined tool execution" },
+              state: "output-error"
+            });
+          }
+        } else {
+          needsApproval.push({
+            toolCallId: toolCall.id,
+            toolName: toolCall.function.name,
+            input,
+            approvalId
+          });
+        }
+      } else {
+        if (clientResults.has(toolCall.id)) {
+          results.push({
+            toolCallId: toolCall.id,
+            toolName,
+            result: clientResults.get(toolCall.id)
+          });
+        } else {
+          needsClientExecution.push({
+            toolCallId: toolCall.id,
+            toolName,
+            input
+          });
+        }
+      }
+      continue;
+    }
+    if (tool.needsApproval) {
+      const approvalId = `approval_${toolCall.id}`;
+      if (approvals.has(approvalId)) {
+        const approved = approvals.get(approvalId);
+        if (approved) {
+          const startTime2 = Date.now();
+          try {
+            let result = await tool.execute(input);
+            const duration = Date.now() - startTime2;
+            if (tool.outputSchema && result !== void 0 && result !== null) {
+              const parsed = tool.outputSchema.safeParse(result);
+              if (parsed.success) {
+                result = parsed.data;
+              } else {
+                throw new Error(
+                  `Output validation failed for tool ${tool.name}: ${parsed.error.message}`
+                );
+              }
+            }
+            results.push({
+              toolCallId: toolCall.id,
+              toolName,
+              result: typeof result === "string" ? JSON.parse(result) : result || null,
+              duration
+            });
+          } catch (error) {
+            const duration = Date.now() - startTime2;
+            results.push({
+              toolCallId: toolCall.id,
+              toolName,
+              result: { error: error.message },
+              state: "output-error",
+              duration
+            });
+          }
+        } else {
+          results.push({
+            toolCallId: toolCall.id,
+            toolName,
+            result: { error: "User declined tool execution" },
+            state: "output-error"
+          });
+        }
+      } else {
+        needsApproval.push({
+          toolCallId: toolCall.id,
+          toolName,
+          input,
+          approvalId
+        });
+      }
+      continue;
+    }
+    const startTime = Date.now();
+    try {
+      let result = await tool.execute(input);
+      const duration = Date.now() - startTime;
+      if (tool.outputSchema && result !== void 0 && result !== null) {
+        const parsed = tool.outputSchema.safeParse(result);
+        if (parsed.success) {
+          result = parsed.data;
+        } else {
+          throw new Error(
+            `Output validation failed for tool ${tool.name}: ${parsed.error.message}`
+          );
+        }
+      }
+      results.push({
+        toolCallId: toolCall.id,
+        toolName,
+        result: typeof result === "string" ? JSON.parse(result) : result || null,
+        duration
+      });
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      results.push({
+        toolCallId: toolCall.id,
+        toolName,
+        result: { error: error.message },
+        state: "output-error",
+        duration
+      });
+    }
+  }
+  return { results, needsApproval, needsClientExecution };
+}
+export {
+  ToolCallManager,
+  executeToolCalls
+};
+//# sourceMappingURL=tool-calls.js.map

package/dist/esm/tools/tool-calls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-calls.js","sources":["../../../src/tools/tool-calls.ts"],"sourcesContent":["import type {\n  DoneStreamChunk,\n  ModelMessage,\n  Tool,\n  ToolCall,\n  ToolResultStreamChunk,\n} from '../types'\n\n/**\n * Manages tool call accumulation and execution for the chat() method's automatic tool execution loop.\n *\n * Responsibilities:\n * - Accumulates streaming tool call chunks (ID, name, arguments)\n * - Validates tool calls (filters out incomplete ones)\n * - Executes tool `execute` functions with parsed arguments\n * - Emits `tool_result` chunks for client visibility\n * - Returns tool result messages for conversation history\n *\n * This class is used internally by the AI.chat() method to handle the automatic\n * tool execution loop. It can also be used independently for custom tool execution logic.\n *\n * @example\n * ```typescript\n * const manager = new ToolCallManager(tools);\n *\n * // During streaming, accumulate tool calls\n * for await (const chunk of stream) {\n *   if (chunk.type === \"tool_call\") {\n *     manager.addToolCallChunk(chunk);\n *   }\n * }\n *\n * // After stream completes, execute tools\n * if (manager.hasToolCalls()) {\n *   const toolResults = yield* manager.executeTools(doneChunk);\n *   messages = [...messages, ...toolResults];\n *   manager.clear();\n * }\n * ```\n */\nexport class ToolCallManager {\n  private toolCallsMap = new Map<number, ToolCall>()\n  private tools: ReadonlyArray<Tool>\n\n  constructor(tools: ReadonlyArray<Tool>) {\n    this.tools = tools\n  }\n\n  /**\n   * Add a tool call chunk to the accumulator\n   * Handles streaming tool calls by accumulating arguments\n   */\n  addToolCallChunk(chunk: {\n    toolCall: {\n      id: string\n      type: 'function'\n      function: {\n        name: string\n        arguments: string\n      }\n    }\n    index: number\n  }): void {\n    const index = chunk.index\n    const existing = this.toolCallsMap.get(index)\n\n    if (!existing) {\n      // Only create entry if we have a tool call ID and name\n      if (chunk.toolCall.id && chunk.toolCall.function.name) {\n        this.toolCallsMap.set(index, {\n          id: chunk.toolCall.id,\n          type: 'function',\n          function: {\n            name: chunk.toolCall.function.name,\n            arguments: chunk.toolCall.function.arguments || '',\n          },\n        })\n      }\n    } else {\n      // Update name if it wasn't set before\n      if (chunk.toolCall.function.name && !existing.function.name) {\n        existing.function.name = chunk.toolCall.function.name\n      }\n      // Accumulate arguments for streaming tool calls\n      if (chunk.toolCall.function.arguments) {\n        existing.function.arguments += chunk.toolCall.function.arguments\n      }\n    }\n  }\n\n  /**\n   * Check if there are any complete tool calls to execute\n   */\n  hasToolCalls(): boolean {\n    return this.getToolCalls().length > 0\n  }\n\n  /**\n   * Get all complete tool calls (filtered for valid ID and name)\n   */\n  getToolCalls(): Array<ToolCall> {\n    return Array.from(this.toolCallsMap.values()).filter(\n      (tc) => tc.id && tc.function.name && tc.function.name.trim().length > 0,\n    )\n  }\n\n  /**\n   * Execute all tool calls and return tool result messages\n   * Also yields tool_result chunks for streaming\n   */\n  async *executeTools(\n    doneChunk: DoneStreamChunk,\n  ): AsyncGenerator<ToolResultStreamChunk, Array<ModelMessage>, void> {\n    const toolCallsArray = this.getToolCalls()\n    const toolResults: Array<ModelMessage> = []\n\n    for (const toolCall of toolCallsArray) {\n      const tool = this.tools.find((t) => t.name === toolCall.function.name)\n\n      let toolResultContent: string\n      if (tool?.execute) {\n        try {\n          // Parse arguments\n          let args: any\n          try {\n            args = JSON.parse(toolCall.function.arguments)\n          } catch (parseError) {\n            throw new Error(\n              `Failed to parse tool arguments as JSON: ${toolCall.function.arguments}`,\n            )\n          }\n\n          // Validate input against inputSchema\n          if (tool.inputSchema) {\n            try {\n              args = tool.inputSchema.parse(args)\n            } catch (validationError: any) {\n              throw new Error(\n                `Input validation failed for tool ${tool.name}: ${validationError.message}`,\n              )\n            }\n          }\n\n          // Execute the tool\n          let result = await tool.execute(args)\n\n          // Validate output against outputSchema if provided\n          if (tool.outputSchema && result !== undefined && result !== null) {\n            try {\n              result = tool.outputSchema.parse(result)\n            } catch (validationError: any) {\n              throw new Error(\n                `Output validation failed for tool ${tool.name}: ${validationError.message}`,\n              )\n            }\n          }\n\n          toolResultContent =\n            typeof result === 'string' ? result : JSON.stringify(result)\n        } catch (error: any) {\n          // If tool execution fails, add error message\n          toolResultContent = `Error executing tool: ${error.message}`\n        }\n      } else {\n        // Tool doesn't have execute function, add placeholder\n        toolResultContent = `Tool ${toolCall.function.name} does not have an execute function`\n      }\n\n      // Emit tool_result chunk so callers can track tool execution\n      yield {\n        type: 'tool_result',\n        id: doneChunk.id,\n        model: doneChunk.model,\n        timestamp: Date.now(),\n        toolCallId: toolCall.id,\n        content: toolResultContent,\n      }\n\n      // Add tool result message\n      toolResults.push({\n        role: 'tool',\n        content: toolResultContent,\n        toolCallId: toolCall.id,\n      })\n    }\n\n    return toolResults\n  }\n\n  /**\n   * Clear the tool calls map for the next iteration\n   */\n  clear(): void {\n    this.toolCallsMap.clear()\n  }\n}\n\nexport interface ToolResult {\n  toolCallId: string\n  toolName: string\n  result: any\n  state?: 'output-available' | 'output-error'\n  /** Duration of tool execution in milliseconds (only for server-executed tools) */\n  duration?: number\n}\n\nexport interface ApprovalRequest {\n  toolCallId: string\n  toolName: string\n  input: any\n  approvalId: string\n}\n\nexport interface ClientToolRequest {\n  toolCallId: string\n  toolName: string\n  input: any\n}\n\ninterface ExecuteToolCallsResult {\n  /** Tool results ready to send to LLM */\n  results: Array<ToolResult>\n  /** Tools that need user approval before execution */\n  needsApproval: Array<ApprovalRequest>\n  /** Tools that need client-side execution */\n  needsClientExecution: Array<ClientToolRequest>\n}\n\n/**\n * Execute tool calls based on their configuration\n *\n * Handles three cases:\n * 1. Client tools (no execute) - request client to execute\n * 2. Server tools with approval - check approval before executing\n * 3. Normal server tools - execute immediately\n *\n * @param toolCalls - Tool calls from the LLM\n * @param tools - Available tools with their configurations\n * @param approvals - Map of approval decisions (approval.id -> approved boolean)\n * @param clientResults - Map of client-side execution results (toolCallId -> result)\n */\nexport async function executeToolCalls(\n  toolCalls: Array<ToolCall>,\n  tools: ReadonlyArray<Tool>,\n  approvals: Map<string, boolean> = new Map(),\n  clientResults: Map<string, any> = new Map(),\n): Promise<ExecuteToolCallsResult> {\n  const results: Array<ToolResult> = []\n  const needsApproval: Array<ApprovalRequest> = []\n  const needsClientExecution: Array<ClientToolRequest> = []\n\n  // Create tool lookup map\n  const toolMap = new Map<string, Tool>()\n  for (const tool of tools) {\n    toolMap.set(tool.name, tool)\n  }\n\n  for (const toolCall of toolCalls) {\n    const tool = toolMap.get(toolCall.function.name)\n    const toolName = toolCall.function.name\n\n    if (!tool) {\n      // Unknown tool - return error\n      results.push({\n        toolCallId: toolCall.id,\n        toolName,\n        result: { error: `Unknown tool: ${toolName}` },\n        state: 'output-error',\n      })\n      continue\n    }\n\n    // Parse arguments, throwing error if invalid JSON\n    let input: any = {}\n    const argsStr = toolCall.function.arguments.trim() || '{}'\n    if (argsStr) {\n      try {\n        input = JSON.parse(argsStr)\n      } catch (parseError) {\n        // If parsing fails, throw error to fail fast\n        throw new Error(`Failed to parse tool arguments as JSON: ${argsStr}`)\n      }\n    }\n\n    // Validate input against inputSchema\n    if (tool.inputSchema) {\n      try {\n        input = tool.inputSchema.parse(input)\n      } catch (validationError: any) {\n        results.push({\n          toolCallId: toolCall.id,\n          toolName,\n          result: {\n            error: `Input validation failed for tool ${tool.name}: ${validationError.message}`,\n          },\n          state: 'output-error',\n        })\n        continue\n      }\n    }\n\n    // CASE 1: Client-side tool (no execute function)\n    if (!tool.execute) {\n      // Check if tool needs approval\n      if (tool.needsApproval) {\n        const approvalId = `approval_${toolCall.id}`\n\n        // Check if approval decision exists\n        if (approvals.has(approvalId)) {\n          const approved = approvals.get(approvalId)\n\n          if (approved) {\n            // Approved - check if client has executed\n            if (clientResults.has(toolCall.id)) {\n              results.push({\n                toolCallId: toolCall.id,\n                toolName,\n                result: clientResults.get(toolCall.id),\n              })\n            } else {\n              // Approved but not executed yet - request client execution\n              needsClientExecution.push({\n                toolCallId: toolCall.id,\n                toolName,\n                input,\n              })\n            }\n          } else {\n            // User declined\n            results.push({\n              toolCallId: toolCall.id,\n              toolName,\n              result: { error: 'User declined tool execution' },\n              state: 'output-error',\n            })\n          }\n        } else {\n          // Need approval first\n          needsApproval.push({\n            toolCallId: toolCall.id,\n            toolName: toolCall.function.name,\n            input,\n            approvalId,\n          })\n        }\n      } else {\n        // No approval needed - check if client has executed\n        if (clientResults.has(toolCall.id)) {\n          results.push({\n            toolCallId: toolCall.id,\n            toolName,\n            result: clientResults.get(toolCall.id),\n          })\n        } else {\n          // Request client execution\n          needsClientExecution.push({\n            toolCallId: toolCall.id,\n            toolName,\n            input,\n          })\n        }\n      }\n      continue\n    }\n\n    // CASE 2: Server tool with approval required\n    if (tool.needsApproval) {\n      const approvalId = `approval_${toolCall.id}`\n\n      // Check if approval decision exists\n      if (approvals.has(approvalId)) {\n        const approved = approvals.get(approvalId)\n\n        if (approved) {\n          // Execute after approval\n          const startTime = Date.now()\n          try {\n            let result = await tool.execute(input)\n            const duration = Date.now() - startTime\n\n            // Validate output against outputSchema if provided\n            if (tool.outputSchema && result !== undefined && result !== null) {\n              const parsed = tool.outputSchema.safeParse(result)\n              if (parsed.success) {\n                result = parsed.data\n              } else {\n                throw new Error(\n                  `Output validation failed for tool ${tool.name}: ${parsed.error.message}`,\n                )\n              }\n            }\n\n            results.push({\n              toolCallId: toolCall.id,\n              toolName,\n              result:\n                typeof result === 'string'\n                  ? JSON.parse(result)\n                  : result || null,\n              duration,\n            })\n          } catch (error: any) {\n            const duration = Date.now() - startTime\n            results.push({\n              toolCallId: toolCall.id,\n              toolName,\n              result: { error: error.message },\n              state: 'output-error',\n              duration,\n            })\n          }\n        } else {\n          // User declined\n          results.push({\n            toolCallId: toolCall.id,\n            toolName,\n            result: { error: 'User declined tool execution' },\n            state: 'output-error',\n          })\n        }\n      } else {\n        // Need approval\n        needsApproval.push({\n          toolCallId: toolCall.id,\n          toolName,\n          input,\n          approvalId,\n        })\n      }\n      continue\n    }\n\n    // CASE 3: Normal server tool - execute immediately\n    const startTime = Date.now()\n    try {\n      let result = await tool.execute(input)\n      const duration = Date.now() - startTime\n\n      // Validate output against outputSchema if provided\n      if (tool.outputSchema && result !== undefined && result !== null) {\n        const parsed = tool.outputSchema.safeParse(result)\n        if (parsed.success) {\n          result = parsed.data\n        } else {\n          throw new Error(\n            `Output validation failed for tool ${tool.name}: ${parsed.error.message}`,\n          )\n        }\n      }\n\n      results.push({\n        toolCallId: toolCall.id,\n        toolName,\n        result:\n          typeof result === 'string' ? JSON.parse(result) : result || null,\n        duration,\n      })\n    } catch (error: any) {\n      const duration = Date.now() - startTime\n      results.push({\n        toolCallId: toolCall.id,\n        toolName,\n        result: { error: error.message },\n        state: 'output-error',\n        duration,\n      })\n    }\n  }\n\n  return { results, needsApproval, needsClientExecution }\n}\n"],"names":["startTime"],"mappings":"AAwCO,MAAM,gBAAgB;AAAA,EAI3B,YAAY,OAA4B;AAHxC,SAAQ,mCAAmB,IAAA;AAIzB,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,iBAAiB,OAUR;AACP,UAAM,QAAQ,MAAM;AACpB,UAAM,WAAW,KAAK,aAAa,IAAI,KAAK;AAE5C,QAAI,CAAC,UAAU;AAEb,UAAI,MAAM,SAAS,MAAM,MAAM,SAAS,SAAS,MAAM;AACrD,aAAK,aAAa,IAAI,OAAO;AAAA,UAC3B,IAAI,MAAM,SAAS;AAAA,UACnB,MAAM;AAAA,UACN,UAAU;AAAA,YACR,MAAM,MAAM,SAAS,SAAS;AAAA,YAC9B,WAAW,MAAM,SAAS,SAAS,aAAa;AAAA,UAAA;AAAA,QAClD,CACD;AAAA,MACH;AAAA,IACF,OAAO;AAEL,UAAI,MAAM,SAAS,SAAS,QAAQ,CAAC,SAAS,SAAS,MAAM;AAC3D,iBAAS,SAAS,OAAO,MAAM,SAAS,SAAS;AAAA,MACnD;AAEA,UAAI,MAAM,SAAS,SAAS,WAAW;AACrC,iBAAS,SAAS,aAAa,MAAM,SAAS,SAAS;AAAA,MACzD;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,eAAwB;AACtB,WAAO,KAAK,eAAe,SAAS;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA,EAKA,eAAgC;AAC9B,WAAO,MAAM,KAAK,KAAK,aAAa,OAAA,CAAQ,EAAE;AAAA,MAC5C,CAAC,OAAO,GAAG,MAAM,GAAG,SAAS,QAAQ,GAAG,SAAS,KAAK,KAAA,EAAO,SAAS;AAAA,IAAA;AAAA,EAE1E;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,aACL,WACkE;AAClE,UAAM,iBAAiB,KAAK,aAAA;AAC5B,UAAM,cAAmC,CAAA;AAEzC,eAAW,YAAY,gBAAgB;AACrC,YAAM,OAAO,KAAK,MAAM,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS,SAAS,IAAI;AAErE,UAAI;AACJ,UAAI,MAAM,SAAS;AACjB,YAAI;AAEF,cAAI;AACJ,cAAI;AACF,mBAAO,KAAK,MAAM,SAAS,SAAS,SAAS;AAAA,UAC/C,SAAS,YAAY;AACnB,kBAAM,IAAI;AAAA,cACR,2CAA2C,SAAS,SAAS,SAAS;AAAA,YAAA;AAAA,UAE1E;AAGA,cAAI,KAAK,aAAa;AACpB,gBAAI;AACF,qBAAO,KAAK,YAAY,MAAM,IAAI;AAAA,YACpC,SAAS,iBAAsB;AAC7B,oBAAM,IAAI;AAAA,gBACR,oCAAoC,KAAK,IAAI,KAAK,gBAAgB,OAAO;AAAA,cAAA;AAAA,YAE7E;AAAA,UACF;AAGA,cAAI,SAAS,MAAM,KAAK,QAAQ,IAAI;AAGpC,cAAI,KAAK,gBAAgB,WAAW,UAAa,WAAW,MAAM;AAChE,gBAAI;AACF,uBAAS,KAAK,aAAa,MAAM,MAAM;AAAA,YACzC,SAAS,iBAAsB;AAC7B,oBAAM,IAAI;AAAA,gBACR,qCAAqC,KAAK,IAAI,KAAK,gBAAgB,OAAO;AAAA,cAAA;AAAA,YAE9E;AAAA,UACF;AAEA,8BACE,OAAO,WAAW,WAAW,SAAS,KAAK,UAAU,MAAM;AAAA,QAC/D,SAAS,OAAY;AAEnB,8BAAoB,yBAAyB,MAAM,OAAO;AAAA,QAC5D;AAAA,MACF,OAAO;AAEL,4BAAoB,QAAQ,SAAS,SAAS,IAAI;AAAA,MACpD;AAGA,YAAM;AAAA,QACJ,MAAM;AAAA,QACN,IAAI,UAAU;AAAA,QACd,OAAO,UAAU;AAAA,QACjB,WAAW,KAAK,IAAA;AAAA,QAChB,YAAY,SAAS;AAAA,QACrB,SAAS;AAAA,MAAA;AAIX,kBAAY,KAAK;AAAA,QACf,MAAM;AAAA,QACN,SAAS;AAAA,QACT,YAAY,SAAS;AAAA,MAAA,CACtB;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,aAAa,MAAA;AAAA,EACpB;AACF;AA8CA,eAAsB,iBACpB,WACA,OACA,YAAkC,oBAAI,OACtC,gBAAkC,oBAAI,OACL;AACjC,QAAM,UAA6B,CAAA;AACnC,QAAM,gBAAwC,CAAA;AAC9C,QAAM,uBAAiD,CAAA;AAGvD,QAAM,8BAAc,IAAA;AACpB,aAAW,QAAQ,OAAO;AACxB,YAAQ,IAAI,KAAK,MAAM,IAAI;AAAA,EAC7B;AAEA,aAAW,YAAY,WAAW;AAChC,UAAM,OAAO,QAAQ,IAAI,SAAS,SAAS,IAAI;AAC/C,UAAM,WAAW,SAAS,SAAS;AAEnC,QAAI,CAAC,MAAM;AAET,cAAQ,KAAK;AAAA,QACX,YAAY,SAAS;AAAA,QACrB;AAAA,QACA,QAAQ,EAAE,OAAO,iBAAiB,QAAQ,GAAA;AAAA,QAC1C,OAAO;AAAA,MAAA,CACR;AACD;AAAA,IACF;AAGA,QAAI,QAAa,CAAA;AACjB,UAAM,UAAU,SAAS,SAAS,UAAU,UAAU;AACzC;AACX,UAAI;AACF,gBAAQ,KAAK,MAAM,OAAO;AAAA,MAC5B,SAAS,YAAY;AAEnB,cAAM,IAAI,MAAM,2CAA2C,OAAO,EAAE;AAAA,MACtE;AAAA,IACF;AAGA,QAAI,KAAK,aAAa;AACpB,UAAI;AACF,gBAAQ,KAAK,YAAY,MAAM,KAAK;AAAA,MACtC,SAAS,iBAAsB;AAC7B,gBAAQ,KAAK;AAAA,UACX,YAAY,SAAS;AAAA,UACrB;AAAA,UACA,QAAQ;AAAA,YACN,OAAO,oCAAoC,KAAK,IAAI,KAAK,gBAAgB,OAAO;AAAA,UAAA;AAAA,UAElF,OAAO;AAAA,QAAA,CACR;AACD;AAAA,MACF;AAAA,IACF;AAGA,QAAI,CAAC,KAAK,SAAS;AAEjB,UAAI,KAAK,eAAe;AACtB,cAAM,aAAa,YAAY,SAAS,EAAE;AAG1C,YAAI,UAAU,IAAI,UAAU,GAAG;AAC7B,gBAAM,WAAW,UAAU,IAAI,UAAU;AAEzC,cAAI,UAAU;AAEZ,gBAAI,cAAc,IAAI,SAAS,EAAE,GAAG;AAClC,sBAAQ,KAAK;AAAA,gBACX,YAAY,SAAS;AAAA,gBACrB;AAAA,gBACA,QAAQ,cAAc,IAAI,SAAS,EAAE;AAAA,cAAA,CACtC;AAAA,YACH,OAAO;AAEL,mCAAqB,KAAK;AAAA,gBACxB,YAAY,SAAS;AAAA,gBACrB;AAAA,gBACA;AAAA,cAAA,CACD;AAAA,YACH;AAAA,UACF,OAAO;AAEL,oBAAQ,KAAK;AAAA,cACX,YAAY,SAAS;AAAA,cACrB;AAAA,cACA,QAAQ,EAAE,OAAO,+BAAA;AAAA,cACjB,OAAO;AAAA,YAAA,CACR;AAAA,UACH;AAAA,QACF,OAAO;AAEL,wBAAc,KAAK;AAAA,YACjB,YAAY,SAAS;AAAA,YACrB,UAAU,SAAS,SAAS;AAAA,YAC5B;AAAA,YACA;AAAA,UAAA,CACD;AAAA,QACH;AAAA,MACF,OAAO;AAEL,YAAI,cAAc,IAAI,SAAS,EAAE,GAAG;AAClC,kBAAQ,KAAK;AAAA,YACX,YAAY,SAAS;AAAA,YACrB;AAAA,YACA,QAAQ,cAAc,IAAI,SAAS,EAAE;AAAA,UAAA,CACtC;AAAA,QACH,OAAO;AAEL,+BAAqB,KAAK;AAAA,YACxB,YAAY,SAAS;AAAA,YACrB;AAAA,YACA;AAAA,UAAA,CACD;AAAA,QACH;AAAA,MACF;AACA;AAAA,IACF;AAGA,QAAI,KAAK,eAAe;AACtB,YAAM,aAAa,YAAY,SAAS,EAAE;AAG1C,UAAI,UAAU,IAAI,UAAU,GAAG;AAC7B,cAAM,WAAW,UAAU,IAAI,UAAU;AAEzC,YAAI,UAAU;AAEZ,gBAAMA,aAAY,KAAK,IAAA;AACvB,cAAI;AACF,gBAAI,SAAS,MAAM,KAAK,QAAQ,KAAK;AACrC,kBAAM,WAAW,KAAK,IAAA,IAAQA;AAG9B,gBAAI,KAAK,gBAAgB,WAAW,UAAa,WAAW,MAAM;AAChE,oBAAM,SAAS,KAAK,aAAa,UAAU,MAAM;AACjD,kBAAI,OAAO,SAAS;AAClB,yBAAS,OAAO;AAAA,cAClB,OAAO;AACL,sBAAM,IAAI;AAAA,kBACR,qCAAqC,KAAK,IAAI,KAAK,OAAO,MAAM,OAAO;AAAA,gBAAA;AAAA,cAE3E;AAAA,YACF;AAEA,oBAAQ,KAAK;AAAA,cACX,YAAY,SAAS;AAAA,cACrB;AAAA,cACA,QACE,OAAO,WAAW,WACd,KAAK,MAAM,MAAM,IACjB,UAAU;AAAA,cAChB;AAAA,YAAA,CACD;AAAA,UACH,SAAS,OAAY;AACnB,kBAAM,WAAW,KAAK,IAAA,IAAQA;AAC9B,oBAAQ,KAAK;AAAA,cACX,YAAY,SAAS;AAAA,cACrB;AAAA,cACA,QAAQ,EAAE,OAAO,MAAM,QAAA;AAAA,cACvB,OAAO;AAAA,cACP;AAAA,YAAA,CACD;AAAA,UACH;AAAA,QACF,OAAO;AAEL,kBAAQ,KAAK;AAAA,YACX,YAAY,SAAS;AAAA,YACrB;AAAA,YACA,QAAQ,EAAE,OAAO,+BAAA;AAAA,YACjB,OAAO;AAAA,UAAA,CACR;AAAA,QACH;AAAA,MACF,OAAO;AAEL,sBAAc,KAAK;AAAA,UACjB,YAAY,SAAS;AAAA,UACrB;AAAA,UACA;AAAA,UACA;AAAA,QAAA,CACD;AAAA,MACH;AACA;AAAA,IACF;AAGA,UAAM,YAAY,KAAK,IAAA;AACvB,QAAI;AACF,UAAI,SAAS,MAAM,KAAK,QAAQ,KAAK;AACrC,YAAM,WAAW,KAAK,IAAA,IAAQ;AAG9B,UAAI,KAAK,gBAAgB,WAAW,UAAa,WAAW,MAAM;AAChE,cAAM,SAAS,KAAK,aAAa,UAAU,MAAM;AACjD,YAAI,OAAO,SAAS;AAClB,mBAAS,OAAO;AAAA,QAClB,OAAO;AACL,gBAAM,IAAI;AAAA,YACR,qCAAqC,KAAK,IAAI,KAAK,OAAO,MAAM,OAAO;AAAA,UAAA;AAAA,QAE3E;AAAA,MACF;AAEA,cAAQ,KAAK;AAAA,QACX,YAAY,SAAS;AAAA,QACrB;AAAA,QACA,QACE,OAAO,WAAW,WAAW,KAAK,MAAM,MAAM,IAAI,UAAU;AAAA,QAC9D;AAAA,MAAA,CACD;AAAA,IACH,SAAS,OAAY;AACnB,YAAM,WAAW,KAAK,IAAA,IAAQ;AAC9B,cAAQ,KAAK;AAAA,QACX,YAAY,SAAS;AAAA,QACrB;AAAA,QACA,QAAQ,EAAE,OAAO,MAAM,QAAA;AAAA,QACvB,OAAO;AAAA,QACP;AAAA,MAAA,CACD;AAAA,IACH;AAAA,EACF;AAEA,SAAO,EAAE,SAAS,eAAe,qBAAA;AACnC;"}

package/dist/esm/tools/tool-definition.d.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { Tool } from '../types.js';
+/**
+ * Marker type for server-side tools
+ */
+export interface ServerTool<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType, TName extends string = string> extends Tool<TInput, TOutput, TName> {
+    __toolSide: 'server';
+}
+/**
+ * Marker type for client-side tools
+ */
+export interface ClientTool<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType, TName extends string = string> {
+    __toolSide: 'client';
+    name: TName;
+    description: string;
+    inputSchema?: TInput;
+    outputSchema?: TOutput;
+    needsApproval?: boolean;
+    metadata?: Record<string, any>;
+    execute?: (args: z.infer<TInput>) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+}
+/**
+ * Tool definition that can be used directly or instantiated for server/client
+ */
+export interface ToolDefinitionInstance<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType, TName extends string = string> extends Tool<TInput, TOutput, TName> {
+    __toolSide: 'definition';
+}
+/**
+ * Union type for any kind of client-side tool (client tool or definition)
+ */
+export type AnyClientTool = ClientTool<any, any> | ToolDefinitionInstance<any, any>;
+/**
+ * Extract the tool name as a literal type
+ */
+export type InferToolName<T> = T extends {
+    name: infer N;
+} ? N : never;
+/**
+ * Extract the input type from a tool (inferred from Zod schema)
+ */
+export type InferToolInput<T> = T extends {
+    inputSchema?: infer TInput;
+} ? TInput extends z.ZodType ? z.infer<TInput> : any : any;
+/**
+ * Extract the output type from a tool (inferred from Zod schema)
+ */
+export type InferToolOutput<T> = T extends {
+    outputSchema?: infer TOutput;
+} ? TOutput extends z.ZodType ? z.infer<TOutput> : any : any;
+/**
+ * Tool definition configuration
+ */
+export interface ToolDefinitionConfig<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType, TName extends string = string> {
+    name: TName;
+    description: string;
+    inputSchema?: TInput;
+    outputSchema?: TOutput;
+    needsApproval?: boolean;
+    metadata?: Record<string, any>;
+}
+/**
+ * Tool definition builder that allows creating server or client tools from a shared definition
+ */
+export interface ToolDefinition<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType, TName extends string = string> extends ToolDefinitionInstance<TInput, TOutput, TName> {
+    /**
+     * Create a server-side tool with execute function
+     */
+    server: (execute: (args: z.infer<TInput>) => Promise<z.infer<TOutput>> | z.infer<TOutput>) => ServerTool<TInput, TOutput, TName>;
+    /**
+     * Create a client-side tool with optional execute function
+     */
+    client: (execute?: (args: z.infer<TInput>) => Promise<z.infer<TOutput>> | z.infer<TOutput>) => ClientTool<TInput, TOutput, TName>;
+}
+/**
+ * Create an isomorphic tool definition that can be used directly or instantiated for server/client
+ *
+ * The definition contains all tool metadata (name, description, schemas) and can be:
+ * 1. Used directly in chat() on the server (as a tool definition without execute)
+ * 2. Instantiated as a server tool with .server()
+ * 3. Instantiated as a client tool with .client()
+ *
+ * @example
+ * ```typescript
+ * import { toolDefinition } from '@tanstack/ai';
+ * import { z } from 'zod';
+ *
+ * const addToCartTool = toolDefinition({
+ *   name: 'addToCart',
+ *   description: 'Add a guitar to the shopping cart (requires approval)',
+ *   needsApproval: true,
+ *   inputSchema: z.object({
+ *     guitarId: z.string(),
+ *     quantity: z.number(),
+ *   }),
+ *   outputSchema: z.object({
+ *     success: z.boolean(),
+ *     cartId: z.string(),
+ *     totalItems: z.number(),
+ *   }),
+ * });
+ *
+ * // Use directly in chat (server-side, no execute function)
+ * chat({
+ *   tools: [addToCartTool],
+ *   // ...
+ * });
+ *
+ * // Or create server-side implementation
+ * const addToCartServer = addToCartTool.server(async (args) => {
+ *   // args is typed as { guitarId: string; quantity: number }
+ *   return {
+ *     success: true,
+ *     cartId: 'CART_' + Date.now(),
+ *     totalItems: args.quantity,
+ *   };
+ * });
+ *
+ * // Or create client-side implementation
+ * const addToCartClient = addToCartTool.client(async (args) => {
+ *   // Client-specific logic (e.g., localStorage)
+ *   return { success: true, cartId: 'local', totalItems: 1 };
+ * });
+ * ```
+ */
+export declare function toolDefinition<TInput extends z.ZodType = z.ZodAny, TOutput extends z.ZodType = z.ZodAny, TName extends string = string>(config: ToolDefinitionConfig<TInput, TOutput, TName>): ToolDefinition<TInput, TOutput, TName>;

package/dist/esm/tools/tool-definition.js

@@ -0,0 +1,25 @@
+function toolDefinition(config) {
+  const definition = {
+    __toolSide: "definition",
+    ...config,
+    server(execute) {
+      return {
+        __toolSide: "server",
+        ...config,
+        execute
+      };
+    },
+    client(execute) {
+      return {
+        __toolSide: "client",
+        ...config,
+        execute
+      };
+    }
+  };
+  return definition;
+}
+export {
+  toolDefinition
+};
+//# sourceMappingURL=tool-definition.js.map

package/dist/esm/tools/tool-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-definition.js","sources":["../../../src/tools/tool-definition.ts"],"sourcesContent":["import type { z } from 'zod'\nimport type { Tool } from '../types'\n\n/**\n * Marker type for server-side tools\n */\nexport interface ServerTool<\n  TInput extends z.ZodType = z.ZodType,\n  TOutput extends z.ZodType = z.ZodType,\n  TName extends string = string,\n> extends Tool<TInput, TOutput, TName> {\n  __toolSide: 'server'\n}\n\n/**\n * Marker type for client-side tools\n */\nexport interface ClientTool<\n  TInput extends z.ZodType = z.ZodType,\n  TOutput extends z.ZodType = z.ZodType,\n  TName extends string = string,\n> {\n  __toolSide: 'client'\n  name: TName\n  description: string\n  inputSchema?: TInput\n  outputSchema?: TOutput\n  needsApproval?: boolean\n  metadata?: Record<string, any>\n  execute?: (\n    args: z.infer<TInput>,\n  ) => Promise<z.infer<TOutput>> | z.infer<TOutput>\n}\n\n/**\n * Tool definition that can be used directly or instantiated for server/client\n */\nexport interface ToolDefinitionInstance<\n  TInput extends z.ZodType = z.ZodType,\n  TOutput extends z.ZodType = z.ZodType,\n  TName extends string = string,\n> extends Tool<TInput, TOutput, TName> {\n  __toolSide: 'definition'\n}\n\n/**\n * Union type for any kind of client-side tool (client tool or definition)\n */\nexport type AnyClientTool =\n  | ClientTool<any, any>\n  | ToolDefinitionInstance<any, any>\n\n/**\n * Extract the tool name as a literal type\n */\nexport type InferToolName<T> = T extends { name: infer N } ? N : never\n\n/**\n * Extract the input type from a tool (inferred from Zod schema)\n */\nexport type InferToolInput<T> = T extends { inputSchema?: infer TInput }\n  ? TInput extends z.ZodType\n    ? z.infer<TInput>\n    : any\n  : any\n\n/**\n * Extract the output type from a tool (inferred from Zod schema)\n */\nexport type InferToolOutput<T> = T extends { outputSchema?: infer TOutput }\n  ? TOutput extends z.ZodType\n    ? z.infer<TOutput>\n    : any\n  : any\n\n/**\n * Tool definition configuration\n */\nexport interface ToolDefinitionConfig<\n  TInput extends z.ZodType = z.ZodType,\n  TOutput extends z.ZodType = z.ZodType,\n  TName extends string = string,\n> {\n  name: TName\n  description: string\n  inputSchema?: TInput\n  outputSchema?: TOutput\n  needsApproval?: boolean\n  metadata?: Record<string, any>\n}\n\n/**\n * Tool definition builder that allows creating server or client tools from a shared definition\n */\nexport interface ToolDefinition<\n  TInput extends z.ZodType = z.ZodType,\n  TOutput extends z.ZodType = z.ZodType,\n  TName extends string = string,\n> extends ToolDefinitionInstance<TInput, TOutput, TName> {\n  /**\n   * Create a server-side tool with execute function\n   */\n  server: (\n    execute: (\n      args: z.infer<TInput>,\n    ) => Promise<z.infer<TOutput>> | z.infer<TOutput>,\n  ) => ServerTool<TInput, TOutput, TName>\n\n  /**\n   * Create a client-side tool with optional execute function\n   */\n  client: (\n    execute?: (\n      args: z.infer<TInput>,\n    ) => Promise<z.infer<TOutput>> | z.infer<TOutput>,\n  ) => ClientTool<TInput, TOutput, TName>\n}\n\n/**\n * Create an isomorphic tool definition that can be used directly or instantiated for server/client\n *\n * The definition contains all tool metadata (name, description, schemas) and can be:\n * 1. Used directly in chat() on the server (as a tool definition without execute)\n * 2. Instantiated as a server tool with .server()\n * 3. Instantiated as a client tool with .client()\n *\n * @example\n * ```typescript\n * import { toolDefinition } from '@tanstack/ai';\n * import { z } from 'zod';\n *\n * const addToCartTool = toolDefinition({\n *   name: 'addToCart',\n *   description: 'Add a guitar to the shopping cart (requires approval)',\n *   needsApproval: true,\n *   inputSchema: z.object({\n *     guitarId: z.string(),\n *     quantity: z.number(),\n *   }),\n *   outputSchema: z.object({\n *     success: z.boolean(),\n *     cartId: z.string(),\n *     totalItems: z.number(),\n *   }),\n * });\n *\n * // Use directly in chat (server-side, no execute function)\n * chat({\n *   tools: [addToCartTool],\n *   // ...\n * });\n *\n * // Or create server-side implementation\n * const addToCartServer = addToCartTool.server(async (args) => {\n *   // args is typed as { guitarId: string; quantity: number }\n *   return {\n *     success: true,\n *     cartId: 'CART_' + Date.now(),\n *     totalItems: args.quantity,\n *   };\n * });\n *\n * // Or create client-side implementation\n * const addToCartClient = addToCartTool.client(async (args) => {\n *   // Client-specific logic (e.g., localStorage)\n *   return { success: true, cartId: 'local', totalItems: 1 };\n * });\n * ```\n */\nexport function toolDefinition<\n  TInput extends z.ZodType = z.ZodAny,\n  TOutput extends z.ZodType = z.ZodAny,\n  TName extends string = string,\n>(\n  config: ToolDefinitionConfig<TInput, TOutput, TName>,\n): ToolDefinition<TInput, TOutput, TName> {\n  const definition: ToolDefinition<TInput, TOutput, TName> = {\n    __toolSide: 'definition',\n    ...config,\n    server(\n      execute: (\n        args: z.infer<TInput>,\n      ) => Promise<z.infer<TOutput>> | z.infer<TOutput>,\n    ): ServerTool<TInput, TOutput, TName> {\n      return {\n        __toolSide: 'server',\n        ...config,\n        execute,\n      }\n    },\n\n    client(\n      execute?: (\n        args: z.infer<TInput>,\n      ) => Promise<z.infer<TOutput>> | z.infer<TOutput>,\n    ): ClientTool<TInput, TOutput, TName> {\n      return {\n        __toolSide: 'client',\n        ...config,\n        execute,\n      }\n    },\n  }\n\n  return definition\n}\n"],"names":[],"mappings":"AAyKO,SAAS,eAKd,QACwC;AACxC,QAAM,aAAqD;AAAA,IACzD,YAAY;AAAA,IACZ,GAAG;AAAA,IACH,OACE,SAGoC;AACpC,aAAO;AAAA,QACL,YAAY;AAAA,QACZ,GAAG;AAAA,QACH;AAAA,MAAA;AAAA,IAEJ;AAAA,IAEA,OACE,SAGoC;AACpC,aAAO;AAAA,QACL,YAAY;AAAA,QACZ,GAAG;AAAA,QACH;AAAA,MAAA;AAAA,IAEJ;AAAA,EAAA;AAGF,SAAO;AACT;"}

package/dist/esm/tools/zod-converter.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+/**
+ * Converts a Zod schema to JSON Schema format compatible with LLM providers.
+ *
+ *
+ * @param schema - Zod schema to convert
+ * @returns JSON Schema object that can be sent to LLM providers
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const schema = z.object({
+ *   location: z.string().describe('City name'),
+ *   unit: z.enum(['celsius', 'fahrenheit']).optional()
+ * });
+ *
+ * const jsonSchema = convertZodToJsonSchema(schema);
+ * // Returns:
+ * // {
+ * //   type: 'object',
+ * //   properties: {
+ * //     location: { type: 'string', description: 'City name' },
+ * //     unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+ * //   },
+ * //   required: ['location']
+ * // }
+ * ```
+ */
+export declare function convertZodToJsonSchema(schema: z.ZodType | undefined): Record<string, any> | undefined;

package/dist/esm/tools/zod-converter.js

@@ -0,0 +1,36 @@
+import { toJSONSchema } from "zod";
+function convertZodToJsonSchema(schema) {
+  if (!schema) return void 0;
+  const jsonSchema = toJSONSchema(schema, {
+    target: "openapi-3.0",
+    reused: "ref"
+  });
+  let result = jsonSchema;
+  if (typeof result === "object" && "$schema" in result) {
+    const { $schema, ...rest } = result;
+    result = rest;
+  }
+  if (typeof result === "object") {
+    const isZodObject = typeof schema === "object" && "def" in schema && schema.def.type === "object";
+    if (isZodObject && !result.type) {
+      result.type = "object";
+    }
+    if (Object.keys(result).length === 0) {
+      result.type = "object";
+    }
+    if ("properties" in result && !result.type) {
+      result.type = "object";
+    }
+    if (result.type === "object" && !("properties" in result)) {
+      result.properties = {};
+    }
+    if (result.type === "object" && !("required" in result)) {
+      result.required = [];
+    }
+  }
+  return result;
+}
+export {
+  convertZodToJsonSchema
+};
+//# sourceMappingURL=zod-converter.js.map

package/dist/esm/tools/zod-converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-converter.js","sources":["../../../src/tools/zod-converter.ts"],"sourcesContent":["import { toJSONSchema } from 'zod'\nimport type { z } from 'zod'\n/**\n * Converts a Zod schema to JSON Schema format compatible with LLM providers.\n *\n *\n * @param schema - Zod schema to convert\n * @returns JSON Schema object that can be sent to LLM providers\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const schema = z.object({\n *   location: z.string().describe('City name'),\n *   unit: z.enum(['celsius', 'fahrenheit']).optional()\n * });\n *\n * const jsonSchema = convertZodToJsonSchema(schema);\n * // Returns:\n * // {\n * //   type: 'object',\n * //   properties: {\n * //     location: { type: 'string', description: 'City name' },\n * //     unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }\n * //   },\n * //   required: ['location']\n * // }\n * ```\n */\nexport function convertZodToJsonSchema(\n  schema: z.ZodType | undefined,\n): Record<string, any> | undefined {\n  if (!schema) return undefined\n\n  // Use Alcyone Labs fork which is compatible with Zod v4\n  const jsonSchema = toJSONSchema(schema, {\n    target: 'openapi-3.0',\n    reused: 'ref',\n  })\n\n  // Remove $schema property as it's not needed for LLM providers\n  let result = jsonSchema\n  if (typeof result === 'object' && '$schema' in result) {\n    const { $schema, ...rest } = result\n    result = rest\n  }\n\n  // Ensure object schemas always have type: \"object\"\n  // This fixes cases where zod-to-json-schema doesn't set type for empty objects\n  if (typeof result === 'object') {\n    // Check if the input schema is a ZodObject by inspecting its internal structure\n    const isZodObject =\n      typeof schema === 'object' &&\n      'def' in schema &&\n      schema.def.type === 'object'\n\n    // If we know it's a ZodObject but result doesn't have type, set it\n    if (isZodObject && !result.type) {\n      result.type = 'object'\n    }\n\n    // If result is completely empty (no keys), it's likely an empty object schema\n    if (Object.keys(result).length === 0) {\n      result.type = 'object'\n    }\n\n    // If it has properties (even empty), it should be an object type\n    if ('properties' in result && !result.type) {\n      result.type = 'object'\n    }\n\n    // Ensure properties exists for object types (even if empty)\n    if (result.type === 'object' && !('properties' in result)) {\n      result.properties = {}\n    }\n\n    // Ensure required exists for object types (even if empty array)\n    if (result.type === 'object' && !('required' in result)) {\n      result.required = []\n    }\n  }\n\n  return result\n}\n"],"names":[],"mappings":";AA8BO,SAAS,uBACd,QACiC;AACjC,MAAI,CAAC,OAAQ,QAAO;AAGpB,QAAM,aAAa,aAAa,QAAQ;AAAA,IACtC,QAAQ;AAAA,IACR,QAAQ;AAAA,EAAA,CACT;AAGD,MAAI,SAAS;AACb,MAAI,OAAO,WAAW,YAAY,aAAa,QAAQ;AACrD,UAAM,EAAE,SAAS,GAAG,KAAA,IAAS;AAC7B,aAAS;AAAA,EACX;AAIA,MAAI,OAAO,WAAW,UAAU;AAE9B,UAAM,cACJ,OAAO,WAAW,YAClB,SAAS,UACT,OAAO,IAAI,SAAS;AAGtB,QAAI,eAAe,CAAC,OAAO,MAAM;AAC/B,aAAO,OAAO;AAAA,IAChB;AAGA,QAAI,OAAO,KAAK,MAAM,EAAE,WAAW,GAAG;AACpC,aAAO,OAAO;AAAA,IAChB;AAGA,QAAI,gBAAgB,UAAU,CAAC,OAAO,MAAM;AAC1C,aAAO,OAAO;AAAA,IAChB;AAGA,QAAI,OAAO,SAAS,YAAY,EAAE,gBAAgB,SAAS;AACzD,aAAO,aAAa,CAAA;AAAA,IACtB;AAGA,QAAI,OAAO,SAAS,YAAY,EAAE,cAAc,SAAS;AACvD,aAAO,WAAW,CAAA;AAAA,IACpB;AAAA,EACF;AAEA,SAAO;AACT;"}