@decocms/bindings 0.2.4 → 1.0.0-test.1

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "moduleResolution": "node",
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test/**/*"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+  },
+});

package/dist/core/binder.d.ts

@@ -1,3 +0,0 @@
-import 'zod/v3';
-export { B as Binder, f as BindingChecker, h as MCPBindingClient, a as ToolBinder, T as ToolWithSchemas, g as bindingClient, j as createBindingChecker, n as normalizeToJsonSchema } from '../index-D0aUdNls.js';
-import './connection.js';

package/dist/core/binder.js

@@ -1,77 +0,0 @@
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { createMCPFetchStub } from "./client/mcp";
-import { isSubset } from "./subset";
-function isZodSchema(value) {
-  return value !== null && typeof value === "object" && "_def" in value && typeof value._def === "object";
-}
-function normalizeToJsonSchema(schema) {
-  if (schema == null) {
-    return null;
-  }
-  if (isZodSchema(schema)) {
-    return zodToJsonSchema(schema);
-  }
-  return schema;
-}
-const bindingClient = (binder) => {
-  return {
-    ...createBindingChecker(binder),
-    forConnection: (mcpConnection) => {
-      return createMCPFetchStub({
-        connection: mcpConnection,
-        streamable: binder.reduce(
-          (acc, tool) => {
-            acc[tool.name] = tool.streamable === true;
-            return acc;
-          },
-          {}
-        )
-      });
-    }
-  };
-};
-function createBindingChecker(binderTools) {
-  return {
-    isImplementedBy: (tools) => {
-      for (const binderTool of binderTools) {
-        const pattern = typeof binderTool.name === "string" ? new RegExp(`^${binderTool.name}$`) : binderTool.name;
-        const matchedTool = tools.find((t) => pattern.test(t.name));
-        if (!matchedTool && binderTool.opt) {
-          continue;
-        }
-        if (!matchedTool) {
-          return false;
-        }
-        const binderInputSchema = normalizeToJsonSchema(binderTool.inputSchema);
-        const toolInputSchema = normalizeToJsonSchema(matchedTool.inputSchema);
-        if (binderInputSchema && toolInputSchema) {
-          if (!isSubset(binderInputSchema, toolInputSchema)) {
-            return false;
-          }
-        } else if (binderInputSchema && !toolInputSchema) {
-          return false;
-        }
-        const binderOutputSchema = normalizeToJsonSchema(
-          binderTool.outputSchema
-        );
-        const toolOutputSchema = normalizeToJsonSchema(
-          matchedTool.outputSchema
-        );
-        if (binderOutputSchema && toolOutputSchema) {
-          if (!isSubset(binderOutputSchema, toolOutputSchema)) {
-            return false;
-          }
-        } else if (binderOutputSchema && !toolOutputSchema) {
-          return false;
-        }
-      }
-      return true;
-    }
-  };
-}
-export {
-  bindingClient,
-  createBindingChecker,
-  normalizeToJsonSchema
-};
-//# sourceMappingURL=binder.js.map

