@omnixhq/ucp-client 0.1.3 → 0.3.0

package/README.md

@@ -84,7 +84,12 @@ Each tool returned by `getAgentTools()` has: `name`, `description`, `parameters`
 ## Error handling
 
 ```typescript
-import { UCPError, UCPEscalationError } from '@omnixhq/ucp-client';
+import {
+  UCPError,
+  UCPEscalationError,
+  UCPIdempotencyConflictError,
+  UCPOAuthError,
+} from '@omnixhq/ucp-client';
 
 try {
   await client.checkout.complete(sessionId, payload);
@@ -92,6 +97,12 @@ try {
   if (err instanceof UCPEscalationError) {
     // Redirect buyer to err.continue_url for merchant-hosted checkout
   }
+  if (err instanceof UCPIdempotencyConflictError) {
+    // HTTP 409 — idempotency key reused with a different request body
+  }
+  if (err instanceof UCPOAuthError) {
+    // OAuth token exchange / refresh / revocation failed — err.statusCode
+  }
   if (err instanceof UCPError) {
     // err.code — e.g., 'PRODUCT_NOT_FOUND'
     // err.messages[] — all messages from the server
@@ -101,6 +112,27 @@ try {
 }
 ```
 
+### catchErrors option
+
+Pass `{ catchErrors: true }` to any adapter to return errors as structured objects instead of
+throwing. The agent observes the failure and can decide what to do next — no try/catch needed in
+every tool call.
+
+```typescript
+import { executeAnthropicToolCall } from '@omnixhq/ucp-client/anthropic';
+import type { ToolErrorResult } from '@omnixhq/ucp-client';
+
+const result = await executeAnthropicToolCall(agentTools, toolName, input, { catchErrors: true });
+
+if (result && typeof result === 'object' && 'error' in result) {
+  const err = result as ToolErrorResult;
+  // { error: 'OUT_OF_STOCK: Item unavailable' }
+  // { requires_escalation: true, continue_url: 'https://...' }
+}
+```
+
+All five adapters (`openai`, `anthropic`, `mcp`, `vercel-ai`, `langchain`) support `catchErrors`.
+
 ## Capabilities
 
 The tools you get depend on what the server declares:
@@ -138,40 +170,97 @@ console.log(Object.keys(client.paymentHandlers));
 // e.g., ['com.google.pay', 'dev.shopify.shop_pay']
 ```
 
-## Other agent frameworks
+## Framework adapters
 
-The `AgentTool` format maps directly to every major framework:
+Ready-made adapters convert `getAgentTools()` output to each framework's native format — no manual mapping.
+
+| Framework         | Import                           | Example                                                                |
+| ----------------- | -------------------------------- | ---------------------------------------------------------------------- |
+| **Anthropic SDK** | `@omnixhq/ucp-client` (built-in) | [examples/anthropic-agent-loop.ts](./examples/anthropic-agent-loop.ts) |
+| **OpenAI SDK**    | `@omnixhq/ucp-client/openai`     | [examples/openai-agent-loop.ts](./examples/openai-agent-loop.ts)       |
+| **Vercel AI SDK** | `@omnixhq/ucp-client/vercel-ai`  | [examples/vercel-ai-nextjs.ts](./examples/vercel-ai-nextjs.ts)         |
+| **LangChain**     | `@omnixhq/ucp-client/langchain`  | [examples/langchain-agent.ts](./examples/langchain-agent.ts)           |
+| **MCP server**    | `@omnixhq/ucp-client/mcp`        | [examples/mcp-server.ts](./examples/mcp-server.ts)                     |
 
 **OpenAI:**
 
 ```typescript
-tools.map((t) => ({
-  type: 'function',
-  function: { name: t.name, description: t.description, parameters: t.parameters },
-}));
+import { toOpenAITools, executeOpenAIToolCall } from '@omnixhq/ucp-client/openai';
+
+const tools = toOpenAITools(client.getAgentTools());
+
+// In your agent loop:
+const response = await openai.chat.completions.create({ model: 'gpt-4o', tools, messages });
+
+for (const call of response.choices[0].message.tool_calls ?? []) {
+  const result = await executeOpenAIToolCall(
+    agentTools,
+    call.function.name,
+    JSON.parse(call.function.arguments),
+  );
+}
 ```
 
 **Vercel AI SDK:**
 
 ```typescript
-import { tool, jsonSchema } from 'ai';
+import { toVercelAITools } from '@omnixhq/ucp-client/vercel-ai';
+import { jsonSchema, streamText } from 'ai';
 
