@contractspec/lib.ai-agent 1.57.0 → 1.58.0

package/dist/tools/index.js

@@ -1,6 +1,345 @@
-import { buildToolHandlers, createToolHandler, specToolToAISDKTool, specToolsToAISDKTools } from "./tool-adapter.js";
-import { createKnowledgeQueryTool } from "./knowledge-tool.js";
-import { createMcpToolsets, mcpServerToTools } from "./mcp-client.js";
-import { agentToMcpServer, createAgentMcpServer } from "./mcp-server.js";
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
-export { agentToMcpServer, buildToolHandlers, createAgentMcpServer, createKnowledgeQueryTool, createMcpToolsets, createToolHandler, mcpServerToTools, specToolToAISDKTool, specToolsToAISDKTools };
+// src/schema/json-schema-to-zod.ts
+import { z } from "zod";
+function jsonSchemaToZod(schema) {
+  const s = schema;
+  const makeNullable = (zodSchema) => {
+    return s.nullable ? z.union([zodSchema, z.null()]) : zodSchema;
+  };
+  if (s.const !== undefined) {
+    return z.literal(s.const);
+  }
+  if (s.enum) {
+    const values = s.enum;
+    return makeNullable(z.enum(values.map(String)));
+  }
+  if (s.anyOf && s.anyOf.length > 0) {
+    const schemas = s.anyOf.map((sub) => jsonSchemaToZod(sub));
+    if (schemas.length === 1)
+      return schemas[0] ?? z.unknown();
+    return z.union([
+      schemas[0] ?? z.unknown(),
+      schemas[1] ?? z.unknown(),
+      ...schemas.slice(2)
+    ]);
+  }
+  if (s.oneOf && s.oneOf.length > 0) {
+    const schemas = s.oneOf.map((sub) => jsonSchemaToZod(sub));
+    if (schemas.length === 1)
+      return schemas[0] ?? z.unknown();
+    return z.union([
+      schemas[0] ?? z.unknown(),
+      schemas[1] ?? z.unknown(),
+      ...schemas.slice(2)
+    ]);
+  }
+  if (s.allOf && s.allOf.length > 0) {
+    const schemas = s.allOf.map((sub) => jsonSchemaToZod(sub));
+    return schemas.reduce((acc, curr) => z.intersection(acc, curr));
+  }
+  switch (s.type) {
+    case "string":
+      return makeNullable(buildStringSchema(s));
+    case "number":
+    case "integer":
+      return makeNullable(buildNumberSchema(s));
+    case "boolean":
+      return makeNullable(z.boolean());
+    case "null":
+      return z.null();
+    case "array":
+      return makeNullable(buildArraySchema(s));
+    case "object":
+      return makeNullable(buildObjectSchema(s));
+    default:
+      return z.unknown();
+  }
+}
+function buildStringSchema(schema) {
+  let zodSchema = z.string();
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  switch (schema.format) {
+    case "email":
+      zodSchema = zodSchema.email();
+      break;
+    case "uri":
+    case "url":
+      zodSchema = zodSchema.url();
+      break;
+    case "uuid":
+      zodSchema = zodSchema.uuid();
+      break;
+    case "date-time":
+      zodSchema = zodSchema.datetime();
+      break;
+    case "date":
+      zodSchema = zodSchema.date();
+      break;
+  }
+  if (schema.minLength !== undefined) {
+    zodSchema = zodSchema.min(schema.minLength);
+  }
+  if (schema.maxLength !== undefined) {
+    zodSchema = zodSchema.max(schema.maxLength);
+  }
+  if (schema.pattern) {
+    zodSchema = zodSchema.regex(new RegExp(schema.pattern));
+  }
+  return zodSchema;
+}
+function buildNumberSchema(schema) {
+  let zodSchema = schema.type === "integer" ? z.number().int() : z.number();
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  if (schema.minimum !== undefined) {
+    zodSchema = zodSchema.min(schema.minimum);
+  }
+  if (schema.maximum !== undefined) {
+    zodSchema = zodSchema.max(schema.maximum);
+  }
+  return zodSchema;
+}
+function buildArraySchema(schema) {
+  const itemsSchema = schema.items ? jsonSchemaToZod(schema.items) : z.unknown();
+  let zodSchema = z.array(itemsSchema);
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  return zodSchema;
+}
+function buildObjectSchema(schema) {
+  const properties = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [key, propSchema] of Object.entries(properties)) {
+    const zodProp = jsonSchemaToZod(propSchema);
+    shape[key] = required.has(key) ? zodProp : zodProp.optional();
+  }
+  let zodSchema = z.object(shape);
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  return zodSchema;
+}
+function jsonSchemaToZodSafe(schema) {
+  if (!schema || Object.keys(schema).length === 0) {
+    return z.object({});
+  }
+  return jsonSchemaToZod(schema);
+}
+var init_json_schema_to_zod = () => {};
+
+// src/tools/tool-adapter.ts
+import { tool } from "ai";
+function specToolToAISDKTool(specTool, handler, context = {}) {
+  return tool({
+    description: specTool.description ?? specTool.name,
+    inputSchema: jsonSchemaToZodSafe(specTool.schema),
+    needsApproval: specTool.requiresApproval ?? !specTool.automationSafe,
+    execute: async (input) => {
+      const result = await handler(input, {
+        agentId: context.agentId ?? "unknown",
+        sessionId: context.sessionId ?? "unknown",
+        tenantId: context.tenantId,
+        actorId: context.actorId,
+        metadata: context.metadata,
+        signal: context.signal
+      });
+      return typeof result === "string" ? result : JSON.stringify(result);
+    }
+  });
+}
+function specToolsToAISDKTools(specTools, handlers, context = {}) {
+  const tools = {};
+  for (const specTool of specTools) {
+    const handler = handlers.get(specTool.name);
+    if (!handler) {
+      throw new Error(`Missing handler for tool: ${specTool.name}`);
+    }
+    tools[specTool.name] = specToolToAISDKTool(specTool, handler, context);
+  }
+  return tools;
+}
+function createToolHandler(handler) {
+  return async (input, context) => {
+    return handler(input, context);
+  };
+}
+function buildToolHandlers(handlersObj) {
+  return new Map(Object.entries(handlersObj));
+}
+var init_tool_adapter = __esm(() => {
+  init_json_schema_to_zod();
+});
+
+// src/tools/knowledge-tool.ts
+import { tool as tool2 } from "ai";
+import * as z2 from "zod";
+function createKnowledgeQueryTool(retriever, knowledgeRefs) {
+  const optionalSpaces = knowledgeRefs.filter((k) => !k.required).map((k) => k.key).filter((key) => retriever.supportsSpace(key));
+  if (optionalSpaces.length === 0) {
+    return null;
+  }
+  const spaceDescriptions = knowledgeRefs.filter((k) => !k.required && retriever.supportsSpace(k.key)).map((k) => `- ${k.key}: ${k.instructions ?? "Knowledge space"}`).join(`
+`);
+  return tool2({
+    description: `Query knowledge bases for relevant information. Use this tool when you need to look up specific information that may not be in your context.
+
+Available knowledge spaces:
+${spaceDescriptions}`,
+    inputSchema: z2.object({
+      query: z2.string().describe("The question or search query to find relevant information"),
+      spaceKey: z2.enum(optionalSpaces).optional().describe("Specific knowledge space to query. If omitted, searches all available spaces."),
+      topK: z2.number().optional().default(5).describe("Maximum number of results to return")
+    }),
+    execute: async ({ query, spaceKey, topK }) => {
+      const spacesToSearch = spaceKey ? [spaceKey] : optionalSpaces;
+      const allResults = [];
+      for (const space of spacesToSearch) {
+        try {
+          const results = await retriever.retrieve(query, {
+            spaceKey: space,
+            topK: topK ?? 5
+          });
+          for (const result of results) {
+            allResults.push({
+              space,
+              content: result.content,
+              score: result.score
+            });
+          }
+        } catch (error) {
+          console.warn(`Failed to query knowledge space ${space}:`, error);
+        }
+      }
+      if (allResults.length === 0) {
+        return "No relevant information found in the knowledge bases.";
+      }
+      allResults.sort((a, b) => b.score - a.score);
+      const topResults = allResults.slice(0, topK ?? 5);
+      return topResults.map((r, i) => `[Source ${i + 1} - ${r.space}] (relevance: ${(r.score * 100).toFixed(0)}%)
+${r.content}`).join(`
+
+---
+
+`);
+    }
+  });
+}
+var init_knowledge_tool = () => {};
+
+// src/tools/mcp-client.ts
+import { experimental_createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport as StdioClientTransport } from "@ai-sdk/mcp/mcp-stdio";
+async function mcpServerToTools(config) {
+  const transport = new StdioClientTransport({
+    command: config.command,
+    args: config.args,
+    env: config.env
+  });
+  const client = await experimental_createMCPClient({ transport });
+  const tools = await client.tools();
+  return {
+    tools,
+    cleanup: () => client.close()
+  };
+}
+async function createMcpToolsets(configs) {
+  const results = await Promise.all(configs.map(mcpServerToTools));
+  const combinedTools = {};
+  for (const result of results) {
+    Object.assign(combinedTools, result.tools);
+  }
+  return {
+    tools: combinedTools,
+    cleanup: async () => {
+      await Promise.all(results.map((r) => r.cleanup()));
+    }
+  };
+}
+
+// src/tools/mcp-server.ts
+init_json_schema_to_zod();
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z3 from "zod";
+function agentToMcpServer(agent, spec) {
+  const server = new McpServer({
+    name: spec.meta.key,
+    version: `${spec.meta.version}`
+  });
+  server.registerTool(spec.meta.key, {
+    description: spec.description ?? `Interact with ${spec.meta.key} agent`,
+    inputSchema: z3.object({
+      message: z3.string().describe("The message or query to send to the agent"),
+      sessionId: z3.string().optional().describe("Optional session ID to continue a conversation")
+    })
+  }, async (args) => {
+    const { message, sessionId } = args;
+    const result = await agent.generate({
+      prompt: message,
+      options: { sessionId }
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: result.text
+        }
+      ]
+    };
+  });
+  for (const toolConfig of spec.tools) {
+    const inputSchema = toolConfig.schema ? jsonSchemaToZodSafe(toolConfig.schema) : z3.object({});
+    server.registerTool(`${spec.meta.key}.${toolConfig.name}`, {
+      description: toolConfig.description ?? `Execute ${toolConfig.name} tool`,
+      inputSchema
+    }, async (args) => {
+      const result = await agent.generate({
+        prompt: `Execute the ${toolConfig.name} tool with the following arguments: ${JSON.stringify(args)}`
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.text
+          }
+        ]
+      };
+    });
+  }
+  return server;
+}
+function createAgentMcpServer(config) {
+  return agentToMcpServer(config.agent, config.spec);
+}
+
+// src/tools/index.ts
+init_tool_adapter();
+init_knowledge_tool();
+export {
+  specToolsToAISDKTools,
+  specToolToAISDKTool,
+  mcpServerToTools,
+  createToolHandler,
+  createMcpToolsets,
+  createKnowledgeQueryTool,
+  createAgentMcpServer,
+  buildToolHandlers,
+  agentToMcpServer
+};