package/dist/core/binder.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/binder.ts"],"sourcesContent":["/**\n * Core Binder Types and Utilities\n *\n * This module provides the core types and utilities for the bindings system.\n * Bindings define standardized interfaces that integrations (MCPs) can implement.\n */\n\nimport type { ZodType } from \"zod/v3\";\nimport { zodToJsonSchema } from \"zod-to-json-schema\";\nimport { createMCPFetchStub, MCPClientFetchStub } from \"./client/mcp\";\nimport { MCPConnection } from \"./connection\";\nimport { isSubset } from \"./subset\";\n\ntype JsonSchema = Record<string, unknown>;\n\n/**\n * Checks if a value is a Zod schema by looking for the _def property\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction isZodSchema(value: unknown): value is ZodType<any> {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    \"_def\" in value &&\n    typeof (value as Record<string, unknown>)._def === \"object\"\n  );\n}\n\n/**\n * Normalizes a schema to JSON Schema format.\n * Accepts either a Zod schema or a JSON schema and returns a JSON schema.\n *\n * @param schema - A Zod schema or JSON schema\n * @returns The JSON schema representation, or null if input is null/undefined\n */\nexport function normalizeToJsonSchema(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  schema: ZodType<any> | JsonSchema | null | undefined,\n): JsonSchema | null {\n  if (schema == null) {\n    return null;\n  }\n\n  if (isZodSchema(schema)) {\n    return zodToJsonSchema(schema) as JsonSchema;\n  }\n\n  // Already a JSON schema\n  return schema as JsonSchema;\n}\n\n/**\n * ToolBinder defines a single tool within a binding.\n * It specifies the tool name, input/output schemas, and whether it's optional.\n *\n * @template TName - The tool name (can be a string or RegExp for pattern matching)\n * @template TInput - The input type (inferred from inputSchema)\n * @template TReturn - The return type (inferred from outputSchema)\n */\nexport interface ToolBinder<\n  TName extends string | RegExp = string,\n  // biome-ignore lint/suspicious/noExplicitAny: Generic type parameter\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  TInput = any,\n  TReturn extends object | null | boolean = object,\n  TStreamable extends boolean = boolean,\n> {\n  /** The name of the tool (e.g., \"DECO_CHAT_CHANNELS_JOIN\") */\n  name: TName;\n\n  /** Zod schema for validating tool input */\n  inputSchema: ZodType<TInput>;\n\n  /** Optional Zod schema for validating tool output */\n  outputSchema?: TStreamable extends true ? never : ZodType<TReturn>;\n\n  /**\n   * Whether this tool is streamable.\n   */\n  streamable?: TStreamable;\n\n  /**\n   * Whether this tool is optional in the binding.\n   * If true, an implementation doesn't need to provide this tool.\n   */\n  opt?: true;\n}\n\n/**\n * Binder represents a collection of tool definitions that form a binding.\n * A binding is like a TypeScript interface - it defines what tools must be implemented.\n *\n * @template TDefinition - Array of ToolBinder definitions\n *\n * @example\n * ```ts\n * const MY_BINDING = [{\n *   name: \"MY_TOOL\" as const,\n *   inputSchema: z.object({ id: z.string() }),\n *   outputSchema: z.object({ success: z.boolean() }),\n * }] as const satisfies Binder;\n * ```\n */\nexport type Binder<\n  TDefinition extends readonly ToolBinder[] = readonly ToolBinder[],\n> = TDefinition;\n\n/**\n * Tool with schemas for validation\n */\nexport interface ToolWithSchemas {\n  name: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  inputSchema?: ZodType<any> | Record<string, unknown>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  outputSchema?: ZodType<any> | Record<string, unknown>;\n}\n\n/**\n * Binding checker interface\n */\nexport interface BindingChecker {\n  /**\n   * Check if a set of tools implements the binding with full schema validation.\n   *\n   * Validates:\n   * - Tool name matches (exact or regex)\n   * - Input schema: Tool accepts what binder requires (no removals from binder to tool)\n   * - Output schema: Tool provides what binder expects (no removals from tool to binder)\n   *\n   * @param tools - Array of tools with names and schemas\n   * @returns Promise<boolean> - true if all tools implement the binding correctly\n   */\n  isImplementedBy: (tools: ToolWithSchemas[]) => boolean;\n}\n\nexport const bindingClient = <TDefinition extends readonly ToolBinder[]>(\n  binder: TDefinition,\n) => {\n  return {\n    ...createBindingChecker(binder),\n    forConnection: (\n      mcpConnection: MCPConnection,\n    ): MCPClientFetchStub<TDefinition> => {\n      return createMCPFetchStub<TDefinition>({\n        connection: mcpConnection,\n        streamable: binder.reduce(\n          (acc, tool) => {\n            acc[tool.name] = tool.streamable === true;\n            return acc;\n          },\n          {} as Record<string, boolean>,\n        ),\n      });\n    },\n  };\n};\n\nexport type MCPBindingClient<T extends ReturnType<typeof bindingClient>> =\n  ReturnType<T[\"forConnection\"]>;\n\n/**\n * Creates a binding checker with full schema validation using structural subset checking.\n *\n * This performs strict compatibility checking:\n * - For input schemas: Validates that the tool can accept what the binder requires (binder ⊆ tool)\n * - For output schemas: Validates that the tool provides what the binder expects (binder ⊆ tool)\n *\n * @param binderTools - The binding definition to check against\n * @returns A binding checker with an async isImplementedBy method\n *\n * @example\n * ```ts\n * const checker = createBindingChecker(MY_BINDING);\n * const isCompatible = await checker.isImplementedBy(availableTools);\n * ```\n */\nexport function createBindingChecker<TDefinition extends readonly ToolBinder[]>(\n  binderTools: TDefinition,\n): BindingChecker {\n  return {\n    isImplementedBy: (tools: ToolWithSchemas[]): boolean => {\n      for (const binderTool of binderTools) {\n        // Find matching tool by name (exact or regex)\n        const pattern =\n          typeof binderTool.name === \"string\"\n            ? new RegExp(`^${binderTool.name}$`)\n            : binderTool.name;\n\n        const matchedTool = tools.find((t) => pattern.test(t.name));\n\n        // Skip optional tools that aren't present\n        if (!matchedTool && binderTool.opt) {\n          continue;\n        }\n\n        // Required tool not found\n        if (!matchedTool) {\n          return false;\n        }\n\n        // === INPUT SCHEMA VALIDATION ===\n        // Tool must accept what binder requires\n        // Check: isSubset(binder, tool) - every value valid under binder is valid under tool\n        const binderInputSchema = normalizeToJsonSchema(binderTool.inputSchema);\n        const toolInputSchema = normalizeToJsonSchema(matchedTool.inputSchema);\n\n        if (binderInputSchema && toolInputSchema) {\n          // Check if binder input is a subset of tool input (tool accepts what binder requires)\n          if (!isSubset(binderInputSchema, toolInputSchema)) {\n            return false;\n          }\n        } else if (binderInputSchema && !toolInputSchema) {\n          // Binder requires input schema but tool doesn't have one\n          return false;\n        }\n\n        // === OUTPUT SCHEMA VALIDATION ===\n        // Tool must provide what binder expects (but can provide more)\n        // Check: isSubset(binder, tool) - tool provides at least what binder expects\n        const binderOutputSchema = normalizeToJsonSchema(\n          binderTool.outputSchema,\n        );\n        const toolOutputSchema = normalizeToJsonSchema(\n          matchedTool.outputSchema,\n        );\n\n        if (binderOutputSchema && toolOutputSchema) {\n          // Check if binder output is a subset of tool output (tool provides what binder expects)\n          if (!isSubset(binderOutputSchema, toolOutputSchema)) {\n            return false;\n          }\n        } else if (binderOutputSchema && !toolOutputSchema) {\n          // Binder expects output schema but tool doesn't have one\n          return false;\n        }\n      }\n      return true;\n    },\n  };\n}\n"],"mappings":"AAQA,SAAS,uBAAuB;AAChC,SAAS,0BAA8C;AAEvD,SAAS,gBAAgB;AAQzB,SAAS,YAAY,OAAuC;AAC1D,SACE,UAAU,QACV,OAAO,UAAU,YACjB,UAAU,SACV,OAAQ,MAAkC,SAAS;AAEvD;AASO,SAAS,sBAEd,QACmB;AACnB,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AAEA,MAAI,YAAY,MAAM,GAAG;AACvB,WAAO,gBAAgB,MAAM;AAAA,EAC/B;AAGA,SAAO;AACT;AAuFO,MAAM,gBAAgB,CAC3B,WACG;AACH,SAAO;AAAA,IACL,GAAG,qBAAqB,MAAM;AAAA,IAC9B,eAAe,CACb,kBACoC;AACpC,aAAO,mBAAgC;AAAA,QACrC,YAAY;AAAA,QACZ,YAAY,OAAO;AAAA,UACjB,CAAC,KAAK,SAAS;AACb,gBAAI,KAAK,IAAI,IAAI,KAAK,eAAe;AACrC,mBAAO;AAAA,UACT;AAAA,UACA,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAqBO,SAAS,qBACd,aACgB;AAChB,SAAO;AAAA,IACL,iBAAiB,CAAC,UAAsC;AACtD,iBAAW,cAAc,aAAa;AAEpC,cAAM,UACJ,OAAO,WAAW,SAAS,WACvB,IAAI,OAAO,IAAI,WAAW,IAAI,GAAG,IACjC,WAAW;AAEjB,cAAM,cAAc,MAAM,KAAK,CAAC,MAAM,QAAQ,KAAK,EAAE,IAAI,CAAC;AAG1D,YAAI,CAAC,eAAe,WAAW,KAAK;AAClC;AAAA,QACF;AAGA,YAAI,CAAC,aAAa;AAChB,iBAAO;AAAA,QACT;AAKA,cAAM,oBAAoB,sBAAsB,WAAW,WAAW;AACtE,cAAM,kBAAkB,sBAAsB,YAAY,WAAW;AAErE,YAAI,qBAAqB,iBAAiB;AAExC,cAAI,CAAC,SAAS,mBAAmB,eAAe,GAAG;AACjD,mBAAO;AAAA,UACT;AAAA,QACF,WAAW,qBAAqB,CAAC,iBAAiB;AAEhD,iBAAO;AAAA,QACT;AAKA,cAAM,qBAAqB;AAAA,UACzB,WAAW;AAAA,QACb;AACA,cAAM,mBAAmB;AAAA,UACvB,YAAY;AAAA,QACd;AAEA,YAAI,sBAAsB,kBAAkB;AAE1C,cAAI,CAAC,SAAS,oBAAoB,gBAAgB,GAAG;AACnD,mBAAO;AAAA,UACT;AAAA,QACF,WAAW,sBAAsB,CAAC,kBAAkB;AAElD,iBAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

