agents 0.0.0-ecf8926 → 0.0.0-ed3f94d

package/dist/{chunk-DS7BJNPH.js → chunk-3OT2NNEW.js}

@@ -1,15 +1,72 @@
 // src/mcp/client.ts
 import { jsonSchema } from "ai";
-import { nanoid } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
+
+// src/core/events.ts
+function toDisposable(fn) {
+  return { dispose: fn };
+}
+var DisposableStore = class {
+  constructor() {
+    this._items = [];
+  }
+  add(d) {
+    this._items.push(d);
+    return d;
+  }
+  dispose() {
+    while (this._items.length) {
+      try {
+        this._items.pop().dispose();
+      } catch {
+      }
+    }
+  }
+};
+var Emitter = class {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Set();
+    this.event = (listener) => {
+      this._listeners.add(listener);
+      return toDisposable(() => this._listeners.delete(listener));
+    };
+  }
+  fire(data) {
+    for (const listener of [...this._listeners]) {
+      try {
+        listener(data);
+      } catch (err) {
+        console.error("Emitter listener error:", err);
+      }
+    }
+  }
+  dispose() {
+    this._listeners.clear();
+  }
+};
 
 // src/mcp/client-connection.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import {
+  ElicitRequestSchema,
   PromptListChangedNotificationSchema,
   ResourceListChangedNotificationSchema,
-  ToolListChangedNotificationSchema,
-  ElicitRequestSchema
+  ToolListChangedNotificationSchema
 } from "@modelcontextprotocol/sdk/types.js";