package/dist/tools/knowledge-tool.d.ts

@@ -1,8 +1,6 @@
-import { AgentKnowledgeRef } from "../spec/spec.js";
-import { Tool } from "ai";
-import { KnowledgeRetriever } from "@contractspec/lib.knowledge/retriever";
-
-//#region src/tools/knowledge-tool.d.ts
+import { type Tool } from 'ai';
+import type { KnowledgeRetriever } from '@contractspec/lib.knowledge/retriever';
+import type { AgentKnowledgeRef } from '../spec/spec';
 /**
  * Create a knowledge query tool for dynamic RAG.
  *
@@ -14,7 +12,5 @@ import { KnowledgeRetriever } from "@contractspec/lib.knowledge/retriever";
  * @param knowledgeRefs - Knowledge references from the agent spec
  * @returns AI SDK CoreTool for knowledge queries
  */
-declare function createKnowledgeQueryTool(retriever: KnowledgeRetriever, knowledgeRefs: AgentKnowledgeRef[]): Tool<any, any> | null;
-//#endregion
-export { createKnowledgeQueryTool };
+export declare function createKnowledgeQueryTool(retriever: KnowledgeRetriever, knowledgeRefs: AgentKnowledgeRef[]): Tool<any, any> | null;
 //# sourceMappingURL=knowledge-tool.d.ts.map