package/dist/core/client/http-client-transport.d.ts

@@ -1,12 +0,0 @@
-import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-import { StreamableHTTPClientTransport, StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-
-declare class HTTPClientTransport extends StreamableHTTPClientTransport {
-    constructor(url: URL, opts?: StreamableHTTPClientTransportOptions);
-    send(message: JSONRPCMessage, options?: {
-        resumptionToken?: string;
-        onresumptiontoken?: (token: string) => void;
-    }): Promise<void>;
-}
-
-export { HTTPClientTransport };

package/dist/core/client/http-client-transport.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/core/client/http-client-transport.ts"],"sourcesContent":["import type { JSONRPCMessage } from \"@modelcontextprotocol/sdk/types.js\";\nimport {\n  StreamableHTTPClientTransport,\n  type StreamableHTTPClientTransportOptions,\n} from \"@modelcontextprotocol/sdk/client/streamableHttp.js\";\n\nexport class HTTPClientTransport extends StreamableHTTPClientTransport {\n  constructor(url: URL, opts?: StreamableHTTPClientTransportOptions) {\n    super(url, opts);\n  }\n\n  override send(\n    message: JSONRPCMessage,\n    options?: {\n      resumptionToken?: string;\n      onresumptiontoken?: (token: string) => void;\n    },\n  ): Promise<void> {\n    const mockAction = getMockActionFor(message);\n    if (mockAction?.type === \"emit\") {\n      this.onmessage?.(mockAction.message);\n      return Promise.resolve();\n    }\n    if (mockAction?.type === \"suppress\") {\n      return Promise.resolve();\n    }\n    return super.send(message, options);\n  }\n}\n\ntype MockAction =\n  | { type: \"emit\"; message: JSONRPCMessage }\n  | { type: \"suppress\" };\n\nfunction getMockActionFor(message: JSONRPCMessage): MockAction | null {\n  const m = message;\n  if (!m || typeof m !== \"object\" || !(\"method\" in m)) return null;\n\n  switch (m.method) {\n    case \"initialize\": {\n      const protocolVersion = m?.params?.protocolVersion;\n      if (!protocolVersion) return null;\n      return {\n        type: \"emit\",\n        message: {\n          result: {\n            protocolVersion,\n            capabilities: { tools: {} },\n            serverInfo: { name: \"deco-chat-server\", version: \"1.0.0\" },\n          },\n          jsonrpc: m.jsonrpc ?? \"2.0\",\n          // @ts-expect-error - id is not typed\n          id: m.id,\n        } as JSONRPCMessage,\n      };\n    }\n    case \"notifications/roots/list_changed\":\n    case \"notifications/initialized\":\n    case \"notifications/cancelled\":\n    case \"notifications/progress\": {\n      return { type: \"suppress\" };\n    }\n    default:\n      return null;\n  }\n}\n"],"mappings":"AACA;AAAA,EACE;AAAA,OAEK;AAEA,MAAM,4BAA4B,8BAA8B;AAAA,EACrE,YAAY,KAAU,MAA6C;AACjE,UAAM,KAAK,IAAI;AAAA,EACjB;AAAA,EAES,KACP,SACA,SAIe;AACf,UAAM,aAAa,iBAAiB,OAAO;AAC3C,QAAI,YAAY,SAAS,QAAQ;AAC/B,WAAK,YAAY,WAAW,OAAO;AACnC,aAAO,QAAQ,QAAQ;AAAA,IACzB;AACA,QAAI,YAAY,SAAS,YAAY;AACnC,aAAO,QAAQ,QAAQ;AAAA,IACzB;AACA,WAAO,MAAM,KAAK,SAAS,OAAO;AAAA,EACpC;AACF;AAMA,SAAS,iBAAiB,SAA4C;AACpE,QAAM,IAAI;AACV,MAAI,CAAC,KAAK,OAAO,MAAM,YAAY,EAAE,YAAY,GAAI,QAAO;AAE5D,UAAQ,EAAE,QAAQ;AAAA,IAChB,KAAK,cAAc;AACjB,YAAM,kBAAkB,GAAG,QAAQ;AACnC,UAAI,CAAC,gBAAiB,QAAO;AAC7B,aAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS;AAAA,UACP,QAAQ;AAAA,YACN;AAAA,YACA,cAAc,EAAE,OAAO,CAAC,EAAE;AAAA,YAC1B,YAAY,EAAE,MAAM,oBAAoB,SAAS,QAAQ;AAAA,UAC3D;AAAA,UACA,SAAS,EAAE,WAAW;AAAA;AAAA,UAEtB,IAAI,EAAE;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,IACA,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK,0BAA0B;AAC7B,aAAO,EAAE,MAAM,WAAW;AAAA,IAC5B;AAAA,IACA;AACE,aAAO;AAAA,EACX;AACF;","names":[]}