-Object.fromEntries(
-  tools.map((t) => [
-    t.name,
-    tool({ description: t.description, parameters: jsonSchema(t.parameters), execute: t.execute }),
+const rawTools = toVercelAITools(client.getAgentTools());
+
+// Wrap parameters with jsonSchema() for strict Vercel AI SDK typing:
+const tools = Object.fromEntries(
+  Object.entries(rawTools).map(([name, t]) => [
+    name,
+    { ...t, parameters: jsonSchema(t.parameters) },
   ]),
 );
+
+const result = await streamText({ model, tools, messages });
+```
+
+**LangChain:**
+
+```typescript
+import { toLangChainTools } from '@omnixhq/ucp-client/langchain';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+const rawTools = toLangChainTools(client.getAgentTools());
+
+const tools = rawTools.map(
+  (t) =>
+    new DynamicStructuredTool({
+      name: t.name,
+      description: t.description,
+      schema: z.object({}),
+      func: t.call,
+    }),
+);
 ```
 
 **MCP server:**
 
 ```typescript
-for (const t of tools) {
-  server.tool(t.name, t.description, t.parameters, async (params) => ({
-    content: [{ type: 'text', text: JSON.stringify(await t.execute(params)) }],
-  }));
-}
+import { toMCPTools, executeMCPToolCall } from '@omnixhq/ucp-client/mcp';
+
+const agentTools = client.getAgentTools();
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: toMCPTools(agentTools),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => ({
+  content: [
+    {
+      type: 'text',
+      text: JSON.stringify(
+        await executeMCPToolCall(agentTools, req.params.name, req.params.arguments ?? {}),
+      ),
+    },
+  ],
+}));
 ```
 
 ## Development
@@ -179,7 +268,8 @@ for (const t of tools) {
 ```bash
 npm install
 npm run build        # tsdown (dual ESM + CJS)
-npm test             # vitest (116 unit tests)
+npm test             # vitest (unit tests)
+npm run test:types   # type-level tests (vitest --typecheck.only)
 npm run typecheck    # tsc --noEmit
 npm run lint         # eslint
 npm run check:exports # attw

package/dist/adapters/anthropic.cjs

@@ -0,0 +1,27 @@
+"use strict";
+require('../errors-C1XqxNmZ.cjs');
+const require_catch_errors = require('../catch-errors-BZP237w4.cjs');
+
+//#region src/adapters/anthropic.ts
+function toAnthropicTools(agentTools, _options) {
+	return agentTools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		input_schema: {
+			...tool.parameters,
+			type: "object"
+		}
+	}));
+}
+async function executeAnthropicToolCall(agentTools, toolName, toolInput, options) {
+	return require_catch_errors.safeExecute(() => {
+		const tool = agentTools.find((t) => t.name === toolName);
+		if (!tool) throw new Error(`Tool not found: ${toolName}`);
+		return tool.execute(toolInput);
+	}, options?.catchErrors ?? false);
+}
+
+//#endregion
+exports.executeAnthropicToolCall = executeAnthropicToolCall
+exports.toAnthropicTools = toAnthropicTools
+//# sourceMappingURL=anthropic.cjs.map

