@cuylabs/agent-core 0.11.0 → 0.13.0

package/dist/chunk-US7S4FYW.js

@@ -0,0 +1,610 @@
+import {
+  silentLogger
+} from "./chunk-S6AKEPAX.js";
+
+// src/mcp/manager.ts
+import {
+  dynamicTool,
+  jsonSchema
+} from "ai";
+
+// src/mcp/modules.ts
+var mcpClientModule;
+var stdioModule;
+var streamableHttpModule;
+var sseModule;
+async function getMcpClientModule() {
+  if (!mcpClientModule) {
+    try {
+      mcpClientModule = await import("@modelcontextprotocol/sdk/client/index.js");
+    } catch {
+      throw new Error(
+        "MCP support requires @modelcontextprotocol/sdk. Install it with: npm install @modelcontextprotocol/sdk"
+      );
+    }
+  }
+  return mcpClientModule;
+}
+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;
+}
+async function getStreamableHttpClientModule() {
+  if (!streamableHttpModule) {
+    try {
+      streamableHttpModule = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    } catch {
+      throw new Error(
+        "HTTP MCP transport requires @modelcontextprotocol/sdk. Install it with: npm install @modelcontextprotocol/sdk"
+      );
+    }
+  }
+  return streamableHttpModule;
+}
+async function getSseClientModule() {
+  if (!sseModule) {
+    try {
+      sseModule = await import("@modelcontextprotocol/sdk/client/sse.js");
+    } catch {
+      throw new Error(
+        "SSE MCP transport requires @modelcontextprotocol/sdk. Install it with: npm install @modelcontextprotocol/sdk"
+      );
+    }
+  }
+  return sseModule;
+}
+
+// src/mcp/manager.ts
+var CLIENT_VERSION = "1.0.0";
+function mcpToModelOutput(options) {
+  const result = options.output;
+  if (!("content" in result) || !Array.isArray(result.content)) {
+    return {
+      type: "json",
+      value: result
+    };
+  }
+  return {
+    type: "content",
+    value: result.content.map((part) => {
+      if (part.type === "text" && "text" in part) {
+        return { type: "text", text: part.text };
+      }
+      if (part.type === "image" && "data" in part && "mimeType" in part) {
+        return {
+          type: "file-data",
+          data: part.data,
+          mediaType: part.mimeType
+        };
+      }
+      return {
+        type: "text",
+        text: JSON.stringify(part)
+      };
+    })
+  };
+}
+function toolToAiSdkTool(options) {
+  const { client, tool } = options;
+  const inputSchema = {
+    ...tool.inputSchema,
+    properties: tool.inputSchema.properties ?? {},
+    additionalProperties: false
+  };
+  return dynamicTool({
+    description: tool.description,
+    ...tool.title ? { title: tool.title } : {},
+    inputSchema: jsonSchema(inputSchema),
+    execute: async (params) => {
+      return client.callTool({
+        name: tool.name,
+        arguments: params
+      });
+    },
+    toModelOutput: mcpToModelOutput
+  });
+}
+var DefaultMCPManager = class {
+  config;
+  connections = /* @__PURE__ */ new Map();
+  log;
+  toolCache;
+  resourceCache;
+  resourceTemplateCache;
+  promptCache;
+  constructor(config, logger) {
+    this.config = config;
+    this.log = logger?.child("mcp") ?? silentLogger;
+  }
+  async connect() {
+    if (this.connections.size > 0) {
+      await this.close();
+    }
+    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.invalidateCaches();
+    return results;
+  }
+  async getTools() {
+    await this.ensureInitialized();
+    if (this.toolCache) {
+      return this.toolCache;
+    }
+    const allTools = {};
+    await Promise.all(
+      Array.from(this.connections.entries()).map(
+        async ([serverName, connection]) => {
+          if (connection.status.status !== "connected" || !connection.client) {
+            return;
+          }
+          try {
+            const tools = await this.listAllTools(
+              connection.client,
+              connection.config
+            );
+            for (const tool of tools) {
+              allTools[`${serverName}__${tool.name}`] = toolToAiSdkTool({
+                serverName,
+                client: connection.client,
+                tool
+              });
+            }
+          } catch (error) {
+            this.log.warn(`Failed to get tools from ${serverName}`, {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
+      )
+    );
+    this.toolCache = allTools;
+    return allTools;
+  }
+  async listResources() {
+    await this.ensureInitialized();
+    if (this.resourceCache) {
+      return this.resourceCache;
+    }
+    const resources = await this.collectAcrossServers({
+      fetch: (client, config) => this.listAllResources(client, config),
+      map: (server, resource) => ({ server, ...resource }),
+      logLabel: "resources"
+    });
+    this.resourceCache = resources;
+    return resources;
+  }
+  async listResourceTemplates() {
+    await this.ensureInitialized();
+    if (this.resourceTemplateCache) {
+      return this.resourceTemplateCache;
+    }
+    const templates = await this.collectAcrossServers({
+      fetch: (client, config) => this.listAllResourceTemplates(client, config),
+      map: (server, template) => ({ server, ...template }),
+      logLabel: "resource templates"
+    });
+    this.resourceTemplateCache = templates;
+    return templates;
+  }
+  async readResource(serverName, uri) {
+    const connection = await this.getConnectedConnection(serverName);
+    return connection.client.readResource(
+      { uri },
+      this.requestOptions(connection.config)
+    );
+  }
+  async listPrompts() {
+    await this.ensureInitialized();
+    if (this.promptCache) {
+      return this.promptCache;
+    }
+    const prompts = await this.collectAcrossServers({
+      fetch: (client, config) => this.listAllPrompts(client, config),
+      map: (server, prompt) => ({ server, ...prompt }),
+      logLabel: "prompts"
+    });
+    this.promptCache = prompts;
+    return prompts;
+  }
+  async getPrompt(serverName, name, args) {
+    const connection = await this.getConnectedConnection(serverName);
+    return connection.client.getPrompt(
+      { name, arguments: args },
+      this.requestOptions(connection.config)
+    );
+  }
+  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.invalidateCaches();
+  }
+  isConnected() {
+    for (const connection of this.connections.values()) {
+      if (connection.status.status === "connected") {
+        return true;
+      }
+    }
+    return false;
+  }
+  invalidateCaches() {
+    this.toolCache = void 0;
+    this.resourceCache = void 0;
+    this.resourceTemplateCache = void 0;
+    this.promptCache = void 0;
+  }
+  async ensureInitialized() {
+    if (this.connections.size === 0) {
+      await this.connect();
+    }
+  }
+  requestOptions(config) {
+    return { timeout: config.timeout ?? 3e4 };
+  }
+  async collectAcrossServers(options) {
+    const collected = [];
+    await Promise.all(
+      Array.from(this.connections.entries()).map(
+        async ([serverName, connection]) => {
+          if (connection.status.status !== "connected" || !connection.client) {
+            return;
+          }
+          try {
+            const items = await options.fetch(
+              connection.client,
+              connection.config
+            );
+            for (const item of items) {
+              collected.push(options.map(serverName, item));
+            }
+          } catch (error) {
+            this.log.warn(
+              `Failed to get ${options.logLabel} from ${serverName}`,
+              {
+                error: error instanceof Error ? error.message : String(error)
+              }
+            );
+          }
+        }
+      )
+    );
+    return collected;
+  }
+  async getConnectedConnection(serverName) {
+    await this.ensureInitialized();
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      throw new Error(`MCP server "${serverName}" is not configured.`);
+    }
+    if (connection.status.status !== "connected" || !connection.client) {
+      const reason = connection.status.status === "error" ? connection.status.error : connection.status.status;
+      throw new Error(
+        `MCP server "${serverName}" is not connected${reason ? `: ${reason}` : "."}`
+      );
+    }
+    return { client: connection.client, config: connection.config };
+  }
+  async collectPaginated(options) {
+    const items = [];
+    let cursor;
+    do {
+      const page = await options.fetchPage(cursor);
+      const batch = page[options.itemsKey];
+      if (Array.isArray(batch)) {
+        items.push(...batch);
+      }
+      cursor = page.nextCursor;
+    } while (cursor);
+    return items;
+  }
+  listAllTools(client, config) {
+    return this.collectPaginated({
+      fetchPage: (cursor) => client.listTools(
+        cursor ? { cursor } : void 0,
+        this.requestOptions(config)
+      ),
+      itemsKey: "tools"
+    });
+  }
+  listAllResources(client, config) {
+    return this.collectPaginated({
+      fetchPage: (cursor) => client.listResources(
+        cursor ? { cursor } : void 0,
+        this.requestOptions(config)
+      ),
+      itemsKey: "resources"
+    });
+  }
+  listAllResourceTemplates(client, config) {
+    return this.collectPaginated({
+      fetchPage: (cursor) => client.listResourceTemplates(
+        cursor ? { cursor } : void 0,
+        this.requestOptions(config)
+      ),
+      itemsKey: "resourceTemplates"
+    });
+  }
+  listAllPrompts(client, config) {
+    return this.collectPaginated({
+      fetchPage: (cursor) => client.listPrompts(
+        cursor ? { cursor } : void 0,
+        this.requestOptions(config)
+      ),
+      itemsKey: "prompts"
+    });
+  }
+  async createClient(name, config) {
+    const { Client } = await getMcpClientModule();
+    const client = new Client(
+      {
+        name: config.name ?? name,
+        version: CLIENT_VERSION
+      },
+      {
+        ...config.capabilities ? { capabilities: config.capabilities } : {},
+        listChanged: {
+          tools: {
+            autoRefresh: false,
+            onChanged: () => this.invalidateCaches()
+          },
+          prompts: {
+            autoRefresh: false,
+            onChanged: () => this.invalidateCaches()
+          },
+          resources: {
+            autoRefresh: false,
+            onChanged: () => this.invalidateCaches()
+          }
+        }
+      }
+    );
+    if (config.onUncaughtError) {
+      client.onerror = (error) => config.onUncaughtError?.(error);
+    }
+    const transport = await this.createTransport(config);
+    if (config.onUncaughtError) {
+      transport.onerror = (error) => config.onUncaughtError?.(error);
+    }
+    await client.connect(transport, this.requestOptions(config));
+    const tools = await this.listAllTools(client, config);
+    return { client, toolCount: tools.length };
+  }
+  async createTransport(config) {
+    if (config.transport === "stdio") {
+      const { StdioClientTransport } = await getStdioClientModule();
+      return new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: config.env,
+        cwd: config.cwd
+      });
+    }
+    const requestInit = {
+      ...config.headers ? { headers: config.headers } : {},
+      ...config.redirect ? { redirect: config.redirect } : {}
+    };
+    if (config.transport === "http") {
+      const { StreamableHTTPClientTransport } = await getStreamableHttpClientModule();
+      return new StreamableHTTPClientTransport(new URL(config.url), {
+        ...config.authProvider ? { authProvider: config.authProvider } : {},
+        requestInit,
+        ...config.fetch ? { fetch: config.fetch } : {}
+      });
+    }
+    const { SSEClientTransport } = await getSseClientModule();
+    return new SSEClientTransport(new URL(config.url), {
+      ...config.authProvider ? { authProvider: config.authProvider } : {},
+      requestInit,
+      ...config.fetch ? { fetch: config.fetch } : {}
+    });
+  }
+};
+
+// src/mcp/auth.ts
+var ClientCredentialsProvider = class {
+  _tokens;
+  _expiresAt;
+  _options;
+  constructor(options) {
+    this._options = options;
+  }
+  // ── OAuthClientProvider: required ─────────────────────────────────────────
+  get redirectUrl() {
+    return void 0;
+  }
+  get clientMetadata() {
+    return {
+      redirect_uris: [],
+      grant_types: ["client_credentials"],
+      token_endpoint_auth_method: "client_secret_basic",
+      scope: this._options.scope
+    };
+  }
+  clientInformation() {
+    return {
+      client_id: this._options.clientId,
+      client_secret: this._options.clientSecret
+    };
+  }
+  saveClientInformation() {
+  }
+  async tokens() {
+    const bufferMs = (this._options.expiryBufferSeconds ?? 60) * 1e3;
+    const hasValid = this._tokens !== void 0 && (this._expiresAt === void 0 || Date.now() < this._expiresAt - bufferMs);
+    if (hasValid) {
+      return this._tokens;
+    }
+    return this._fetchTokens();
+  }
+  async saveTokens(tokens) {
+    this._tokens = tokens;
+    this._expiresAt = tokens.expires_in !== void 0 ? Date.now() + tokens.expires_in * 1e3 : void 0;
+  }
+  redirectToAuthorization(_authorizationUrl) {
+    throw new Error(
+      "ClientCredentialsProvider: redirectToAuthorization() was called unexpectedly. Verify that the tokenUrl, clientId, clientSecret, and scope are correct."
+    );
+  }
+  saveCodeVerifier() {
+  }
+  codeVerifier() {
+    throw new Error(
+      "ClientCredentialsProvider: codeVerifier() is not used for client_credentials."
+    );
+  }
+  prepareTokenRequest(scope) {
+    const params = new URLSearchParams({ grant_type: "client_credentials" });
+    const effectiveScope = scope ?? this._options.scope;
+    if (effectiveScope) params.set("scope", effectiveScope);
+    return params;
+  }
+  addClientAuthentication(headers) {
+    const encoded = `${encodeURIComponent(this._options.clientId)}:${encodeURIComponent(this._options.clientSecret)}`;
+    headers.set("Authorization", `Basic ${btoa(encoded)}`);
+  }
+  // ── OAuthClientProvider: optional ─────────────────────────────────────────
+  invalidateCredentials(scope) {
+    if (scope === "all" || scope === "tokens") {
+      this._tokens = void 0;
+      this._expiresAt = void 0;
+    }
+  }
+  // ── Private ────────────────────────────────────────────────────────────────
+  async _fetchTokens() {
+    const { tokenUrl, scope } = this._options;
+    const params = this.prepareTokenRequest(scope);
+    const headers = new Headers({
+      "Content-Type": "application/x-www-form-urlencoded"
+    });
+    this.addClientAuthentication(headers);
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers,
+      body: params.toString()
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(
+        `ClientCredentialsProvider: token fetch failed (HTTP ${response.status}): ${body}`
+      );
+    }
+    const json = await response.json();
+    const tokens = {
+      access_token: String(json.access_token),
+      token_type: String(json.token_type ?? "bearer"),
+      expires_in: typeof json.expires_in === "number" ? json.expires_in : void 0,
+      scope: typeof json.scope === "string" ? json.scope : void 0,
+      refresh_token: typeof json.refresh_token === "string" ? json.refresh_token : void 0
+    };
+    await this.saveTokens(tokens);
+    return tokens;
+  }
+};
+
+// 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
+  };
+}
+function serviceAccountServer(url, credentials, options) {
+  return {
+    transport: "http",
+    url,
+    authProvider: new ClientCredentialsProvider(credentials),
+    ...options
+  };
+}
+
+export {
+  ClientCredentialsProvider,
+  createMCPManager,
+  stdioServer,
+  httpServer,
+  sseServer,
+  serviceAccountServer
+};