package/dist/core/client/index.d.ts

@@ -1,3 +0,0 @@
-export { HTTPClientTransport } from './http-client-transport.js';
-import '@modelcontextprotocol/sdk/types.js';
-import '@modelcontextprotocol/sdk/client/streamableHttp.js';

package/dist/core/client/index.js

@@ -1,5 +0,0 @@
-import { HTTPClientTransport } from "./http-client-transport";
-export {
-  HTTPClientTransport
-};
-//# sourceMappingURL=index.js.map

package/dist/core/client/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/core/client/index.ts"],"sourcesContent":["export { HTTPClientTransport } from \"./http-client-transport\";\n"],"mappings":"AAAA,SAAS,2BAA2B;","names":[]}

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

@@ -1,233 +0,0 @@
-import * as zod from 'zod';
-import { Client as Client$1, ClientOptions } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
-import { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import { Implementation, ListToolsRequest } from '@modelcontextprotocol/sdk/types.js';
-import { MCPConnection } from '../connection.js';
-import { HTTPClientTransport } from './http-client-transport.js';
-import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-
-/**
- * WARNNING: This is a hack to prevent schema compilation errors.
- * More info at: https://github.com/modelcontextprotocol/typescript-sdk/issues/923
- *
- * Make sure to keep this updated with the right version of the SDK.
- * https://github.com/modelcontextprotocol/typescript-sdk/blob/bf817939917277a4c59f2e19e7b44b8dd7ff140c/src/client/index.ts#L480
- */
-declare class Client extends Client$1 {
-    constructor(_clientInfo: Implementation, options?: ClientOptions);
-    listTools(params?: ListToolsRequest["params"], options?: RequestOptions): Promise<zod.objectOutputType<{
-        _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-    } & {
-        nextCursor: zod.ZodOptional<zod.ZodString>;
-    } & {
-        tools: zod.ZodArray<zod.ZodObject<zod.objectUtil.extendShape<zod.objectUtil.extendShape<{
-            name: zod.ZodString;
-            title: zod.ZodOptional<zod.ZodString>;
-        }, {
-            description: zod.ZodOptional<zod.ZodString>;
-            inputSchema: zod.ZodObject<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>;
-            outputSchema: zod.ZodOptional<zod.ZodObject<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>>;
-            annotations: zod.ZodOptional<zod.ZodObject<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, zod.ZodTypeAny, "passthrough">>>;
-            _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-        }>, {
-            icons: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>, "many">>;
-        }>, "passthrough", zod.ZodTypeAny, zod.objectOutputType<zod.objectUtil.extendShape<zod.objectUtil.extendShape<{
-            name: zod.ZodString;
-            title: zod.ZodOptional<zod.ZodString>;
-        }, {
-            description: zod.ZodOptional<zod.ZodString>;
-            inputSchema: zod.ZodObject<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>;
-            outputSchema: zod.ZodOptional<zod.ZodObject<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>>;
-            annotations: zod.ZodOptional<zod.ZodObject<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, zod.ZodTypeAny, "passthrough">>>;
-            _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-        }>, {
-            icons: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>, "many">>;
-        }>, zod.ZodTypeAny, "passthrough">, zod.objectInputType<zod.objectUtil.extendShape<zod.objectUtil.extendShape<{
-            name: zod.ZodString;
-            title: zod.ZodOptional<zod.ZodString>;
-        }, {
-            description: zod.ZodOptional<zod.ZodString>;
-            inputSchema: zod.ZodObject<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>;
-            outputSchema: zod.ZodOptional<zod.ZodObject<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                type: zod.ZodLiteral<"object">;
-                properties: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-                required: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>>;
-            annotations: zod.ZodOptional<zod.ZodObject<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                title: zod.ZodOptional<zod.ZodString>;
-                readOnlyHint: zod.ZodOptional<zod.ZodBoolean>;
-                destructiveHint: zod.ZodOptional<zod.ZodBoolean>;
-                idempotentHint: zod.ZodOptional<zod.ZodBoolean>;
-                openWorldHint: zod.ZodOptional<zod.ZodBoolean>;
-            }, zod.ZodTypeAny, "passthrough">>>;
-            _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-        }>, {
-            icons: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{
-                src: zod.ZodString;
-                mimeType: zod.ZodOptional<zod.ZodString>;
-                sizes: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
-            }, zod.ZodTypeAny, "passthrough">>, "many">>;
-        }>, zod.ZodTypeAny, "passthrough">>, "many">;
-    }, zod.ZodTypeAny, "passthrough">>;
-}
-interface ServerClient {
-    client: Client;
-    callStreamableTool: (tool: string, args: unknown) => Promise<Response>;
-}
-declare const createServerClient: (mcpServer: {
-    connection: MCPConnection;
-    name?: string;
-}, signal?: AbortSignal, extraHeaders?: Record<string, string>) => Promise<ServerClient>;
-declare const createTransport: (connection: MCPConnection, signal?: AbortSignal, extraHeaders?: Record<string, string>) => HTTPClientTransport | WebSocketClientTransport | SSEClientTransport | null;
-
-export { type ServerClient, createServerClient, createTransport };