package/dist/adapters/anthropic.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.cjs","names":["agentTools: readonly AgentTool[]","_options?: AdapterOptions","toolName: string","toolInput: Record<string, unknown>","options?: AdapterOptions"],"sources":["../../src/adapters/anthropic.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface AnthropicInputSchema {\n  readonly type: 'object';\n  readonly properties?: Readonly<Record<string, JsonSchema>>;\n  readonly required?: readonly string[];\n  readonly description?: string;\n}\n\nexport interface AnthropicTool {\n  readonly name: string;\n  readonly description: string;\n  readonly input_schema: AnthropicInputSchema & JsonSchema;\n}\n\nexport function toAnthropicTools(\n  agentTools: readonly AgentTool[],\n  // accepted for API symmetry with executeAnthropicToolCall; catchErrors only applies at call time\n  _options?: AdapterOptions,\n): readonly AnthropicTool[] {\n  return agentTools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    input_schema: { ...tool.parameters, type: 'object' as const },\n  }));\n}\n\nexport async function executeAnthropicToolCall(\n  agentTools: readonly AgentTool[],\n  toolName: string,\n  toolInput: Record<string, unknown>,\n  options?: AdapterOptions,\n): Promise<unknown> {\n  return safeExecute(() => {\n    const tool = agentTools.find((t) => t.name === toolName);\n    if (!tool) throw new Error(`Tool not found: ${toolName}`);\n    return tool.execute(toolInput);\n  }, options?.catchErrors ?? false);\n}\n"],"mappings":";;;;;AAkBA,SAAgB,iBACdA,YAEAC,UAC0B;AAC1B,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,cAAc;GAAE,GAAG,KAAK;GAAY,MAAM;EAAmB;CAC9D,GAAE;AACJ;AAED,eAAsB,yBACpBD,YACAE,UACAC,WACAC,SACkB;AAClB,QAAO,iCAAY,MAAM;EACvB,MAAM,OAAO,WAAW,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AACxD,OAAK,KAAM,OAAM,IAAI,OAAO,kBAAkB,SAAS;AACvD,SAAO,KAAK,QAAQ,UAAU;CAC/B,GAAE,SAAS,eAAe,MAAM;AAClC"}

package/dist/adapters/anthropic.d.cts

@@ -0,0 +1,22 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-CbIHeFvF.cjs";
+
+//#region src/adapters/anthropic.d.ts
+interface AnthropicInputSchema {
+  readonly type: 'object';
+  readonly properties?: Readonly<Record<string, JsonSchema>>;
+  readonly required?: readonly string[];
+  readonly description?: string;
+}
+interface AnthropicTool {
+  readonly name: string;
+  readonly description: string;
+  readonly input_schema: AnthropicInputSchema & JsonSchema;
+}
+declare function toAnthropicTools(agentTools: readonly AgentTool[], _options?: AdapterOptions): readonly AnthropicTool[];
+declare function executeAnthropicToolCall(agentTools: readonly AgentTool[], toolName: string, toolInput: Record<string, unknown>, options?: AdapterOptions): Promise<unknown>;
+
+//#endregion
+//# sourceMappingURL=anthropic.d.ts.map
+
+export { AgentTool, AnthropicInputSchema, AnthropicTool, JsonSchema, executeAnthropicToolCall, toAnthropicTools };
+//# sourceMappingURL=anthropic.d.cts.map

package/dist/adapters/anthropic.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.cts","names":[],"sources":["../../src/adapters/anthropic.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,oBAAA,CAAoB;EAAA,SAAA,IAAA,EAAA,QAAA;EAAA,SAEW,UAAA,CAAA,EAAxB,QAAwB,CAAf,MAAe,CAAA,MAAA,EAAA,UAAA,CAAA,CAAA;EAAU,SAAzB,QAAA,CAAA,EAAA,SAAA,MAAA,EAAA;EAAM,SAAf,WAAA,CAAA,EAAA,MAAA;AAAQ;AAKf,UAAA,aAAA,CAAa;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAGL,WAAA,EAAA,MAAA;EAAoB,SAAG,YAAA,EAAvB,oBAAuB,GAAA,UAAA;AAAU;AAG1C,iBAAA,gBAAA,CAAgB,UAAA,EAAA,SACT,SADS,EAAA,EAAA,QAAA,CAAA,EAGnB,cAHmB,CAAA,EAAA,SAIpB,aAJoB,EAAA;AAAA,iBAYV,wBAAA,CAZU,UAAA,EAAA,SAaT,SAbS,EAAA,EAAA,QAAA,EAAA,MAAA,EAAA,SAAA,EAenB,MAfmB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAgBpB,cAhBoB,CAAA,EAiB7B,OAjB6B,CAAA,OAAA,CAAA"}

package/dist/adapters/anthropic.d.ts

@@ -0,0 +1,22 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-H8gObrht.js";
+
+//#region src/adapters/anthropic.d.ts
+interface AnthropicInputSchema {
+  readonly type: 'object';
+  readonly properties?: Readonly<Record<string, JsonSchema>>;
+  readonly required?: readonly string[];
+  readonly description?: string;
+}
+interface AnthropicTool {
+  readonly name: string;
+  readonly description: string;
+  readonly input_schema: AnthropicInputSchema & JsonSchema;
+}
+declare function toAnthropicTools(agentTools: readonly AgentTool[], _options?: AdapterOptions): readonly AnthropicTool[];
+declare function executeAnthropicToolCall(agentTools: readonly AgentTool[], toolName: string, toolInput: Record<string, unknown>, options?: AdapterOptions): Promise<unknown>;
+
+//#endregion
+//# sourceMappingURL=anthropic.d.ts.map
+
+export { AgentTool, AnthropicInputSchema, AnthropicTool, JsonSchema, executeAnthropicToolCall, toAnthropicTools };
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/adapters/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","names":[],"sources":["../../src/adapters/anthropic.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,oBAAA,CAAoB;EAAA,SAAA,IAAA,EAAA,QAAA;EAAA,SAEW,UAAA,CAAA,EAAxB,QAAwB,CAAf,MAAe,CAAA,MAAA,EAAA,UAAA,CAAA,CAAA;EAAU,SAAzB,QAAA,CAAA,EAAA,SAAA,MAAA,EAAA;EAAM,SAAf,WAAA,CAAA,EAAA,MAAA;AAAQ;AAKf,UAAA,aAAA,CAAa;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAGL,WAAA,EAAA,MAAA;EAAoB,SAAG,YAAA,EAAvB,oBAAuB,GAAA,UAAA;AAAU;AAG1C,iBAAA,gBAAA,CAAgB,UAAA,EAAA,SACT,SADS,EAAA,EAAA,QAAA,CAAA,EAGnB,cAHmB,CAAA,EAAA,SAIpB,aAJoB,EAAA;AAAA,iBAYV,wBAAA,CAZU,UAAA,EAAA,SAaT,SAbS,EAAA,EAAA,QAAA,EAAA,MAAA,EAAA,SAAA,EAenB,MAfmB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAgBpB,cAhBoB,CAAA,EAiB7B,OAjB6B,CAAA,OAAA,CAAA"}

package/dist/adapters/anthropic.js

@@ -0,0 +1,25 @@
+import "../errors-DX7yw6Gl.js";
+import { safeExecute } from "../catch-errors-Cpn2vHir.js";
+
+//#region src/adapters/anthropic.ts
+function toAnthropicTools(agentTools, _options) {
+	return agentTools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		input_schema: {
+			...tool.parameters,
+			type: "object"
+		}
+	}));
+}
+async function executeAnthropicToolCall(agentTools, toolName, toolInput, options) {
+	return safeExecute(() => {
+		const tool = agentTools.find((t) => t.name === toolName);
+		if (!tool) throw new Error(`Tool not found: ${toolName}`);
+		return tool.execute(toolInput);
+	}, options?.catchErrors ?? false);
+}
+
+//#endregion
+export { executeAnthropicToolCall, toAnthropicTools };
+//# sourceMappingURL=anthropic.js.map

package/dist/adapters/anthropic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.js","names":["agentTools: readonly AgentTool[]","_options?: AdapterOptions","toolName: string","toolInput: Record<string, unknown>","options?: AdapterOptions"],"sources":["../../src/adapters/anthropic.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface AnthropicInputSchema {\n  readonly type: 'object';\n  readonly properties?: Readonly<Record<string, JsonSchema>>;\n  readonly required?: readonly string[];\n  readonly description?: string;\n}\n\nexport interface AnthropicTool {\n  readonly name: string;\n  readonly description: string;\n  readonly input_schema: AnthropicInputSchema & JsonSchema;\n}\n\nexport function toAnthropicTools(\n  agentTools: readonly AgentTool[],\n  // accepted for API symmetry with executeAnthropicToolCall; catchErrors only applies at call time\n  _options?: AdapterOptions,\n): readonly AnthropicTool[] {\n  return agentTools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    input_schema: { ...tool.parameters, type: 'object' as const },\n  }));\n}\n\nexport async function executeAnthropicToolCall(\n  agentTools: readonly AgentTool[],\n  toolName: string,\n  toolInput: Record<string, unknown>,\n  options?: AdapterOptions,\n): Promise<unknown> {\n  return safeExecute(() => {\n    const tool = agentTools.find((t) => t.name === toolName);\n    if (!tool) throw new Error(`Tool not found: ${toolName}`);\n    return tool.execute(toolInput);\n  }, options?.catchErrors ?? false);\n}\n"],"mappings":";;;;AAkBA,SAAgB,iBACdA,YAEAC,UAC0B;AAC1B,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,cAAc;GAAE,GAAG,KAAK;GAAY,MAAM;EAAmB;CAC9D,GAAE;AACJ;AAED,eAAsB,yBACpBD,YACAE,UACAC,WACAC,SACkB;AAClB,QAAO,YAAY,MAAM;EACvB,MAAM,OAAO,WAAW,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AACxD,OAAK,KAAM,OAAM,IAAI,OAAO,kBAAkB,SAAS;AACvD,SAAO,KAAK,QAAQ,UAAU;CAC/B,GAAE,SAAS,eAAe,MAAM;AAClC"}

package/dist/adapters/langchain.cjs

@@ -0,0 +1,20 @@
+"use strict";
+require('../errors-C1XqxNmZ.cjs');
+const require_catch_errors = require('../catch-errors-BZP237w4.cjs');
+
+//#region src/adapters/langchain.ts
+function toLangChainTools(agentTools, options) {
+	return agentTools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		schema: tool.parameters,
+		call: async (input) => {
+			const result = await require_catch_errors.safeExecute(() => tool.execute(input), options?.catchErrors ?? false);
+			return JSON.stringify(result);
+		}
+	}));
+}
+
+//#endregion
+exports.toLangChainTools = toLangChainTools
+//# sourceMappingURL=langchain.cjs.map

