@avasis-ai/synthcode 1.0.0

package/dist/llm/index.d.ts

@@ -0,0 +1,70 @@
+import { B as BaseProvider, P as ProviderConfig, C as ChatRequest, M as ModelResponse, c as ChatMessage, A as APIToolDefinition, e as TokenUsage, f as Provider } from '../types-C11cw5ZD.js';
+export { R as RetryableError } from '../types-C11cw5ZD.js';
+import 'zod';
+
+interface AnthropicProviderConfig extends ProviderConfig {
+    apiKey: string;
+    baseURL?: string;
+    dangerouslySkipAuth?: boolean;
+    enableCaching?: boolean;
+}
+declare class AnthropicProvider extends BaseProvider {
+    private readonly apiKey;
+    private readonly baseURL?;
+    private readonly dangerouslySkipAuth?;
+    private readonly enableCaching;
+    private client;
+    constructor(config: AnthropicProviderConfig);
+    chat(request: ChatRequest): Promise<ModelResponse>;
+    protected mapMessages(messages: ChatMessage[]): unknown[];
+    protected mapTools(tools?: APIToolDefinition[]): unknown[] | undefined;
+    protected mapUsage(providerUsage: unknown): TokenUsage;
+    private mapOutgoingBlock;
+}
+
+interface OpenAIProviderConfig extends ProviderConfig {
+    apiKey: string;
+    baseURL?: string;
+    organization?: string;
+}
+declare class OpenAIProvider extends BaseProvider {
+    private readonly apiKey;
+    private readonly baseURL?;
+    private readonly organization?;
+    private client;
+    constructor(config: OpenAIProviderConfig);
+    chat(request: ChatRequest): Promise<ModelResponse>;
+    protected mapMessages(messages: ChatMessage[]): unknown[];
+    protected mapTools(tools?: APIToolDefinition[]): unknown[] | undefined;
+    protected mapUsage(providerUsage: unknown): TokenUsage;
+}
+
+interface OllamaProviderConfig {
+    model: string;
+    baseURL?: string;
+}
+declare class OllamaProvider implements Provider {
+    readonly model: string;
+    private readonly baseURL;
+    constructor(config: OllamaProviderConfig);
+    chat(request: ChatRequest): Promise<ModelResponse>;
+}
+
+declare function anthropic(config: AnthropicProviderConfig): AnthropicProvider;
+declare function openai(config: OpenAIProviderConfig): OpenAIProvider;
+declare function ollama(config: OllamaProviderConfig): OllamaProvider;
+interface CustomProviderConfig {
+    provider: 'custom';
+    model: string;
+    chat: (request: ChatRequest) => Promise<ModelResponse>;
+}
+type OllamaProviderConfigWithProvider = OllamaProviderConfig & {
+    provider: 'ollama';
+};
+declare function createProvider(config: (AnthropicProviderConfig & {
+    provider: 'anthropic';
+}) | (OpenAIProviderConfig & {
+    provider: 'openai';
+}) | OllamaProviderConfigWithProvider | CustomProviderConfig): Provider;
+
+export { APIToolDefinition, AnthropicProvider, type AnthropicProviderConfig, BaseProvider, ChatMessage, ChatRequest, type CustomProviderConfig, OllamaProvider, type OllamaProviderConfig, type OllamaProviderConfigWithProvider, OpenAIProvider, type OpenAIProviderConfig, Provider, anthropic, createProvider, ollama, openai };

package/dist/llm/index.js

@@ -0,0 +1,24 @@
+import {
+  AnthropicProvider,
+  BaseProvider,
+  OllamaProvider,
+  OpenAIProvider,
+  RetryableError,
+  anthropic,
+  createProvider,
+  ollama,
+  openai
+} from "../chunk-F34HO4RA.js";
+import "../chunk-DGUM43GV.js";
+export {
+  AnthropicProvider,
+  BaseProvider,
+  OllamaProvider,
+  OpenAIProvider,
+  RetryableError,
+  anthropic,
+  createProvider,
+  ollama,
+  openai
+};
+//# sourceMappingURL=index.js.map

package/dist/llm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/mcp/index.cjs

