@cuylabs/agent-core 0.10.0 → 0.12.0

package/dist/chunk-ROTGCYDW.js

@@ -1,221 +0,0 @@
-import {
-  silentLogger
-} from "./chunk-T4UIX5D7.js";
-
-// src/mcp/modules.ts
-var mcpModule;
-var stdioModule;
-async function getMcpSdkModule() {
-  if (!mcpModule) {
-    try {
-      mcpModule = await import("@ai-sdk/mcp");
-    } catch {
-      throw new Error(
-        "MCP support requires @ai-sdk/mcp. Install it with: npm install @ai-sdk/mcp"
-      );
-    }
-  }
-  return mcpModule;
-}
-async function getStdioClientModule() {
-  if (!stdioModule) {
-    try {
-      stdioModule = await import("@modelcontextprotocol/sdk/client/stdio.js");
-    } catch {
-      throw new Error(
-        "Stdio MCP transport requires @modelcontextprotocol/sdk. Install it with: npm install @modelcontextprotocol/sdk"
-      );
-    }
-  }
-  return stdioModule;
-}
-
-// src/mcp/manager.ts
-var DefaultMCPManager = class {
-  config;
-  connections = /* @__PURE__ */ new Map();
-  log;
-  toolCache;
-  constructor(config, logger) {
-    this.config = config;
-    this.log = logger?.child("mcp") ?? silentLogger;
-  }
-  async connect() {
-    const results = /* @__PURE__ */ new Map();
-    const connectPromises = Object.entries(this.config).map(
-      async ([name, serverConfig]) => {
-        if (serverConfig.enabled === false) {
-          const status = { status: "disabled" };
-          this.connections.set(name, {
-            client: void 0,
-            config: serverConfig,
-            status
-          });
-          results.set(name, status);
-          return;
-        }
-        results.set(name, { status: "connecting" });
-        try {
-          const { client, toolCount } = await this.createClient(name, serverConfig);
-          const status = { status: "connected", toolCount };
-          this.connections.set(name, { client, config: serverConfig, status });
-          results.set(name, status);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          const status = {
-            status: "error",
-            error: errorMessage
-          };
-          results.set(name, status);
-          this.connections.set(name, {
-            client: void 0,
-            config: serverConfig,
-            status
-          });
-        }
-      }
-    );
-    await Promise.all(connectPromises);
-    this.toolCache = void 0;
-    return results;
-  }
-  async getTools() {
-    if (this.toolCache) {
-      return this.toolCache;
-    }
-    const allTools = {};
-    const toolPromises = Array.from(this.connections.entries()).map(
-      async ([serverName, connection]) => {
-        if (connection.status.status !== "connected" || !connection.client) {
-          return;
-        }
-        try {
-          const tools = await connection.client.tools();
-          for (const [toolName, tool] of Object.entries(tools)) {
-            allTools[`${serverName}__${toolName}`] = tool;
-          }
-        } catch (error) {
-          this.log.warn(`Failed to get tools from ${serverName}`, {
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    );
-    await Promise.all(toolPromises);
-    this.toolCache = allTools;
-    return allTools;
-  }
-  getStatus(serverName) {
-    const connection = this.connections.get(serverName);
-    return connection?.status ?? { status: "disconnected" };
-  }
-  getAllStatus() {
-    const status = /* @__PURE__ */ new Map();
-    for (const [name, connection] of this.connections) {
-      status.set(name, connection.status);
-    }
-    return status;
-  }
-  async close() {
-    const closePromises = Array.from(this.connections.values()).map(
-      async (connection) => {
-        if (connection.client) {
-          try {
-            await connection.client.close();
-          } catch {
-          }
-        }
-      }
-    );
-    await Promise.all(closePromises);
-    this.connections.clear();
-    this.toolCache = void 0;
-  }
-  isConnected() {
-    for (const connection of this.connections.values()) {
-      if (connection.status.status === "connected") {
-        return true;
-      }
-    }
-    return false;
-  }
-  async createClient(name, config) {
-    const { createMCPClient } = await getMcpSdkModule();
-    const timeout = config.timeout ?? 3e4;
-    const withTimeout = (promise, ms) => {
-      return Promise.race([
-        promise,
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error(`MCP connection timeout after ${ms}ms`)),
-            ms
-          )
-        )
-      ]);
-    };
-    const clientOptions = {
-      name: config.name ?? name,
-      ...config.onUncaughtError ? { onUncaughtError: config.onUncaughtError } : {},
-      ...config.capabilities ? { capabilities: config.capabilities } : {}
-    };
-    if (config.transport === "stdio") {
-      const { StdioClientTransport } = await getStdioClientModule();
-      const transport = new StdioClientTransport({
-        command: config.command,
-        args: config.args,
-        env: config.env,
-        cwd: config.cwd
-      });
-      const client2 = await createMCPClient({ transport, ...clientOptions });
-      const tools2 = await withTimeout(client2.tools(), timeout);
-      return { client: client2, toolCount: Object.keys(tools2).length };
-    }
-    const client = await createMCPClient({
-      transport: {
-        type: config.transport,
-        url: config.url,
-        headers: config.headers,
-        ...config.authProvider ? { authProvider: config.authProvider } : {},
-        ...config.redirect ? { redirect: config.redirect } : {},
-        ...config.fetch ? { fetch: config.fetch } : {}
-      },
-      ...clientOptions
-    });
-    const tools = await withTimeout(client.tools(), timeout);
-    return { client, toolCount: Object.keys(tools).length };
-  }
-};
-
-// src/mcp/factories.ts
-function createMCPManager(config) {
-  return new DefaultMCPManager(config);
-}
-function stdioServer(command, args, options) {
-  return {
-    transport: "stdio",
-    command,
-    args,
-    ...options
-  };
-}
-function httpServer(url, options) {
-  return {
-    transport: "http",
-    url,
-    ...options
-  };
-}
-function sseServer(url, options) {
-  return {
-    transport: "sse",
-    url,
-    ...options
-  };
-}
-
-export {
-  createMCPManager,
-  stdioServer,
-  httpServer,
-  sseServer
-};