package/dist/core/client/mcp-client.js

@@ -1,99 +0,0 @@
-import {
-  Client as BaseClient
-} from "@modelcontextprotocol/sdk/client/index.js";
-import {
-  SSEClientTransport
-} from "@modelcontextprotocol/sdk/client/sse.js";
-import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
-import {
-  ListToolsResultSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { HTTPClientTransport } from "./http-client-transport";
-class Client extends BaseClient {
-  constructor(_clientInfo, options) {
-    super(_clientInfo, options);
-  }
-  async listTools(params, options) {
-    const result = await this.request(
-      { method: "tools/list", params },
-      ListToolsResultSchema,
-      options
-    );
-    return result;
-  }
-}
-const createServerClient = async (mcpServer, signal, extraHeaders) => {
-  const transport = createTransport(mcpServer.connection, signal, extraHeaders);
-  if (!transport) {
-    throw new Error("Unknown MCP connection type");
-  }
-  const client = new Client({
-    name: mcpServer?.name ?? "MCP Client",
-    version: "1.0.0"
-  });
-  await client.connect(transport);
-  return {
-    client,
-    callStreamableTool: (tool, args) => {
-      if (mcpServer.connection.type !== "HTTP") {
-        throw new Error("HTTP connection required");
-      }
-      return fetch(mcpServer.connection.url + `/call-tool/${tool}`, {
-        method: "POST",
-        redirect: "manual",
-        body: JSON.stringify(args),
-        headers: {
-          ...extraHeaders,
-          Authorization: `Bearer ${mcpServer.connection.token}`
-        }
-      });
-    }
-  };
-};
-const createTransport = (connection, signal, extraHeaders) => {
-  if (connection.type === "Websocket") {
-    return new WebSocketClientTransport(new URL(connection.url));
-  }
-  if (connection.type !== "SSE" && connection.type !== "HTTP") {
-    return null;
-  }
-  const authHeaders = connection.token ? { authorization: `Bearer ${connection.token}` } : {};
-  const headers = {
-    ...authHeaders,
-    ...extraHeaders ?? {},
-    ..."headers" in connection ? connection.headers || {} : {}
-  };
-  if (connection.type === "SSE") {
-    const config = {
-      requestInit: { headers, signal }
-    };
-    if (connection.token) {
-      config.eventSourceInit = {
-        fetch: (req, init) => {
-          return fetch(req, {
-            ...init,
-            headers: {
-              ...headers,
-              Accept: "text/event-stream"
-            },
-            signal
-          });
-        }
-      };
-    }
-    return new SSEClientTransport(new URL(connection.url), config);
-  }
-  return new HTTPClientTransport(new URL(connection.url), {
-    requestInit: {
-      headers,
-      signal,
-      // @ts-ignore - this is a valid option for fetch
-      credentials: "include"
-    }
-  });
-};
-export {
-  createServerClient,
-  createTransport
-};
-//# sourceMappingURL=mcp-client.js.map

package/dist/core/client/mcp-client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/core/client/mcp-client.ts"],"sourcesContent":["import {\n  Client as BaseClient,\n  ClientOptions,\n} from \"@modelcontextprotocol/sdk/client/index.js\";\nimport {\n  SSEClientTransport,\n  SSEClientTransportOptions,\n} from \"@modelcontextprotocol/sdk/client/sse.js\";\nimport { WebSocketClientTransport } from \"@modelcontextprotocol/sdk/client/websocket.js\";\nimport { RequestOptions } from \"@modelcontextprotocol/sdk/shared/protocol.js\";\nimport {\n  Implementation,\n  ListToolsRequest,\n  ListToolsResultSchema,\n} from \"@modelcontextprotocol/sdk/types.js\";\nimport { MCPConnection } from \"../connection\";\nimport { HTTPClientTransport } from \"./http-client-transport\";\n\n/**\n * WARNNING: This is a hack to prevent schema compilation errors.\n * More info at: https://github.com/modelcontextprotocol/typescript-sdk/issues/923\n *\n * Make sure to keep this updated with the right version of the SDK.\n * https://github.com/modelcontextprotocol/typescript-sdk/blob/bf817939917277a4c59f2e19e7b44b8dd7ff140c/src/client/index.ts#L480\n */\nclass Client extends BaseClient {\n  constructor(_clientInfo: Implementation, options?: ClientOptions) {\n    super(_clientInfo, options);\n  }\n\n  override async listTools(\n    params?: ListToolsRequest[\"params\"],\n    options?: RequestOptions,\n  ) {\n    const result = await this.request(\n      { method: \"tools/list\", params },\n      ListToolsResultSchema,\n      options,\n    );\n\n    return result;\n  }\n}\n\nexport interface ServerClient {\n  client: Client;\n  callStreamableTool: (tool: string, args: unknown) => Promise<Response>;\n}\nexport const createServerClient = async (\n  mcpServer: { connection: MCPConnection; name?: string },\n  signal?: AbortSignal,\n  extraHeaders?: Record<string, string>,\n): Promise<ServerClient> => {\n  const transport = createTransport(mcpServer.connection, signal, extraHeaders);\n\n  if (!transport) {\n    throw new Error(\"Unknown MCP connection type\");\n  }\n\n  const client = new Client({\n    name: mcpServer?.name ?? \"MCP Client\",\n    version: \"1.0.0\",\n  });\n\n  await client.connect(transport);\n\n  return {\n    client,\n    callStreamableTool: (tool, args) => {\n      if (mcpServer.connection.type !== \"HTTP\") {\n        throw new Error(\"HTTP connection required\");\n      }\n      return fetch(mcpServer.connection.url + `/call-tool/${tool}`, {\n        method: \"POST\",\n        redirect: \"manual\",\n        body: JSON.stringify(args),\n        headers: {\n          ...extraHeaders,\n          Authorization: `Bearer ${mcpServer.connection.token}`,\n        },\n      });\n    },\n  };\n};\n\nexport const createTransport = (\n  connection: MCPConnection,\n  signal?: AbortSignal,\n  extraHeaders?: Record<string, string>,\n) => {\n  if (connection.type === \"Websocket\") {\n    return new WebSocketClientTransport(new URL(connection.url));\n  }\n\n  if (connection.type !== \"SSE\" && connection.type !== \"HTTP\") {\n    return null;\n  }\n\n  const authHeaders: Record<string, string> = connection.token\n    ? { authorization: `Bearer ${connection.token}` }\n    : {};\n\n  const headers: Record<string, string> = {\n    ...authHeaders,\n    ...(extraHeaders ?? {}),\n    ...(\"headers\" in connection ? connection.headers || {} : {}),\n  };\n\n  if (connection.type === \"SSE\") {\n    const config: SSEClientTransportOptions = {\n      requestInit: { headers, signal },\n    };\n\n    if (connection.token) {\n      config.eventSourceInit = {\n        fetch: (req, init) => {\n          return fetch(req, {\n            ...init,\n            headers: {\n              ...headers,\n              Accept: \"text/event-stream\",\n            },\n            signal,\n          });\n        },\n      };\n    }\n\n    return new SSEClientTransport(new URL(connection.url), config);\n  }\n  return new HTTPClientTransport(new URL(connection.url), {\n    requestInit: {\n      headers,\n      signal,\n      // @ts-ignore - this is a valid option for fetch\n      credentials: \"include\",\n    },\n  });\n};\n"],"mappings":"AAAA;AAAA,EACE,UAAU;AAAA,OAEL;AACP;AAAA,EACE;AAAA,OAEK;AACP,SAAS,gCAAgC;AAEzC;AAAA,EAGE;AAAA,OACK;AAEP,SAAS,2BAA2B;AASpC,MAAM,eAAe,WAAW;AAAA,EAC9B,YAAY,aAA6B,SAAyB;AAChE,UAAM,aAAa,OAAO;AAAA,EAC5B;AAAA,EAEA,MAAe,UACb,QACA,SACA;AACA,UAAM,SAAS,MAAM,KAAK;AAAA,MACxB,EAAE,QAAQ,cAAc,OAAO;AAAA,MAC/B;AAAA,MACA;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AAMO,MAAM,qBAAqB,OAChC,WACA,QACA,iBAC0B;AAC1B,QAAM,YAAY,gBAAgB,UAAU,YAAY,QAAQ,YAAY;AAE5E,MAAI,CAAC,WAAW;AACd,UAAM,IAAI,MAAM,6BAA6B;AAAA,EAC/C;AAEA,QAAM,SAAS,IAAI,OAAO;AAAA,IACxB,MAAM,WAAW,QAAQ;AAAA,IACzB,SAAS;AAAA,EACX,CAAC;AAED,QAAM,OAAO,QAAQ,SAAS;AAE9B,SAAO;AAAA,IACL;AAAA,IACA,oBAAoB,CAAC,MAAM,SAAS;AAClC,UAAI,UAAU,WAAW,SAAS,QAAQ;AACxC,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC5C;AACA,aAAO,MAAM,UAAU,WAAW,MAAM,cAAc,IAAI,IAAI;AAAA,QAC5D,QAAQ;AAAA,QACR,UAAU;AAAA,QACV,MAAM,KAAK,UAAU,IAAI;AAAA,QACzB,SAAS;AAAA,UACP,GAAG;AAAA,UACH,eAAe,UAAU,UAAU,WAAW,KAAK;AAAA,QACrD;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEO,MAAM,kBAAkB,CAC7B,YACA,QACA,iBACG;AACH,MAAI,WAAW,SAAS,aAAa;AACnC,WAAO,IAAI,yBAAyB,IAAI,IAAI,WAAW,GAAG,CAAC;AAAA,EAC7D;AAEA,MAAI,WAAW,SAAS,SAAS,WAAW,SAAS,QAAQ;AAC3D,WAAO;AAAA,EACT;AAEA,QAAM,cAAsC,WAAW,QACnD,EAAE,eAAe,UAAU,WAAW,KAAK,GAAG,IAC9C,CAAC;AAEL,QAAM,UAAkC;AAAA,IACtC,GAAG;AAAA,IACH,GAAI,gBAAgB,CAAC;AAAA,IACrB,GAAI,aAAa,aAAa,WAAW,WAAW,CAAC,IAAI,CAAC;AAAA,EAC5D;AAEA,MAAI,WAAW,SAAS,OAAO;AAC7B,UAAM,SAAoC;AAAA,MACxC,aAAa,EAAE,SAAS,OAAO;AAAA,IACjC;AAEA,QAAI,WAAW,OAAO;AACpB,aAAO,kBAAkB;AAAA,QACvB,OAAO,CAAC,KAAK,SAAS;AACpB,iBAAO,MAAM,KAAK;AAAA,YAChB,GAAG;AAAA,YACH,SAAS;AAAA,cACP,GAAG;AAAA,cACH,QAAQ;AAAA,YACV;AAAA,YACA;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAEA,WAAO,IAAI,mBAAmB,IAAI,IAAI,WAAW,GAAG,GAAG,MAAM;AAAA,EAC/D;AACA,SAAO,IAAI,oBAAoB,IAAI,IAAI,WAAW,GAAG,GAAG;AAAA,IACtD,aAAa;AAAA,MACX;AAAA,MACA;AAAA;AAAA,MAEA,aAAa;AAAA,IACf;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/core/client/mcp.d.ts