package/dist/tools/knowledge-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"knowledge-tool.d.ts","names":[],"sources":["../../src/tools/knowledge-tool.ts"],"mappings":";;;;;;;AAgBA;;;;;;;;;iBAAgB,wBAAA,CACd,SAAA,EAAW,kBAAA,EACX,aAAA,EAAe,iBAAA,KAEd,IAAA"}
+{"version":3,"file":"knowledge-tool.d.ts","sourceRoot":"","sources":["../../src/tools/knowledge-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,IAAI,EAAE,MAAM,IAAI,CAAC;AAErC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,kBAAkB,EAC7B,aAAa,EAAE,iBAAiB,EAAE,GAEjC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAgFvB"}

package/dist/tools/knowledge-tool.js

@@ -1,54 +1,74 @@
-import { tool } from "ai";
-import * as z$1 from "zod";
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
-//#region src/tools/knowledge-tool.ts
-/**
-* Create a knowledge query tool for dynamic RAG.
-*
-* This tool allows the agent to query optional knowledge spaces
-* at runtime. Required knowledge is injected statically via
-* the knowledge injector.
-*
-* @param retriever - The knowledge retriever to use
-* @param knowledgeRefs - Knowledge references from the agent spec
-* @returns AI SDK CoreTool for knowledge queries
-*/
+// src/tools/knowledge-tool.ts
+import { tool } from "ai";
+import * as z from "zod";
 function createKnowledgeQueryTool(retriever, knowledgeRefs) {
-	const optionalSpaces = knowledgeRefs.filter((k) => !k.required).map((k) => k.key).filter((key) => retriever.supportsSpace(key));
-	if (optionalSpaces.length === 0) return null;
-	return tool({
-		description: `Query knowledge bases for relevant information. Use this tool when you need to look up specific information that may not be in your context.
+  const optionalSpaces = knowledgeRefs.filter((k) => !k.required).map((k) => k.key).filter((key) => retriever.supportsSpace(key));
+  if (optionalSpaces.length === 0) {
+    return null;
+  }
+  const spaceDescriptions = knowledgeRefs.filter((k) => !k.required && retriever.supportsSpace(k.key)).map((k) => `- ${k.key}: ${k.instructions ?? "Knowledge space"}`).join(`
+`);
+  return tool({
+    description: `Query knowledge bases for relevant information. Use this tool when you need to look up specific information that may not be in your context.
 
 Available knowledge spaces:
-${knowledgeRefs.filter((k) => !k.required && retriever.supportsSpace(k.key)).map((k) => `- ${k.key}: ${k.instructions ?? "Knowledge space"}`).join("\n")}`,
-		inputSchema: z$1.object({
-			query: z$1.string().describe("The question or search query to find relevant information"),
-			spaceKey: z$1.enum(optionalSpaces).optional().describe("Specific knowledge space to query. If omitted, searches all available spaces."),
-			topK: z$1.number().optional().default(5).describe("Maximum number of results to return")
-		}),
-		execute: async ({ query, spaceKey, topK }) => {
-			const spacesToSearch = spaceKey ? [spaceKey] : optionalSpaces;
-			const allResults = [];
-			for (const space of spacesToSearch) try {
-				const results = await retriever.retrieve(query, {
-					spaceKey: space,
-					topK: topK ?? 5
-				});
-				for (const result of results) allResults.push({
-					space,
-					content: result.content,
-					score: result.score
-				});
-			} catch (error) {
-				console.warn(`Failed to query knowledge space ${space}:`, error);
-			}
-			if (allResults.length === 0) return "No relevant information found in the knowledge bases.";
-			allResults.sort((a, b) => b.score - a.score);
-			return allResults.slice(0, topK ?? 5).map((r, i) => `[Source ${i + 1} - ${r.space}] (relevance: ${(r.score * 100).toFixed(0)}%)\n${r.content}`).join("\n\n---\n\n");
-		}
-	});
+${spaceDescriptions}`,
+    inputSchema: z.object({
+      query: z.string().describe("The question or search query to find relevant information"),
+      spaceKey: z.enum(optionalSpaces).optional().describe("Specific knowledge space to query. If omitted, searches all available spaces."),
+      topK: z.number().optional().default(5).describe("Maximum number of results to return")
+    }),
+    execute: async ({ query, spaceKey, topK }) => {
+      const spacesToSearch = spaceKey ? [spaceKey] : optionalSpaces;
+      const allResults = [];
+      for (const space of spacesToSearch) {
+        try {
+          const results = await retriever.retrieve(query, {
+            spaceKey: space,
+            topK: topK ?? 5
+          });
+          for (const result of results) {
+            allResults.push({
+              space,
+              content: result.content,
+              score: result.score
+            });
+          }
+        } catch (error) {
+          console.warn(`Failed to query knowledge space ${space}:`, error);
+        }
+      }
+      if (allResults.length === 0) {
+        return "No relevant information found in the knowledge bases.";
+      }
+      allResults.sort((a, b) => b.score - a.score);
+      const topResults = allResults.slice(0, topK ?? 5);
+      return topResults.map((r, i) => `[Source ${i + 1} - ${r.space}] (relevance: ${(r.score * 100).toFixed(0)}%)
+${r.content}`).join(`
+
+---
+
+`);
+    }
+  });
 }
+var init_knowledge_tool = () => {};
+init_knowledge_tool();
 
-//#endregion
-export { createKnowledgeQueryTool };
-//# sourceMappingURL=knowledge-tool.js.map
+export {
+  createKnowledgeQueryTool
+};

package/dist/tools/mcp-client.d.ts

@@ -1,27 +1,25 @@
-import { Tool } from "ai";
-
-//#region src/tools/mcp-client.d.ts
+import type { Tool } from 'ai';
 /**
  * Configuration for connecting to an MCP server.
  */
-interface McpClientConfig {
-  /** Display name for the MCP server */
-  name: string;
-  /** Command to spawn the MCP server process */
-  command: string;
-  /** Arguments to pass to the command */
-  args?: string[];
-  /** Environment variables for the process */
-  env?: Record<string, string>;
+export interface McpClientConfig {
+    /** Display name for the MCP server */
+    name: string;
+    /** Command to spawn the MCP server process */
+    command: string;
+    /** Arguments to pass to the command */
+    args?: string[];
+    /** Environment variables for the process */
+    env?: Record<string, string>;
 }
 /**
  * Result of creating an MCP client with tools.
  */
-interface McpClientResult {
-  /** AI SDK tools from the MCP server */
-  tools: Record<string, Tool<unknown, unknown>>;
-  /** Cleanup function to close the connection */
-  cleanup: () => Promise<void>;
+export interface McpClientResult {
+    /** AI SDK tools from the MCP server */
+    tools: Record<string, Tool<unknown, unknown>>;
+    /** Cleanup function to close the connection */
+    cleanup: () => Promise<void>;
 }
 /**
  * Create AI SDK tools from an MCP server.
@@ -45,14 +43,12 @@ interface McpClientResult {
  * await cleanup();
  * ```
  */
-declare function mcpServerToTools(config: McpClientConfig): Promise<McpClientResult>;
+export declare function mcpServerToTools(config: McpClientConfig): Promise<McpClientResult>;
 /**
  * Create multiple MCP tool sets from configurations.
  *
  * @param configs - Array of MCP server configurations
  * @returns Combined tools and cleanup function
  */
-declare function createMcpToolsets(configs: McpClientConfig[]): Promise<McpClientResult>;
-//#endregion
-export { McpClientConfig, McpClientResult, createMcpToolsets, mcpServerToTools };
+export declare function createMcpToolsets(configs: McpClientConfig[]): Promise<McpClientResult>;
 //# sourceMappingURL=mcp-client.d.ts.map

package/dist/tools/mcp-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-client.d.ts","names":[],"sources":["../../src/tools/mcp-client.ts"],"mappings":";;;;;AAOA;UAAiB,eAAA;;EAEf,IAAA;EAAA;EAEA,OAAA;EAEA;EAAA,IAAA;EAEM;EAAN,GAAA,GAAM,MAAA;AAAA;AAMR;;;AAAA,UAAiB,eAAA;EAER;EAAP,KAAA,EAAO,MAAA,SAAe,IAAA;EAEA;EAAtB,OAAA,QAAe,OAAA;AAAA;;;;;;;AAyBjB;;;;;;;;;;;;;;AAwBA;;iBAxBsB,gBAAA,CACpB,MAAA,EAAQ,eAAA,GACP,OAAA,CAAQ,eAAA;;;;;;;iBAsBW,iBAAA,CACpB,OAAA,EAAS,eAAA,KACR,OAAA,CAAQ,eAAA"}
+{"version":3,"file":"mcp-client.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9C,+CAA+C;IAC/C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,eAAe,CAAC,CAc1B;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,eAAe,EAAE,GACzB,OAAO,CAAC,eAAe,CAAC,CAc1B"}

package/dist/tools/mcp-client.js

@@ -1,58 +1,47 @@
-import { experimental_createMCPClient } from "@ai-sdk/mcp";
-import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
-//#region src/tools/mcp-client.ts
-/**
-* Create AI SDK tools from an MCP server.
-*
-* This adapter allows ContractSpec agents to consume tools
-* from external MCP servers (e.g., filesystem, database, etc.).
-*
-* @param config - MCP server configuration
-* @returns Tools and cleanup function
-*
-* @example
-* ```typescript
-* const { tools, cleanup } = await mcpServerToTools({
-*   name: 'filesystem',
-*   command: 'npx',
-*   args: ['-y', '@modelcontextprotocol/server-filesystem', '/path'],
-* });
-*
-* // Use tools in agent...
-*
-* await cleanup();
-* ```
-*/
+// src/tools/mcp-client.ts
+import { experimental_createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport as StdioClientTransport } from "@ai-sdk/mcp/mcp-stdio";
 async function mcpServerToTools(config) {
-	const client = await experimental_createMCPClient({ transport: new Experimental_StdioMCPTransport({
-		command: config.command,
-		args: config.args,
-		env: config.env
-	}) });
-	return {
-		tools: await client.tools(),
-		cleanup: () => client.close()
-	};
+  const transport = new StdioClientTransport({
+    command: config.command,
+    args: config.args,
+    env: config.env
+  });
+  const client = await experimental_createMCPClient({ transport });
+  const tools = await client.tools();
+  return {
+    tools,
+    cleanup: () => client.close()
+  };
 }
-/**
-* Create multiple MCP tool sets from configurations.
-*
-* @param configs - Array of MCP server configurations
-* @returns Combined tools and cleanup function
-*/
 async function createMcpToolsets(configs) {
-	const results = await Promise.all(configs.map(mcpServerToTools));
-	const combinedTools = {};
-	for (const result of results) Object.assign(combinedTools, result.tools);
-	return {
-		tools: combinedTools,
-		cleanup: async () => {
-			await Promise.all(results.map((r) => r.cleanup()));
-		}
-	};
+  const results = await Promise.all(configs.map(mcpServerToTools));
+  const combinedTools = {};
+  for (const result of results) {
+    Object.assign(combinedTools, result.tools);
+  }
+  return {
+    tools: combinedTools,
+    cleanup: async () => {
+      await Promise.all(results.map((r) => r.cleanup()));
+    }
+  };
 }
-
-//#endregion
-export { createMcpToolsets, mcpServerToTools };
-//# sourceMappingURL=mcp-client.js.map
+export {
+  mcpServerToTools,
+  createMcpToolsets
+};