package/dist/adapters/langchain.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.cjs","names":["agentTools: readonly AgentTool[]","options?: AdapterOptions","input: Record<string, unknown>"],"sources":["../../src/adapters/langchain.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface LangChainTool {\n  readonly name: string;\n  readonly description: string;\n  readonly schema: JsonSchema;\n  readonly call: (input: Record<string, unknown>) => Promise<string>;\n}\n\nexport function toLangChainTools(\n  agentTools: readonly AgentTool[],\n  options?: AdapterOptions,\n): readonly LangChainTool[] {\n  return agentTools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    schema: tool.parameters,\n    call: async (input: Record<string, unknown>): Promise<string> => {\n      const result = await safeExecute(() => tool.execute(input), options?.catchErrors ?? false);\n      return JSON.stringify(result);\n    },\n  }));\n}\n"],"mappings":";;;;;AAYA,SAAgB,iBACdA,YACAC,SAC0B;AAC1B,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,QAAQ,KAAK;EACb,MAAM,OAAOC,UAAoD;GAC/D,MAAM,SAAS,MAAM,iCAAY,MAAM,KAAK,QAAQ,MAAM,EAAE,SAAS,eAAe,MAAM;AAC1F,UAAO,KAAK,UAAU,OAAO;EAC9B;CACF,GAAE;AACJ"}

package/dist/adapters/langchain.d.cts

@@ -0,0 +1,16 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-CbIHeFvF.cjs";
+
+//#region src/adapters/langchain.d.ts
+interface LangChainTool {
+  readonly name: string;
+  readonly description: string;
+  readonly schema: JsonSchema;
+  readonly call: (input: Record<string, unknown>) => Promise<string>;
+}
+declare function toLangChainTools(agentTools: readonly AgentTool[], options?: AdapterOptions): readonly LangChainTool[];
+
+//#endregion
+//# sourceMappingURL=langchain.d.ts.map
+
+export { AgentTool, JsonSchema, LangChainTool, toLangChainTools };
+//# sourceMappingURL=langchain.d.cts.map

package/dist/adapters/langchain.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.cts","names":[],"sources":["../../src/adapters/langchain.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,aAAA,CAAa;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAGX,WAAA,EAAA,MAAA;EAAU,SACJ,MAAA,EADN,UACM;EAAM,SAAsB,IAAA,EAAA,CAAA,KAAA,EAA5B,MAA4B,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,OAAA,CAAA,MAAA,CAAA;AAAO;AAG5C,iBAAA,gBAAA,CAAgB,UAAA,EAAA,SACT,SADS,EAAA,EAAA,OAAA,CAAA,EAEpB,cAFoB,CAAA,EAAA,SAGpB,aAHoB,EAAA"}

package/dist/adapters/langchain.d.ts

@@ -0,0 +1,16 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-H8gObrht.js";
+
+//#region src/adapters/langchain.d.ts
+interface LangChainTool {
+  readonly name: string;
+  readonly description: string;
+  readonly schema: JsonSchema;
+  readonly call: (input: Record<string, unknown>) => Promise<string>;
+}
+declare function toLangChainTools(agentTools: readonly AgentTool[], options?: AdapterOptions): readonly LangChainTool[];
+
+//#endregion
+//# sourceMappingURL=langchain.d.ts.map
+
+export { AgentTool, JsonSchema, LangChainTool, toLangChainTools };
+//# sourceMappingURL=langchain.d.ts.map

package/dist/adapters/langchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.ts","names":[],"sources":["../../src/adapters/langchain.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,aAAA,CAAa;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAGX,WAAA,EAAA,MAAA;EAAU,SACJ,MAAA,EADN,UACM;EAAM,SAAsB,IAAA,EAAA,CAAA,KAAA,EAA5B,MAA4B,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,OAAA,CAAA,MAAA,CAAA;AAAO;AAG5C,iBAAA,gBAAA,CAAgB,UAAA,EAAA,SACT,SADS,EAAA,EAAA,OAAA,CAAA,EAEpB,cAFoB,CAAA,EAAA,SAGpB,aAHoB,EAAA"}

package/dist/adapters/langchain.js