@@ -1,3 +0,0 @@
-import 'zod/v3';
-import '../connection.js';
-export { C as CreateStubAPIOptions, F as FetchOptions, J as JSONSchemaToZodConverter, b as MCPClient, M as MCPClientFetchStub, d as MCPClientRaw, c as MCPClientStub, a as ToolBinder, e as createMCPFetchStub, i as isStreamableToolBinder } from '../../index-D0aUdNls.js';

package/dist/core/client/mcp.js

@@ -1,29 +0,0 @@
-import { createMCPClientProxy } from "./proxy";
-const MCPClient = new Proxy(
-  {},
-  {
-    get(_, name) {
-      if (name === "toJSON") {
-        return null;
-      }
-      if (name === "forConnection") {
-        return (connection) => createMCPFetchStub({
-          connection
-        });
-      }
-      return global[name];
-    }
-  }
-);
-const isStreamableToolBinder = (toolBinder) => {
-  return toolBinder.streamable === true;
-};
-function createMCPFetchStub(options) {
-  return createMCPClientProxy(options);
-}
-export {
-  MCPClient,
-  createMCPFetchStub,
-  isStreamableToolBinder
-};
-//# sourceMappingURL=mcp.js.map

package/dist/core/client/mcp.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/core/client/mcp.ts"],"sourcesContent":["/* oxlint-disable no-explicit-any */\nimport { z } from \"zod/v3\";\nimport type { MCPConnection } from \"../connection\";\nimport { createMCPClientProxy } from \"./proxy\";\n\nexport interface FetchOptions extends RequestInit {\n  path?: string;\n  segments?: string[];\n}\n\n// Default fetcher instance with API_SERVER_URL and API_HEADERS\nexport const MCPClient = new Proxy(\n  {} as {\n    forConnection: <TDefinition extends readonly ToolBinder[]>(\n      connection: MCPConnection,\n    ) => MCPClientFetchStub<TDefinition>;\n  },\n  {\n    get(_, name) {\n      if (name === \"toJSON\") {\n        return null;\n      }\n\n      if (name === \"forConnection\") {\n        return <TDefinition extends readonly ToolBinder[]>(\n          connection: MCPConnection,\n        ) =>\n          createMCPFetchStub<TDefinition>({\n            connection,\n          });\n      }\n      return global[name as keyof typeof global];\n    },\n  },\n);\n\nimport type { ToolBinder } from \"../binder\";\nexport type { ToolBinder };\n\nexport const isStreamableToolBinder = (\n  toolBinder: ToolBinder,\n): toolBinder is ToolBinder<string, any, any, true> => {\n  return toolBinder.streamable === true;\n};\nexport type MCPClientStub<TDefinition extends readonly ToolBinder[]> = {\n  [K in TDefinition[number] as K[\"name\"]]: K extends ToolBinder<\n    string,\n    infer TInput,\n    infer TReturn\n  >\n    ? (params: TInput, init?: RequestInit) => Promise<TReturn>\n    : never;\n};\n\nexport type MCPClientFetchStub<TDefinition extends readonly ToolBinder[]> = {\n  [K in TDefinition[number] as K[\"name\"]]: K[\"streamable\"] extends true\n    ? K extends ToolBinder<string, infer TInput, any, true>\n      ? (params: TInput, init?: RequestInit) => Promise<Response>\n      : never\n    : K extends ToolBinder<string, infer TInput, infer TReturn, any>\n      ? (params: TInput, init?: RequestInit) => Promise<Awaited<TReturn>>\n      : never;\n};\n\nexport interface MCPClientRaw {\n  callTool: (tool: string, args: unknown) => Promise<unknown>;\n  listTools: () => Promise<\n    {\n      name: string;\n      inputSchema: any;\n      outputSchema?: any;\n      description: string;\n    }[]\n  >;\n}\nexport type JSONSchemaToZodConverter = (jsonSchema: any) => z.ZodTypeAny;\nexport interface CreateStubAPIOptions {\n  connection: MCPConnection;\n  streamable?: Record<string, boolean>;\n  debugId?: () => string;\n  getErrorByStatusCode?: (\n    statusCode: number,\n    message?: string,\n    traceId?: string,\n    errorObject?: unknown,\n  ) => Error;\n}\n\nexport function createMCPFetchStub<TDefinition extends readonly ToolBinder[]>(\n  options: CreateStubAPIOptions,\n): MCPClientFetchStub<TDefinition> {\n  return createMCPClientProxy<MCPClientFetchStub<TDefinition>>(options);\n}\n"],"mappings":"AAGA,SAAS,4BAA4B;AAQ9B,MAAM,YAAY,IAAI;AAAA,EAC3B,CAAC;AAAA,EAKD;AAAA,IACE,IAAI,GAAG,MAAM;AACX,UAAI,SAAS,UAAU;AACrB,eAAO;AAAA,MACT;AAEA,UAAI,SAAS,iBAAiB;AAC5B,eAAO,CACL,eAEA,mBAAgC;AAAA,UAC9B;AAAA,QACF,CAAC;AAAA,MACL;AACA,aAAO,OAAO,IAA2B;AAAA,IAC3C;AAAA,EACF;AACF;AAKO,MAAM,yBAAyB,CACpC,eACqD;AACrD,SAAO,WAAW,eAAe;AACnC;AA6CO,SAAS,mBACd,SACiC;AACjC,SAAO,qBAAsD,OAAO;AACtE;","names":[]}

package/dist/core/client/proxy.d.ts

@@ -1,10 +0,0 @@
-import { C as CreateStubAPIOptions } from '../../index-D0aUdNls.js';
-import 'zod/v3';
-import '../connection.js';
-
-/**
- * The base fetcher used to fetch the MCP from API.
- */
-declare function createMCPClientProxy<T extends Record<string, unknown>>(options: CreateStubAPIOptions): T;
-
-export { createMCPClientProxy };