@@ -0,0 +1,323 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mcp/index.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  MCPClient: () => MCPClient,
+  loadMCPTools: () => loadMCPTools
+});
+module.exports = __toCommonJS(mcp_exports);
+
+// src/mcp/client.ts
+var MCPClient = class {
+  config;
+  tools = [];
+  proc = null;
+  initialized = false;
+  nextId = 1;
+  messageBuffer = "";
+  pendingHandlers = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  send(proc, method, params, id) {
+    const msgId = id ?? this.nextId++;
+    const msg = JSON.stringify({ jsonrpc: "2.0", id: msgId, method, params });
+    proc.stdin.write(msg + "\n");
+    return msgId;
+  }
+  setupMessageHandler(proc) {
+    proc.stdout.on("data", (data) => {
+      this.messageBuffer += data.toString();
+      const lines = this.messageBuffer.split("\n");
+      this.messageBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id !== void 0 && this.pendingHandlers.has(msg.id)) {
+            const handler = this.pendingHandlers.get(msg.id);
+            this.pendingHandlers.delete(msg.id);
+            handler(msg);
+          } else if (msg.method === "initialize" && msg.id) {
+            proc.stdin.write(JSON.stringify({
+              jsonrpc: "2.0",
+              id: msg.id,
+              result: { protocolVersion: "2024-11-05", capabilities: {}, serverInfo: { name: "synthcode-mcp-proxy", version: "0.6.0" } }
+            }) + "\n");
+          }
+        } catch {
+        }
+      }
+    });
+    proc.stderr.on("data", () => {
+    });
+  }
+  async connect() {
+    if (this.config.type === "stdio") {
+      const { spawn } = await import("child_process");
+      const proc = spawn(this.config.command, this.config.args ?? [], {
+        env: { ...process.env, ...this.config.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      proc.on("error", (err) => {
+        throw err;
+      });
+      proc.on("close", () => {
+        this.initialized = false;
+      });
+      this.proc = proc;
+      this.setupMessageHandler(proc);
+      await new Promise((resolve) => {
+        const handler = (_data) => {
+          proc.stdout.off("data", handler);
+          resolve();
+        };
+        proc.stdout.on("data", handler);
+        setTimeout(() => {
+          proc.stdout.off("data", handler);
+          resolve();
+        }, 2e3);
+      });
+      this.initialized = true;
+    }
+    if (this.config.type === "sse") {
+      if (!this.config.url) throw new Error("SSE MCP server requires a url");
+      this.initialized = true;
+    }
+  }
+  async listTools() {
+    if (this.config.type === "stdio" && this.proc) {
+      const id = this.nextId++;
+      const tools = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingHandlers.delete(id);
+          reject(new Error("MCP listTools timeout"));
+        }, 1e4);
+        this.pendingHandlers.set(id, (msg) => {
+          clearTimeout(timeout);
+          const m = msg;
+          if (m.result?.tools) {
+            resolve(
+              m.result.tools.map((t) => ({
+                name: t.name,
+                description: t.description ?? "",
+                inputSchema: t.inputSchema ?? { type: "object", properties: {} }
+              }))
+            );
+          } else {
+            resolve([]);
+          }
+        });
+      });
+      this.send(this.proc, "tools/list", {}, id);
+      this.tools = tools;
+      return tools;
+    }
+    return [];
+  }
+  async callTool(name, input) {
+    if (this.config.type === "stdio" && this.proc) {
+      const id = this.nextId++;
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingHandlers.delete(id);
+          reject(new Error("MCP callTool timeout"));
+        }, 3e4);
+        this.pendingHandlers.set(id, (msg) => {
+          clearTimeout(timeout);
+          const m = msg;
+          if (m.result) {
+            resolve(typeof m.result === "string" ? m.result : JSON.stringify(m.result));
+          } else if (m.error) {
+            reject(
+              new Error(
+                m.error.message ?? "MCP tool error"
+              )
+            );
+          }
+        });
+        this.send(this.proc, "tools/call", { name, arguments: input }, id);
+      });
+    }
+    throw new Error("MCP callTool not implemented for SSE type");
+  }
+  async disconnect() {
+    if (this.proc) {
+      this.proc.kill();
+      this.proc = null;
+    }
+  }
+  getTools() {
+    return this.tools;
+  }
+};
+
+// src/tools/tool.ts
+function zodToJsonSchema(schema) {
+  const s = schema;
+  const def = s._def;
+  const typeName = def.typeName;
+  const description = def.description;
+  const base = {};
+  if (description) base.description = description;
+  switch (typeName) {
+    case "ZodString":
+      return { ...base, type: "string" };
+    case "ZodNumber":
+      return { ...base, type: "number" };
+    case "ZodBoolean":
+      return { ...base, type: "boolean" };
+    case "ZodNull":
+      return { ...base, type: "null" };
+    case "ZodArray": {
+      const items = zodToJsonSchema(def.element);
+      return { ...base, type: "array", items };
+    }
+    case "ZodObject": {
+      const shapeFn = def.shape;
+      const shape = shapeFn();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        const propDef = value._def;
+        if (propDef.typeName !== "ZodOptional" && propDef.typeName !== "ZodNullish" && propDef.typeName !== "ZodDefault") {
+          required.push(key);
+        }
+      }
+      const result = { ...base, type: "object", properties };
+      if (required.length > 0) result.required = required;
+      return result;
+    }
+    case "ZodEnum":
+      return { ...base, enum: def.values };
+    case "ZodLiteral":
+      return { ...base, const: def.value };
+    case "ZodUnion": {
+      const options = def.options.map((o) => zodToJsonSchema(o));
+      return { ...base, anyOf: options };
+    }
+    case "ZodDiscriminatedUnion": {
+      const options = def.options.map((o) => zodToJsonSchema(o));
+      return { ...base, anyOf: options };
+    }
+    case "ZodOptional":
+      return zodToJsonSchema(def.innerType);
+    case "ZodNullable": {
+      const inner = zodToJsonSchema(def.innerType);
+      inner.nullable = true;
+      return inner;
+    }
+    case "ZodNullish": {
+      const inner = zodToJsonSchema(def.innerType);
+      inner.nullable = true;
+      return inner;
+    }
+    case "ZodDefault":
+      return zodToJsonSchema(def.innerType);
+    case "ZodRecord": {
+      const valueSchema = zodToJsonSchema(def.valueType);
+      return { ...base, type: "object", additionalProperties: valueSchema };
+    }
+    case "ZodTuple": {
+      const items = def.items.map((o) => zodToJsonSchema(o));
+      return { ...base, type: "array", items, minItems: items.length, maxItems: items.length };
+    }
+    case "ZodEffects": {
+      return zodToJsonSchema(def.innerType);
+    }
+    case "ZodAny":
+      return {};
+    case "ZodUnknown":
+      return {};
+    case "ZodVoid":
+      return { ...base, type: "null" };
+    case "ZodNever":
+      return { ...base, not: {} };
+    default:
+      return { ...base, type: "string" };
+  }
+}
+function defineTool(config) {
+  const tool = {
+    name: config.name,
+    description: config.description,
+    inputSchema: config.inputSchema,
+    isReadOnly: config.isReadOnly ?? false,
+    isConcurrencySafe: config.isConcurrencySafe ?? false,
+    execute: config.execute,
+    toAPI() {
+      return {
+        name: config.name,
+        description: config.description,
+        input_schema: zodToJsonSchema(config.inputSchema)
+      };
+    },
+    toString(input) {
+      const entries = Object.entries(input).map(([k, v]) => {
+        if (typeof v === "string") return `${k}: "${v}"`;
+        if (v === void 0) return `${k}: undefined`;
+        if (v === null) return `${k}: null`;
+        return `${k}: ${String(v)}`;
+      }).join(", ");
+      return `${config.name}({ ${entries} })`;
+    }
+  };
+  return tool;
+}
+
+// src/mcp/adapter.ts
+async function loadMCPTools(config) {
+  const { z } = await import("zod");
+  const client = new MCPClient(config);
+  await client.connect();
+  const definitions = await client.listTools();
+  const tools = definitions.map(
+    (def) => defineTool({
+      name: def.name,
+      description: def.description,
+      inputSchema: z.object({}).passthrough(),
+      isReadOnly: true,
+      isConcurrencySafe: true,
+      execute: async (input, _context) => {
+        const result = await client.callTool(def.name, input);
+        return result;
+      }
+    })
+  );
+  return { tools, client };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPClient,
+  loadMCPTools
+});
+//# sourceMappingURL=index.cjs.map