@@ -0,0 +1,19 @@
+import "../errors-DX7yw6Gl.js";
+import { safeExecute } from "../catch-errors-Cpn2vHir.js";
+
+//#region src/adapters/langchain.ts
+function toLangChainTools(agentTools, options) {
+	return agentTools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		schema: tool.parameters,
+		call: async (input) => {
+			const result = await safeExecute(() => tool.execute(input), options?.catchErrors ?? false);
+			return JSON.stringify(result);
+		}
+	}));
+}
+
+//#endregion
+export { toLangChainTools };
+//# sourceMappingURL=langchain.js.map

package/dist/adapters/langchain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.js","names":["agentTools: readonly AgentTool[]","options?: AdapterOptions","input: Record<string, unknown>"],"sources":["../../src/adapters/langchain.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface LangChainTool {\n  readonly name: string;\n  readonly description: string;\n  readonly schema: JsonSchema;\n  readonly call: (input: Record<string, unknown>) => Promise<string>;\n}\n\nexport function toLangChainTools(\n  agentTools: readonly AgentTool[],\n  options?: AdapterOptions,\n): readonly LangChainTool[] {\n  return agentTools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    schema: tool.parameters,\n    call: async (input: Record<string, unknown>): Promise<string> => {\n      const result = await safeExecute(() => tool.execute(input), options?.catchErrors ?? false);\n      return JSON.stringify(result);\n    },\n  }));\n}\n"],"mappings":";;;;AAYA,SAAgB,iBACdA,YACAC,SAC0B;AAC1B,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,QAAQ,KAAK;EACb,MAAM,OAAOC,UAAoD;GAC/D,MAAM,SAAS,MAAM,YAAY,MAAM,KAAK,QAAQ,MAAM,EAAE,SAAS,eAAe,MAAM;AAC1F,UAAO,KAAK,UAAU,OAAO;EAC9B;CACF,GAAE;AACJ"}

package/dist/adapters/mcp.cjs

@@ -0,0 +1,27 @@
+"use strict";
+require('../errors-C1XqxNmZ.cjs');
+const require_catch_errors = require('../catch-errors-BZP237w4.cjs');
+
+//#region src/adapters/mcp.ts
+function toMCPTools(agentTools, _options) {
+	return agentTools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: {
+			...tool.parameters,
+			type: "object"
+		}
+	}));
+}
+async function executeMCPToolCall(agentTools, toolName, toolInput, options) {
+	return require_catch_errors.safeExecute(() => {
+		const tool = agentTools.find((t) => t.name === toolName);
+		if (!tool) throw new Error(`Tool not found: ${toolName}`);
+		return tool.execute(toolInput);
+	}, options?.catchErrors ?? false);
+}
+
+//#endregion
+exports.executeMCPToolCall = executeMCPToolCall
+exports.toMCPTools = toMCPTools
+//# sourceMappingURL=mcp.cjs.map