+import { nanoid } from "nanoid";
+
+// src/mcp/errors.ts
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isUnauthorized(error) {
+  const msg = toErrorMessage(error);
+  return msg.includes("Unauthorized") || msg.includes("401");
+}
+function isTransportNotImplemented(error) {
+  const msg = toErrorMessage(error);
+  return msg.includes("404") || msg.includes("405") || msg.includes("Not Implemented") || msg.includes("not implemented");
+}
 
 // src/mcp/sse-edge.ts
 import {
@@ -118,6 +175,8 @@ var MCPClientConnection = class {
     this.prompts = [];
     this.resources = [];
     this.resourceTemplates = [];
+    this._onObservabilityEvent = new Emitter();
+    this.onObservabilityEvent = this._onObservabilityEvent.event;
     const clientOptions = {
       ...options.client,
       capabilities: {
@@ -130,23 +189,112 @@ var MCPClientConnection = class {
   /**
    * Initialize a client connection
    *
-   * @param code Optional OAuth code to initialize the connection with if auth hasn't been initialized
    * @returns
    */
-  async init(code) {
+  async init() {
+    const transportType = this.options.transport.type;
+    if (!transportType) {
+      throw new Error("Transport type must be specified");
+    }
     try {
-      const transportType = this.options.transport.type || "streamable-http";
-      await this.tryConnect(transportType, code);
+      await this.tryConnect(transportType);
     } catch (e) {
-      if (e.toString().includes("Unauthorized")) {
+      if (isUnauthorized(e)) {
         this.connectionState = "authenticating";
         return;
       }
+      this._onObservabilityEvent.fire({
+        type: "mcp:client:connect",
+        displayMessage: `Connection initialization failed for ${this.url.toString()}`,
+        payload: {
+          url: this.url.toString(),
+          transport: transportType,
+          state: this.connectionState,
+          error: toErrorMessage(e)
+        },
+        timestamp: Date.now(),
+        id: nanoid()
+      });
       this.connectionState = "failed";
+      return;
+    }
+    await this.discoverAndRegister();
+  }
+  /**
+   * Finish OAuth by probing transports based on configured type.
+   * - Explicit: finish on that transport
+   * - Auto: try streamable-http, then sse on 404/405/Not Implemented
+   */
+  async finishAuthProbe(code) {
+    if (!this.options.transport.authProvider) {
+      throw new Error("No auth provider configured");
+    }
+    const configuredType = this.options.transport.type;
+    if (!configuredType) {
+      throw new Error("Transport type must be specified");
+    }
+    const finishAuth = async (base) => {
+      const transport = this.getTransport(base);
+      await transport.finishAuth(code);
+    };
+    if (configuredType === "sse" || configuredType === "streamable-http") {
+      await finishAuth(configuredType);
+      return;
+    }
+    try {
+      await finishAuth("streamable-http");
+    } catch (e) {
+      if (isTransportNotImplemented(e)) {
+        await finishAuth("sse");
+        return;
+      }
       throw e;
     }
+  }
+  /**
+   * Complete OAuth authorization
+   */
+  async completeAuthorization(code) {
+    if (this.connectionState !== "authenticating") {
+      throw new Error(
+        "Connection must be in authenticating state to complete authorization"
+      );
+    }
+    try {
+      await this.finishAuthProbe(code);
+      this.connectionState = "connecting";
+    } catch (error) {
+      this.connectionState = "failed";
+      throw error;
+    }
+  }
+  /**
+   * Establish connection after successful authorization
+   */
+  async establishConnection() {
+    if (this.connectionState !== "connecting") {
+      throw new Error(
+        "Connection must be in connecting state to establish connection"
+      );
+    }
+    try {
+      const transportType = this.options.transport.type;
+      if (!transportType) {
+        throw new Error("Transport type must be specified");
+      }
+      await this.tryConnect(transportType);
+      await this.discoverAndRegister();
+    } catch (error) {
+      this.connectionState = "failed";
+      throw error;
+    }
+  }
+  /**
+   * Discover server capabilities and register tools, resources, prompts, and templates
+   */
+  async discoverAndRegister() {
     this.connectionState = "discovering";
-    this.serverCapabilities = await this.client.getServerCapabilities();
+    this.serverCapabilities = this.client.getServerCapabilities();
     if (!this.serverCapabilities) {
       throw new Error("The MCP Server failed to return server capabilities");
     }
@@ -172,7 +320,18 @@ var MCPClientConnection = class {
     ];
     for (const { name, result } of operations) {
       if (result.status === "rejected") {
-        console.error(`Failed to initialize ${name}:`, result.reason);
+        const url = this.url.toString();
+        this._onObservabilityEvent.fire({
+          type: "mcp:client:discover",
+          displayMessage: `Failed to discover ${name} for ${url}`,
+          payload: {
+            url,
+            capability: name,
+            error: result.reason
+          },
+          timestamp: Date.now(),
+          id: nanoid()
+        });
       }
     }
     this.instructions = instructionsResult.status === "fulfilled" ? instructionsResult.value : void 0;
@@ -239,7 +398,7 @@ var MCPClientConnection = class {
     do {
       toolsResult = await this.client.listTools({
         cursor: toolsResult.nextCursor
-      }).catch(capabilityErrorHandler({ tools: [] }, "tools/list"));
+      }).catch(this._capabilityErrorHandler({ tools: [] }, "tools/list"));
       toolsAgg = toolsAgg.concat(toolsResult.tools);
     } while (toolsResult.nextCursor);
     return toolsAgg;
@@ -250,7 +409,9 @@ var MCPClientConnection = class {
     do {
       resourcesResult = await this.client.listResources({
         cursor: resourcesResult.nextCursor
-      }).catch(capabilityErrorHandler({ resources: [] }, "resources/list"));
+      }).catch(
+        this._capabilityErrorHandler({ resources: [] }, "resources/list")
+      );
       resourcesAgg = resourcesAgg.concat(resourcesResult.resources);
     } while (resourcesResult.nextCursor);
     return resourcesAgg;
@@ -261,7 +422,7 @@ var MCPClientConnection = class {
     do {
       promptsResult = await this.client.listPrompts({
         cursor: promptsResult.nextCursor
-      }).catch(capabilityErrorHandler({ prompts: [] }, "prompts/list"));
+      }).catch(this._capabilityErrorHandler({ prompts: [] }, "prompts/list"));
       promptsAgg = promptsAgg.concat(promptsResult.prompts);
     } while (promptsResult.nextCursor);
     return promptsAgg;
@@ -275,7 +436,7 @@ var MCPClientConnection = class {
       templatesResult = await this.client.listResourceTemplates({
         cursor: templatesResult.nextCursor
       }).catch(
-        capabilityErrorHandler(
+        this._capabilityErrorHandler(
           { resourceTemplates: [] },
           "resources/templates/list"
         )
@@ -314,21 +475,46 @@ var MCPClientConnection = class {
         throw new Error(`Unsupported transport type: ${transportType}`);
     }
   }
-  async tryConnect(transportType, code) {
+  async tryConnect(transportType) {
     const transports = transportType === "auto" ? ["streamable-http", "sse"] : [transportType];
     for (const currentTransportType of transports) {
       const isLastTransport = currentTransportType === transports[transports.length - 1];
       const hasFallback = transportType === "auto" && currentTransportType === "streamable-http" && !isLastTransport;
-      const transport = await this.getTransport(currentTransportType);
-      if (code) {
-        await transport.finishAuth(code);
-      }
+      const transport = this.getTransport(currentTransportType);
       try {
         await this.client.connect(transport);
+        this.lastConnectedTransport = currentTransportType;
+        const url = this.url.toString();
+        this._onObservabilityEvent.fire({
+          type: "mcp:client:connect",
+          displayMessage: `Connected successfully using ${currentTransportType} transport for ${url}`,
+          payload: {
+            url,
+            transport: currentTransportType,
+            state: this.connectionState
+          },
+          timestamp: Date.now(),
+          id: nanoid()
+        });
         break;
       } catch (e) {
         const error = e instanceof Error ? e : new Error(String(e));
-        if (hasFallback && (error.message.includes("404") || error.message.includes("405"))) {
+        if (isUnauthorized(error)) {
+          throw e;
+        }
+        if (hasFallback && isTransportNotImplemented(error)) {
+          const url = this.url.toString();
+          this._onObservabilityEvent.fire({
+            type: "mcp:client:connect",
+            displayMessage: `${currentTransportType} transport not available, trying ${transports[transports.indexOf(currentTransportType) + 1]} for ${url}`,
+            payload: {
+              url,
+              transport: currentTransportType,
+              state: this.connectionState
+            },
+            timestamp: Date.now(),
+            id: nanoid()
+          });
           continue;
         }
         throw e;
@@ -341,18 +527,27 @@ var MCPClientConnection = class {
       }
     );
   }
+  _capabilityErrorHandler(empty, method) {
+    return (e) => {
+      if (e.code === -32601) {
+        const url = this.url.toString();
+        this._onObservabilityEvent.fire({
+          type: "mcp:client:discover",
+          displayMessage: `The server advertised support for the capability ${method.split("/")[0]}, but returned "Method not found" for '${method}' for ${url}`,
+          payload: {
+            url,
+            capability: method.split("/")[0],
+            error: toErrorMessage(e)
+          },
+          timestamp: Date.now(),
+          id: nanoid()
+        });
+        return empty;
+      }
+      throw e;
+    };
+  }
 };
-function capabilityErrorHandler(empty, method) {
-  return (e) => {
-    if (e.code === -32601) {
-      console.error(
-        `The server advertised support for the capability ${method.split("/")[0]}, but returned "Method not found" for '${method}'.`
-      );
-      return empty;
-    }
-    throw e;
-  };
-}
 
 // src/mcp/client.ts
 var MCPClientManager = class {
@@ -366,6 +561,12 @@ var MCPClientManager = class {
     this._version = _version;
     this.mcpConnections = {};
     this._callbackUrls = [];
+    this._didWarnAboutUnstableGetAITools = false;
+    this._connectionDisposables = /* @__PURE__ */ new Map();
+    this._onObservabilityEvent = new Emitter();
+    this.onObservabilityEvent = this._onObservabilityEvent.event;
+    this._onConnected = new Emitter();
+    this.onConnected = this._onConnected.event;
   }
   /**
    * Connect to and register an MCP server
@@ -375,31 +576,64 @@ var MCPClientManager = class {
    * @param capabilities Client capabilities (i.e. if the client supports roots/sampling)
    */
   async connect(url, options = {}) {
-    const id = options.reconnect?.id ?? nanoid(8);
-    if (!options.transport?.authProvider) {
-      console.warn(
-        "No authProvider provided in the transport options. This client will only support unauthenticated remote MCP Servers"
-      );
-    } else {
+    const id = options.reconnect?.id ?? nanoid2(8);
+    if (options.transport?.authProvider) {
       options.transport.authProvider.serverId = id;
       if (options.reconnect?.oauthClientId) {
         options.transport.authProvider.clientId = options.reconnect?.oauthClientId;
       }
     }
-    this.mcpConnections[id] = new MCPClientConnection(
-      new URL(url),
-      {
-        name: this._name,
-        version: this._version
-      },
-      {
-        client: options.client ?? {},
-        transport: options.transport ?? {}
+    if (!options.reconnect?.oauthCode || !this.mcpConnections[id]) {
+      const normalizedTransport = {
+        ...options.transport,
+        type: options.transport?.type ?? "auto"
+      };
+      this.mcpConnections[id] = new MCPClientConnection(
+        new URL(url),
+        {
+          name: this._name,
+          version: this._version
+        },
+        {
+          client: options.client ?? {},
+          transport: normalizedTransport
+        }
+      );
+      const store = new DisposableStore();
+      const existing = this._connectionDisposables.get(id);
+      if (existing) existing.dispose();
+      this._connectionDisposables.set(id, store);
+      store.add(
+        this.mcpConnections[id].onObservabilityEvent((event) => {
+          this._onObservabilityEvent.fire(event);
+        })
+      );
+    }
+    await this.mcpConnections[id].init();
+    if (options.reconnect?.oauthCode) {
+      try {
+        await this.mcpConnections[id].completeAuthorization(
+          options.reconnect.oauthCode
+        );
+        await this.mcpConnections[id].establishConnection();
+      } catch (error) {
+        this._onObservabilityEvent.fire({
+          type: "mcp:client:connect",
+          displayMessage: `Failed to complete OAuth reconnection for ${id} for ${url}`,
+          payload: {
+            url,
+            transport: options.transport?.type ?? "auto",
+            state: this.mcpConnections[id].connectionState,
+            error: toErrorMessage(error)
+          },
+          timestamp: Date.now(),
+          id
+        });
+        throw error;
       }
-    );
-    await this.mcpConnections[id].init(options.reconnect?.oauthCode);
+    }
     const authUrl = options.transport?.authProvider?.authUrl;
-    if (authUrl && options.transport?.authProvider?.redirectUrl) {
+    if (this.mcpConnections[id].connectionState === "authenticating" && authUrl && options.transport?.authProvider?.redirectUrl) {
       this._callbackUrls.push(
         options.transport.authProvider.redirectUrl.toString()
       );
@@ -454,19 +688,88 @@ var MCPClientManager = class {
     }
     conn.options.transport.authProvider.clientId = clientId;
     conn.options.transport.authProvider.serverId = serverId;
-    const serverUrl = conn.url.toString();
-    await this.connect(serverUrl, {
-      reconnect: {
-        id: serverId,
-        oauthClientId: clientId,
-        oauthCode: code
-      },
-      ...conn.options
-    });
-    if (this.mcpConnections[serverId].connectionState === "authenticating") {
-      throw new Error("Failed to authenticate: client failed to initialize");
+    try {
+      await conn.completeAuthorization(code);
+      return {
+        serverId,
+        authSuccess: true
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        serverId,
+        authSuccess: false,
+        authError: errorMessage
+      };
     }
-    return { serverId };
+  }
+  /**
+   * Establish connection in the background after OAuth completion
+   * This method is called asynchronously and doesn't block the OAuth callback response
+   * @param serverId The server ID to establish connection for
+   */
+  async establishConnection(serverId) {
+    const conn = this.mcpConnections[serverId];
+    if (!conn) {
+      this._onObservabilityEvent.fire({
+        type: "mcp:client:preconnect",
+        displayMessage: `Connection not found for serverId: ${serverId}`,
+        payload: { serverId },
+        timestamp: Date.now(),
+        id: nanoid2()
+      });
+      return;
+    }
+    try {
+      await conn.establishConnection();
+      this._onConnected.fire(serverId);
+    } catch (error) {
+      const url = conn.url.toString();
+      this._onObservabilityEvent.fire({
+        type: "mcp:client:connect",
+        displayMessage: `Failed to establish connection to server ${serverId} with url ${url}`,
+        payload: {
+          url,
+          transport: conn.options.transport.type ?? "auto",
+          state: conn.connectionState,
+          error: toErrorMessage(error)
+        },
+        timestamp: Date.now(),
+        id: nanoid2()
+      });
+    }
+  }
+  /**
+   * Register a callback URL for OAuth handling
+   * @param url The callback URL to register
+   */
+  registerCallbackUrl(url) {
+    if (!this._callbackUrls.includes(url)) {
+      this._callbackUrls.push(url);
+    }
+  }
+  /**
+   * Unregister a callback URL
+   * @param serverId The server ID whose callback URL should be removed
+   */
+  unregisterCallbackUrl(serverId) {
+    this._callbackUrls = this._callbackUrls.filter(
+      (url) => !url.endsWith(`/${serverId}`)
+    );
+  }
+  /**
+   * Configure OAuth callback handling
+   * @param config OAuth callback configuration
+   */
+  configureOAuthCallback(config) {
+    this._oauthCallbackConfig = config;
+  }
+  /**
+   * Get the current OAuth callback configuration
+   * @returns The current OAuth callback configuration
+   */
+  getOAuthCallbackConfig() {
+    return this._oauthCallbackConfig;
   }
   /**
    * @returns namespaced list of tools
@@ -477,7 +780,7 @@ var MCPClientManager = class {
   /**
    * @returns a set of tools that you can use with the AI SDK
    */
-  unstable_getAITools() {
+  getAITools() {
     return Object.fromEntries(
       getNamespacedData(this.mcpConnections, "tools").map((tool) => {
         return [
@@ -495,21 +798,46 @@ var MCPClientManager = class {
               }
               return result;
             },
-            inputSchema: jsonSchema(tool.inputSchema)
+            // @ts-expect-error drift between ai and mcp types
+            inputSchema: jsonSchema(tool.inputSchema),
+            outputSchema: tool.outputSchema ? (
+              // @ts-expect-error drift between ai and mcp types
+              jsonSchema(tool.outputSchema)
+            ) : void 0
           }
         ];
       })
     );
   }
+  /**
+   * @deprecated this has been renamed to getAITools(), and unstable_getAITools will be removed in the next major version
+   * @returns a set of tools that you can use with the AI SDK
+   */
+  unstable_getAITools() {
+    if (!this._didWarnAboutUnstableGetAITools) {
+      this._didWarnAboutUnstableGetAITools = true;
+      console.warn(
+        "unstable_getAITools is deprecated, use getAITools instead. unstable_getAITools will be removed in the next major version."
+      );
+    }
+    return this.getAITools();
+  }
   /**
    * Closes all connections to MCP servers
    */
   async closeAllConnections() {
-    return Promise.all(
-      Object.values(this.mcpConnections).map(async (connection) => {
-        await connection.client.close();
+    const ids = Object.keys(this.mcpConnections);
+    await Promise.all(
+      ids.map(async (id) => {
+        await this.mcpConnections[id].client.close();
       })
     );
+    for (const id of ids) {
+      const store = this._connectionDisposables.get(id);
+      if (store) store.dispose();
+      this._connectionDisposables.delete(id);
+      delete this.mcpConnections[id];
+    }
   }
   /**
    * Closes a connection to an MCP server
@@ -521,6 +849,20 @@ var MCPClientManager = class {
     }
     await this.mcpConnections[id].client.close();
     delete this.mcpConnections[id];
+    const store = this._connectionDisposables.get(id);
+    if (store) store.dispose();
+    this._connectionDisposables.delete(id);
+  }
+  /**
+   * Dispose the manager and all resources.
+   */
+  async dispose() {
+    try {
+      await this.closeAllConnections();
+    } finally {
+      this._onConnected.dispose();
+      this._onObservabilityEvent.dispose();
+    }
   }
   /**
    * @returns namespaced list of prompts
@@ -543,7 +885,7 @@ var MCPClientManager = class {
   /**
    * Namespaced version of callTool
    */
-  callTool(params, resultSchema, options) {
+  async callTool(params, resultSchema, options) {
     const unqualifiedName = params.name.replace(`${params.serverId}.`, "");
     return this.mcpConnections[params.serverId].client.callTool(
       {
@@ -590,9 +932,10 @@ function getNamespacedData(mcpClients, type) {
 }
 
 export {
+  DisposableStore,
   SSEEdgeClientTransport,
   StreamableHTTPEdgeClientTransport,
   MCPClientManager,
   getNamespacedData
 };
-//# sourceMappingURL=chunk-DS7BJNPH.js.map
+//# sourceMappingURL=chunk-3OT2NNEW.js.map