package/dist/mcp/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/mcp/index.ts","../../src/mcp/client.ts","../../src/tools/tool.ts","../../src/mcp/adapter.ts"],"sourcesContent":["export { MCPClient } from \"./client.js\";\nexport type { MCPServerConfig, MCPToolDefinition } from \"./client.js\";\nexport { loadMCPTools } from \"./adapter.js\";\n","import type { ChildProcess } from \"node:child_process\";\n\nexport interface MCPToolDefinition {\n  name: string;\n  description: string;\n  inputSchema: Record<string, unknown>;\n}\n\nexport interface MCPServerConfig {\n  type: \"stdio\" | \"sse\";\n  command?: string;\n  args?: string[];\n  url?: string;\n  env?: Record<string, string>;\n}\n\nexport class MCPClient {\n  private config: MCPServerConfig;\n  private tools: MCPToolDefinition[] = [];\n  private proc: ChildProcess | null = null;\n  private initialized = false;\n  private nextId = 1;\n  private messageBuffer = \"\";\n  private pendingHandlers: Map<number, (msg: unknown) => void> = new Map();\n\n  constructor(config: MCPServerConfig) {\n    this.config = config;\n  }\n\n  private send(proc: ChildProcess, method: string, params: Record<string, unknown>, id?: number): number {\n    const msgId = id ?? this.nextId++;\n    const msg = JSON.stringify({ jsonrpc: \"2.0\", id: msgId, method, params });\n    proc.stdin!.write(msg + \"\\n\");\n    return msgId;\n  }\n\n  private setupMessageHandler(proc: ChildProcess): void {\n    proc.stdout!.on(\"data\", (data: Buffer) => {\n      this.messageBuffer += data.toString();\n      const lines = this.messageBuffer.split(\"\\n\");\n      this.messageBuffer = lines.pop() ?? \"\";\n      for (const line of lines) {\n        if (!line.trim()) continue;\n        try {\n          const msg = JSON.parse(line);\n          if (msg.id !== undefined && this.pendingHandlers.has(msg.id)) {\n            const handler = this.pendingHandlers.get(msg.id)!;\n            this.pendingHandlers.delete(msg.id);\n            handler(msg);\n          } else if (msg.method === \"initialize\" && msg.id) {\n            proc.stdin!.write(JSON.stringify({\n              jsonrpc: \"2.0\",\n              id: msg.id,\n              result: { protocolVersion: \"2024-11-05\", capabilities: {}, serverInfo: { name: \"synthcode-mcp-proxy\", version: \"0.6.0\" } },\n            }) + \"\\n\");\n          }\n        } catch {}\n      }\n    });\n    proc.stderr!.on(\"data\", () => {});\n  }\n\n  async connect(): Promise<void> {\n    if (this.config.type === \"stdio\") {\n      const { spawn } = await import(\"node:child_process\");\n      const proc = spawn(this.config.command!, this.config.args ?? [], {\n        env: { ...process.env, ...this.config.env },\n        stdio: [\"pipe\", \"pipe\", \"pipe\"],\n      });\n      proc.on(\"error\", (err) => { throw err; });\n      proc.on(\"close\", () => { this.initialized = false; });\n      this.proc = proc;\n      this.setupMessageHandler(proc);\n      await new Promise<void>((resolve) => {\n        const handler = (_data: Buffer) => {\n          proc.stdout!.off(\"data\", handler);\n          resolve();\n        };\n        proc.stdout!.on(\"data\", handler);\n        setTimeout(() => {\n          proc.stdout!.off(\"data\", handler);\n          resolve();\n        }, 2000);\n      });\n      this.initialized = true;\n    }\n    if (this.config.type === \"sse\") {\n      if (!this.config.url) throw new Error(\"SSE MCP server requires a url\");\n      this.initialized = true;\n    }\n  }\n\n  async listTools(): Promise<MCPToolDefinition[]> {\n    if (this.config.type === \"stdio\" && this.proc) {\n      const id = this.nextId++;\n      const tools = await new Promise<MCPToolDefinition[]>((resolve, reject) => {\n        const timeout = setTimeout(() => {\n          this.pendingHandlers.delete(id);\n          reject(new Error(\"MCP listTools timeout\"));\n        }, 10000);\n        this.pendingHandlers.set(id, (msg: unknown) => {\n          clearTimeout(timeout);\n          const m = msg as Record<string, unknown>;\n          if ((m.result as Record<string, unknown>)?.tools) {\n            resolve(\n              ((m.result as Record<string, unknown>).tools as Record<string, unknown>[]).map((t) => ({\n                name: t.name as string,\n                description: (t.description as string) ?? \"\",\n                inputSchema: (t.inputSchema as Record<string, unknown>) ?? { type: \"object\", properties: {} },\n              })),\n            );\n          } else {\n            resolve([]);\n          }\n        });\n      });\n      this.send(this.proc!, \"tools/list\", {}, id);\n      this.tools = tools;\n      return tools;\n    }\n    return [];\n  }\n\n  async callTool(\n    name: string,\n    input: Record<string, unknown>,\n  ): Promise<string> {\n    if (this.config.type === \"stdio\" && this.proc) {\n      const id = this.nextId++;\n      return new Promise((resolve, reject) => {\n        const timeout = setTimeout(() => {\n          this.pendingHandlers.delete(id);\n          reject(new Error(\"MCP callTool timeout\"));\n        }, 30000);\n        this.pendingHandlers.set(id, (msg: unknown) => {\n          clearTimeout(timeout);\n          const m = msg as Record<string, unknown>;\n          if (m.result) {\n            resolve(typeof m.result === \"string\" ? m.result : JSON.stringify(m.result));\n          } else if (m.error) {\n            reject(\n              new Error(\n                ((m.error as Record<string, unknown>).message as string) ?? \"MCP tool error\",\n              ),\n            );\n          }\n        });\n        this.send(this.proc!, \"tools/call\", { name, arguments: input }, id);\n      });\n    }\n    throw new Error(\"MCP callTool not implemented for SSE type\");\n  }\n\n  async disconnect(): Promise<void> {\n    if (this.proc) {\n      this.proc.kill();\n      this.proc = null;\n    }\n  }\n\n  getTools(): MCPToolDefinition[] {\n    return this.tools;\n  }\n}\n","import type { ZodSchema } from 'zod';\nimport type { ToolContext } from '../types.js';\n\n/** JSON Schema representation of a tool for LLM function calling APIs. */\nexport interface APIToolDefinition {\n  name: string;\n  description: string;\n  input_schema: Record<string, unknown>;\n}\n\n/** Core tool abstraction that every tool must implement. */\nexport interface Tool<P = unknown> {\n  readonly name: string;\n  readonly description: string;\n  readonly inputSchema: ZodSchema<P>;\n  readonly isReadOnly: boolean;\n  readonly isConcurrencySafe: boolean;\n\n  execute(input: P, context: ToolContext): Promise<string>;\n  toAPI(): APIToolDefinition;\n  toString(input: P): string;\n}\n\n/** Configuration object for defining a tool. */\nexport interface ToolExecuteOptions<P = unknown> {\n  name: string;\n  description: string;\n  inputSchema: ZodSchema<P>;\n  isReadOnly?: boolean;\n  isConcurrencySafe?: boolean;\n  execute: (input: P, context: ToolContext) => Promise<string>;\n}\n\nfunction zodToJsonSchema(schema: unknown): Record<string, unknown> {\n  const s = schema as { _def: Record<string, unknown> };\n  const def = s._def;\n  const typeName = def.typeName as string;\n  const description = def.description as string | undefined;\n\n  const base: Record<string, unknown> = {};\n  if (description) base.description = description;\n\n  switch (typeName) {\n    case 'ZodString':\n      return { ...base, type: 'string' };\n    case 'ZodNumber':\n      return { ...base, type: 'number' };\n    case 'ZodBoolean':\n      return { ...base, type: 'boolean' };\n    case 'ZodNull':\n      return { ...base, type: 'null' };\n    case 'ZodArray': {\n      const items = zodToJsonSchema(def.element);\n      return { ...base, type: 'array', items };\n    }\n    case 'ZodObject': {\n      const shapeFn = def.shape as () => Record<string, unknown>;\n      const shape = shapeFn();\n      const properties: Record<string, unknown> = {};\n      const required: string[] = [];\n      for (const [key, value] of Object.entries(shape)) {\n        properties[key] = zodToJsonSchema(value);\n        const propDef = (value as { _def: Record<string, unknown> })._def;\n        if (\n          propDef.typeName !== 'ZodOptional' &&\n          propDef.typeName !== 'ZodNullish' &&\n          propDef.typeName !== 'ZodDefault'\n        ) {\n          required.push(key);\n        }\n      }\n      const result: Record<string, unknown> = { ...base, type: 'object', properties };\n      if (required.length > 0) result.required = required;\n      return result;\n    }\n    case 'ZodEnum':\n      return { ...base, enum: def.values };\n    case 'ZodLiteral':\n      return { ...base, const: def.value };\n    case 'ZodUnion': {\n      const options = (def.options as unknown[]).map((o) => zodToJsonSchema(o));\n      return { ...base, anyOf: options };\n    }\n    case 'ZodDiscriminatedUnion': {\n      const options = (def.options as unknown[]).map((o) => zodToJsonSchema(o));\n      return { ...base, anyOf: options };\n    }\n    case 'ZodOptional':\n      return zodToJsonSchema(def.innerType);\n    case 'ZodNullable': {\n      const inner = zodToJsonSchema(def.innerType);\n      inner.nullable = true;\n      return inner;\n    }\n    case 'ZodNullish': {\n      const inner = zodToJsonSchema(def.innerType);\n      inner.nullable = true;\n      return inner;\n    }\n    case 'ZodDefault':\n      return zodToJsonSchema(def.innerType);\n    case 'ZodRecord': {\n      const valueSchema = zodToJsonSchema(def.valueType);\n      return { ...base, type: 'object', additionalProperties: valueSchema };\n    }\n    case 'ZodTuple': {\n      const items = (def.items as unknown[]).map((o) => zodToJsonSchema(o));\n      return { ...base, type: 'array', items, minItems: items.length, maxItems: items.length };\n    }\n    case 'ZodEffects': {\n      return zodToJsonSchema(def.innerType);\n    }\n    case 'ZodAny':\n      return {};\n    case 'ZodUnknown':\n      return {};\n    case 'ZodVoid':\n      return { ...base, type: 'null' };\n    case 'ZodNever':\n      return { ...base, not: {} };\n    default:\n      return { ...base, type: 'string' };\n  }\n}\n\n/** Define a tool from a configuration object. */\nexport function defineTool<P = unknown>(config: ToolExecuteOptions<P>): Tool<P> {\n  const tool: Tool<P> = {\n    name: config.name,\n    description: config.description,\n    inputSchema: config.inputSchema,\n    isReadOnly: config.isReadOnly ?? false,\n    isConcurrencySafe: config.isConcurrencySafe ?? false,\n    execute: config.execute,\n    toAPI(): APIToolDefinition {\n      return {\n        name: config.name,\n        description: config.description,\n        input_schema: zodToJsonSchema(config.inputSchema),\n      };\n    },\n    toString(input: P): string {\n      const entries = Object.entries(input as Record<string, unknown>)\n        .map(([k, v]) => {\n          if (typeof v === 'string') return `${k}: \"${v}\"`;\n          if (v === undefined) return `${k}: undefined`;\n          if (v === null) return `${k}: null`;\n          return `${k}: ${String(v)}`;\n        })\n        .join(', ');\n      return `${config.name}({ ${entries} })`;\n    },\n  };\n  return tool;\n}\n\n/** Wrap a class-based tool into the standard Tool interface. */\nexport function defineToolFromClass(ctor: new () => Tool): Tool {\n  const instance = new ctor();\n  return {\n    name: instance.name,\n    description: instance.description,\n    inputSchema: instance.inputSchema,\n    isReadOnly: instance.isReadOnly,\n    isConcurrencySafe: instance.isConcurrencySafe,\n    execute: (input, context) => instance.execute(input, context),\n    toAPI: () => instance.toAPI(),\n    toString: (input) => instance.toString(input),\n  };\n}\n","import { defineTool } from \"../tools/tool.js\";\nimport type { Tool } from \"../tools/tool.js\";\nimport type { ToolContext } from \"../types.js\";\nimport { MCPClient } from \"./client.js\";\nimport type { MCPToolDefinition, MCPServerConfig } from \"./client.js\";\n\nexport async function loadMCPTools(\n  config: MCPServerConfig,\n): Promise<{ tools: Tool[]; client: MCPClient }> {\n  const { z } = await import(\"zod\");\n\n  const client = new MCPClient(config);\n  await client.connect();\n  const definitions = await client.listTools();\n\n  const tools = definitions.map((def: MCPToolDefinition) =>\n    defineTool({\n      name: def.name,\n      description: def.description,\n      inputSchema: z.object({}).passthrough(),\n      isReadOnly: true,\n      isConcurrencySafe: true,\n      execute: async (input: Record<string, unknown>, _context: ToolContext) => {\n        const result = await client.callTool(def.name, input);\n        return result;\n      },\n    }),\n  );\n\n  return { tools, client };\n}\n"],"mappings":"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","names":[]}