package/dist/adapters/mcp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.cjs","names":["agentTools: readonly AgentTool[]","_options?: AdapterOptions","toolName: string","toolInput: Record<string, unknown>","options?: AdapterOptions"],"sources":["../../src/adapters/mcp.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface MCPInputSchema {\n  readonly type: 'object';\n  readonly properties?: Readonly<Record<string, JsonSchema>>;\n  readonly required?: readonly string[];\n  readonly description?: string;\n}\n\nexport interface MCPTool {\n  readonly name: string;\n  readonly description: string;\n  readonly inputSchema: MCPInputSchema & JsonSchema;\n}\n\nexport function toMCPTools(\n  agentTools: readonly AgentTool[],\n  // accepted for API symmetry with executeMCPToolCall; catchErrors only applies at call time\n  _options?: AdapterOptions,\n): readonly MCPTool[] {\n  return agentTools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    inputSchema: { ...tool.parameters, type: 'object' as const },\n  }));\n}\n\nexport async function executeMCPToolCall(\n  agentTools: readonly AgentTool[],\n  toolName: string,\n  toolInput: Record<string, unknown>,\n  options?: AdapterOptions,\n): Promise<unknown> {\n  return safeExecute(() => {\n    const tool = agentTools.find((t) => t.name === toolName);\n    if (!tool) throw new Error(`Tool not found: ${toolName}`);\n    return tool.execute(toolInput);\n  }, options?.catchErrors ?? false);\n}\n"],"mappings":";;;;;AAkBA,SAAgB,WACdA,YAEAC,UACoB;AACpB,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,aAAa;GAAE,GAAG,KAAK;GAAY,MAAM;EAAmB;CAC7D,GAAE;AACJ;AAED,eAAsB,mBACpBD,YACAE,UACAC,WACAC,SACkB;AAClB,QAAO,iCAAY,MAAM;EACvB,MAAM,OAAO,WAAW,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AACxD,OAAK,KAAM,OAAM,IAAI,OAAO,kBAAkB,SAAS;AACvD,SAAO,KAAK,QAAQ,UAAU;CAC/B,GAAE,SAAS,eAAe,MAAM;AAClC"}

package/dist/adapters/mcp.d.cts

@@ -0,0 +1,22 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-CbIHeFvF.cjs";
+
+//#region src/adapters/mcp.d.ts
+interface MCPInputSchema {
+  readonly type: 'object';
+  readonly properties?: Readonly<Record<string, JsonSchema>>;
+  readonly required?: readonly string[];
+  readonly description?: string;
+}
+interface MCPTool {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: MCPInputSchema & JsonSchema;
+}
+declare function toMCPTools(agentTools: readonly AgentTool[], _options?: AdapterOptions): readonly MCPTool[];
+declare function executeMCPToolCall(agentTools: readonly AgentTool[], toolName: string, toolInput: Record<string, unknown>, options?: AdapterOptions): Promise<unknown>;
+
+//#endregion
+//# sourceMappingURL=mcp.d.ts.map
+
+export { AgentTool, JsonSchema, MCPInputSchema, MCPTool, executeMCPToolCall, toMCPTools };
+//# sourceMappingURL=mcp.d.cts.map

package/dist/adapters/mcp.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.cts","names":[],"sources":["../../src/adapters/mcp.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,cAAA,CAAc;EAAA,SAAA,IAAA,EAAA,QAAA;EAAA,SAEiB,UAAA,CAAA,EAAxB,QAAwB,CAAf,MAAe,CAAA,MAAA,EAAA,UAAA,CAAA,CAAA;EAAU,SAAzB,QAAA,CAAA,EAAA,SAAA,MAAA,EAAA;EAAM,SAAf,WAAA,CAAA,EAAA,MAAA;AAAQ;AAKf,UAAA,OAAA,CAAO;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAGA,WAAA,EAAA,MAAA;EAAc,SAAG,WAAA,EAAjB,cAAiB,GAAA,UAAA;AAAU;AAGnC,iBAAA,UAAA,CAAU,UAAA,EAAA,SACH,SADG,EAAA,EAAA,QAAA,CAAA,EAGb,cAHa,CAAA,EAAA,SAId,OAJc,EAAA;AAAA,iBAYJ,kBAAA,CAZI,UAAA,EAAA,SAaH,SAbG,EAAA,EAAA,QAAA,EAAA,MAAA,EAAA,SAAA,EAeb,MAfa,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAgBd,cAhBc,CAAA,EAiBvB,OAjBuB,CAAA,OAAA,CAAA"}

package/dist/adapters/mcp.d.ts

@@ -0,0 +1,22 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-H8gObrht.js";
+
+//#region src/adapters/mcp.d.ts
+interface MCPInputSchema {
+  readonly type: 'object';
+  readonly properties?: Readonly<Record<string, JsonSchema>>;
+  readonly required?: readonly string[];
+  readonly description?: string;
+}
+interface MCPTool {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: MCPInputSchema & JsonSchema;
+}
+declare function toMCPTools(agentTools: readonly AgentTool[], _options?: AdapterOptions): readonly MCPTool[];
+declare function executeMCPToolCall(agentTools: readonly AgentTool[], toolName: string, toolInput: Record<string, unknown>, options?: AdapterOptions): Promise<unknown>;
+
+//#endregion
+//# sourceMappingURL=mcp.d.ts.map
+
+export { AgentTool, JsonSchema, MCPInputSchema, MCPTool, executeMCPToolCall, toMCPTools };
+//# sourceMappingURL=mcp.d.ts.map

package/dist/adapters/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","names":[],"sources":["../../src/adapters/mcp.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,cAAA,CAAc;EAAA,SAAA,IAAA,EAAA,QAAA;EAAA,SAEiB,UAAA,CAAA,EAAxB,QAAwB,CAAf,MAAe,CAAA,MAAA,EAAA,UAAA,CAAA,CAAA;EAAU,SAAzB,QAAA,CAAA,EAAA,SAAA,MAAA,EAAA;EAAM,SAAf,WAAA,CAAA,EAAA,MAAA;AAAQ;AAKf,UAAA,OAAA,CAAO;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAGA,WAAA,EAAA,MAAA;EAAc,SAAG,WAAA,EAAjB,cAAiB,GAAA,UAAA;AAAU;AAGnC,iBAAA,UAAA,CAAU,UAAA,EAAA,SACH,SADG,EAAA,EAAA,QAAA,CAAA,EAGb,cAHa,CAAA,EAAA,SAId,OAJc,EAAA;AAAA,iBAYJ,kBAAA,CAZI,UAAA,EAAA,SAaH,SAbG,EAAA,EAAA,QAAA,EAAA,MAAA,EAAA,SAAA,EAeb,MAfa,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAgBd,cAhBc,CAAA,EAiBvB,OAjBuB,CAAA,OAAA,CAAA"}

package/dist/adapters/mcp.js

@@ -0,0 +1,25 @@
+import "../errors-DX7yw6Gl.js";
+import { safeExecute } from "../catch-errors-Cpn2vHir.js";
+
+//#region src/adapters/mcp.ts
+function toMCPTools(agentTools, _options) {
+	return agentTools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: {
+			...tool.parameters,
+			type: "object"
+		}
+	}));
+}
+async function executeMCPToolCall(agentTools, toolName, toolInput, options) {
+	return safeExecute(() => {
+		const tool = agentTools.find((t) => t.name === toolName);
+		if (!tool) throw new Error(`Tool not found: ${toolName}`);
+		return tool.execute(toolInput);
+	}, options?.catchErrors ?? false);
+}
+
+//#endregion
+export { executeMCPToolCall, toMCPTools };
+//# sourceMappingURL=mcp.js.map

package/dist/adapters/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","names":["agentTools: readonly AgentTool[]","_options?: AdapterOptions","toolName: string","toolInput: Record<string, unknown>","options?: AdapterOptions"],"sources":["../../src/adapters/mcp.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface MCPInputSchema {\n  readonly type: 'object';\n  readonly properties?: Readonly<Record<string, JsonSchema>>;\n  readonly required?: readonly string[];\n  readonly description?: string;\n}\n\nexport interface MCPTool {\n  readonly name: string;\n  readonly description: string;\n  readonly inputSchema: MCPInputSchema & JsonSchema;\n}\n\nexport function toMCPTools(\n  agentTools: readonly AgentTool[],\n  // accepted for API symmetry with executeMCPToolCall; catchErrors only applies at call time\n  _options?: AdapterOptions,\n): readonly MCPTool[] {\n  return agentTools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    inputSchema: { ...tool.parameters, type: 'object' as const },\n  }));\n}\n\nexport async function executeMCPToolCall(\n  agentTools: readonly AgentTool[],\n  toolName: string,\n  toolInput: Record<string, unknown>,\n  options?: AdapterOptions,\n): Promise<unknown> {\n  return safeExecute(() => {\n    const tool = agentTools.find((t) => t.name === toolName);\n    if (!tool) throw new Error(`Tool not found: ${toolName}`);\n    return tool.execute(toolInput);\n  }, options?.catchErrors ?? false);\n}\n"],"mappings":";;;;AAkBA,SAAgB,WACdA,YAEAC,UACoB;AACpB,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,aAAa;GAAE,GAAG,KAAK;GAAY,MAAM;EAAmB;CAC7D,GAAE;AACJ;AAED,eAAsB,mBACpBD,YACAE,UACAC,WACAC,SACkB;AAClB,QAAO,YAAY,MAAM;EACvB,MAAM,OAAO,WAAW,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AACxD,OAAK,KAAM,OAAM,IAAI,OAAO,kBAAkB,SAAS;AACvD,SAAO,KAAK,QAAQ,UAAU;CAC/B,GAAE,SAAS,eAAe,MAAM;AAClC"}

package/dist/adapters/openai.cjs

@@ -0,0 +1,27 @@
+"use strict";
+require('../errors-C1XqxNmZ.cjs');
+const require_catch_errors = require('../catch-errors-BZP237w4.cjs');
+
+//#region src/adapters/openai.ts
+function toOpenAITools(agentTools, _options) {
+	return agentTools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	}));
+}
+async function executeOpenAIToolCall(agentTools, toolName, toolInput, options) {
+	return require_catch_errors.safeExecute(() => {
+		const tool = agentTools.find((t) => t.name === toolName);
+		if (!tool) throw new Error(`Tool not found: ${toolName}`);
+		return tool.execute(toolInput);
+	}, options?.catchErrors ?? false);
+}
+
+//#endregion
+exports.executeOpenAIToolCall = executeOpenAIToolCall
+exports.toOpenAITools = toOpenAITools
+//# sourceMappingURL=openai.cjs.map

package/dist/adapters/openai.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.cjs","names":["agentTools: readonly AgentTool[]","_options?: AdapterOptions","toolName: string","toolInput: Record<string, unknown>","options?: AdapterOptions"],"sources":["../../src/adapters/openai.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface OpenAIFunction {\n  readonly name: string;\n  readonly description: string;\n  readonly parameters: JsonSchema;\n}\n\nexport interface OpenAITool {\n  readonly type: 'function';\n  readonly function: OpenAIFunction;\n}\n\nexport function toOpenAITools(\n  agentTools: readonly AgentTool[],\n  // accepted for API symmetry with executeOpenAIToolCall; catchErrors only applies at call time\n  _options?: AdapterOptions,\n): readonly OpenAITool[] {\n  return agentTools.map((tool) => ({\n    type: 'function' as const,\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: tool.parameters,\n    },\n  }));\n}\n\nexport async function executeOpenAIToolCall(\n  agentTools: readonly AgentTool[],\n  toolName: string,\n  toolInput: Record<string, unknown>,\n  options?: AdapterOptions,\n): Promise<unknown> {\n  return safeExecute(() => {\n    const tool = agentTools.find((t) => t.name === toolName);\n    if (!tool) throw new Error(`Tool not found: ${toolName}`);\n    return tool.execute(toolInput);\n  }, options?.catchErrors ?? false);\n}\n"],"mappings":";;;;;AAgBA,SAAgB,cACdA,YAEAC,UACuB;AACvB,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM;EACN,UAAU;GACR,MAAM,KAAK;GACX,aAAa,KAAK;GAClB,YAAY,KAAK;EAClB;CACF,GAAE;AACJ;AAED,eAAsB,sBACpBD,YACAE,UACAC,WACAC,SACkB;AAClB,QAAO,iCAAY,MAAM;EACvB,MAAM,OAAO,WAAW,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AACxD,OAAK,KAAM,OAAM,IAAI,OAAO,kBAAkB,SAAS;AACvD,SAAO,KAAK,QAAQ,UAAU;CAC/B,GAAE,SAAS,eAAe,MAAM;AAClC"}

package/dist/adapters/openai.d.cts

@@ -0,0 +1,20 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-CbIHeFvF.cjs";
+
+//#region src/adapters/openai.d.ts
+interface OpenAIFunction {
+  readonly name: string;
+  readonly description: string;
+  readonly parameters: JsonSchema;
+}
+interface OpenAITool {
+  readonly type: 'function';
+  readonly function: OpenAIFunction;
+}
+declare function toOpenAITools(agentTools: readonly AgentTool[], _options?: AdapterOptions): readonly OpenAITool[];
+declare function executeOpenAIToolCall(agentTools: readonly AgentTool[], toolName: string, toolInput: Record<string, unknown>, options?: AdapterOptions): Promise<unknown>;
+
+//#endregion
+//# sourceMappingURL=openai.d.ts.map
+
+export { AgentTool, JsonSchema, OpenAIFunction, OpenAITool, executeOpenAIToolCall, toOpenAITools };
+//# sourceMappingURL=openai.d.cts.map

package/dist/adapters/openai.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.cts","names":[],"sources":["../../src/adapters/openai.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,cAAA,CAGM;EAGN,SAAA,IAAU,EAAA,MAAA;EAKX,SAAA,WAAa,EAAA,MAAA;EAAA,SAAA,UAAA,EARN,UAQM;;AAGhB,UARI,UAAA,CAQJ;EAAc,SACf,IAAA,EAAA,UAAA;EAAU,SAAA,QAAA,EAPD,cAOC;AAWtB;AAA2C,iBAf3B,aAAA,CAe2B,UAAA,EAAA,SAdpB,SAcoB,EAAA,EAAA,QAAA,CAAA,EAZ9B,cAY8B,CAAA,EAAA,SAX/B,UAW+B,EAAA;AACpB,iBADD,qBAAA,CACC,UAAA,EAAA,SAAA,SAAA,EAAA,EAAA,QAAA,EAAA,MAAA,EAAA,SAAA,EAEV,MAFU,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAGX,cAHW,CAAA,EAIpB,OAJoB,CAAA,OAAA,CAAA"}

package/dist/adapters/openai.d.ts

@@ -0,0 +1,20 @@
+import { AdapterOptions, AgentTool, JsonSchema } from "../catch-errors-H8gObrht.js";
+
+//#region src/adapters/openai.d.ts
+interface OpenAIFunction {
+  readonly name: string;
+  readonly description: string;
+  readonly parameters: JsonSchema;
+}
+interface OpenAITool {
+  readonly type: 'function';
+  readonly function: OpenAIFunction;
+}
+declare function toOpenAITools(agentTools: readonly AgentTool[], _options?: AdapterOptions): readonly OpenAITool[];
+declare function executeOpenAIToolCall(agentTools: readonly AgentTool[], toolName: string, toolInput: Record<string, unknown>, options?: AdapterOptions): Promise<unknown>;
+
+//#endregion
+//# sourceMappingURL=openai.d.ts.map
+
+export { AgentTool, JsonSchema, OpenAIFunction, OpenAITool, executeOpenAIToolCall, toOpenAITools };
+//# sourceMappingURL=openai.d.ts.map

package/dist/adapters/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","names":[],"sources":["../../src/adapters/openai.ts"],"sourcesContent":null,"mappings":";;;AAKiB,UAAA,cAAA,CAGM;EAGN,SAAA,IAAU,EAAA,MAAA;EAKX,SAAA,WAAa,EAAA,MAAA;EAAA,SAAA,UAAA,EARN,UAQM;;AAGhB,UARI,UAAA,CAQJ;EAAc,SACf,IAAA,EAAA,UAAA;EAAU,SAAA,QAAA,EAPD,cAOC;AAWtB;AAA2C,iBAf3B,aAAA,CAe2B,UAAA,EAAA,SAdpB,SAcoB,EAAA,EAAA,QAAA,CAAA,EAZ9B,cAY8B,CAAA,EAAA,SAX/B,UAW+B,EAAA;AACpB,iBADD,qBAAA,CACC,UAAA,EAAA,SAAA,SAAA,EAAA,EAAA,QAAA,EAAA,MAAA,EAAA,SAAA,EAEV,MAFU,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAGX,cAHW,CAAA,EAIpB,OAJoB,CAAA,OAAA,CAAA"}

package/dist/adapters/openai.js

@@ -0,0 +1,25 @@
+import "../errors-DX7yw6Gl.js";
+import { safeExecute } from "../catch-errors-Cpn2vHir.js";
+
+//#region src/adapters/openai.ts
+function toOpenAITools(agentTools, _options) {
+	return agentTools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	}));
+}
+async function executeOpenAIToolCall(agentTools, toolName, toolInput, options) {
+	return safeExecute(() => {
+		const tool = agentTools.find((t) => t.name === toolName);
+		if (!tool) throw new Error(`Tool not found: ${toolName}`);
+		return tool.execute(toolInput);
+	}, options?.catchErrors ?? false);
+}
+
+//#endregion
+export { executeOpenAIToolCall, toOpenAITools };
+//# sourceMappingURL=openai.js.map