package/dist/mcp/index.d.cts

@@ -0,0 +1,39 @@
+import { T as Tool } from '../types-C11cw5ZD.cjs';
+import 'zod';
+
+interface MCPToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+interface MCPServerConfig {
+    type: "stdio" | "sse";
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+}
+declare class MCPClient {
+    private config;
+    private tools;
+    private proc;
+    private initialized;
+    private nextId;
+    private messageBuffer;
+    private pendingHandlers;
+    constructor(config: MCPServerConfig);
+    private send;
+    private setupMessageHandler;
+    connect(): Promise<void>;
+    listTools(): Promise<MCPToolDefinition[]>;
+    callTool(name: string, input: Record<string, unknown>): Promise<string>;
+    disconnect(): Promise<void>;
+    getTools(): MCPToolDefinition[];
+}
+
+declare function loadMCPTools(config: MCPServerConfig): Promise<{
+    tools: Tool[];
+    client: MCPClient;
+}>;
+
+export { MCPClient, type MCPServerConfig, type MCPToolDefinition, loadMCPTools };

package/dist/mcp/index.d.ts

@@ -0,0 +1,39 @@
+import { T as Tool } from '../types-C11cw5ZD.js';
+import 'zod';
+
+interface MCPToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+interface MCPServerConfig {
+    type: "stdio" | "sse";
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+}
+declare class MCPClient {
+    private config;
+    private tools;
+    private proc;
+    private initialized;
+    private nextId;
+    private messageBuffer;
+    private pendingHandlers;
+    constructor(config: MCPServerConfig);
+    private send;
+    private setupMessageHandler;
+    connect(): Promise<void>;
+    listTools(): Promise<MCPToolDefinition[]>;
+    callTool(name: string, input: Record<string, unknown>): Promise<string>;
+    disconnect(): Promise<void>;
+    getTools(): MCPToolDefinition[];
+}
+
+declare function loadMCPTools(config: MCPServerConfig): Promise<{
+    tools: Tool[];
+    client: MCPClient;
+}>;
+
+export { MCPClient, type MCPServerConfig, type MCPToolDefinition, loadMCPTools };

package/dist/mcp/index.js

@@ -0,0 +1,11 @@
+import {
+  MCPClient,
+  loadMCPTools
+} from "../chunk-TLPOO6C3.js";
+import "../chunk-FK7S2S7V.js";
+import "../chunk-DGUM43GV.js";
+export {
+  MCPClient,
+  loadMCPTools
+};
+//# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}