package/dist/adapters/openai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.js","names":["agentTools: readonly AgentTool[]","_options?: AdapterOptions","toolName: string","toolInput: Record<string, unknown>","options?: AdapterOptions"],"sources":["../../src/adapters/openai.ts"],"sourcesContent":["import type { AgentTool, JsonSchema } from '../agent-tools.js';\nimport { type AdapterOptions, safeExecute } from './catch-errors.js';\n\nexport type { AgentTool, JsonSchema };\n\nexport interface OpenAIFunction {\n  readonly name: string;\n  readonly description: string;\n  readonly parameters: JsonSchema;\n}\n\nexport interface OpenAITool {\n  readonly type: 'function';\n  readonly function: OpenAIFunction;\n}\n\nexport function toOpenAITools(\n  agentTools: readonly AgentTool[],\n  // accepted for API symmetry with executeOpenAIToolCall; catchErrors only applies at call time\n  _options?: AdapterOptions,\n): readonly OpenAITool[] {\n  return agentTools.map((tool) => ({\n    type: 'function' as const,\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: tool.parameters,\n    },\n  }));\n}\n\nexport async function executeOpenAIToolCall(\n  agentTools: readonly AgentTool[],\n  toolName: string,\n  toolInput: Record<string, unknown>,\n  options?: AdapterOptions,\n): Promise<unknown> {\n  return safeExecute(() => {\n    const tool = agentTools.find((t) => t.name === toolName);\n    if (!tool) throw new Error(`Tool not found: ${toolName}`);\n    return tool.execute(toolInput);\n  }, options?.catchErrors ?? false);\n}\n"],"mappings":";;;;AAgBA,SAAgB,cACdA,YAEAC,UACuB;AACvB,QAAO,WAAW,IAAI,CAAC,UAAU;EAC/B,MAAM;EACN,UAAU;GACR,MAAM,KAAK;GACX,aAAa,KAAK;GAClB,YAAY,KAAK;EAClB;CACF,GAAE;AACJ;AAED,eAAsB,sBACpBD,YACAE,UACAC,WACAC,SACkB;AAClB,QAAO,YAAY,MAAM;EACvB,MAAM,OAAO,WAAW,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AACxD,OAAK,KAAM,OAAM,IAAI,OAAO,kBAAkB,SAAS;AACvD,SAAO,KAAK,QAAQ,UAAU;CAC/B,GAAE,SAAS,eAAe,MAAM;AAClC"}