agents 0.0.0-7d9b939 → 0.0.0-7f4616c

package/src/index.ts

@@ -22,10 +22,12 @@ import {
   routePartykitRequest
 } from "partyserver";
 import { camelCaseToKebabCase } from "./client";
-import { MCPClientManager } from "./mcp/client";
-// import type { MCPClientConnection } from "./mcp/client-connection";
+import { MCPClientManager, type MCPClientOAuthResult } from "./mcp/client";
+import type { MCPConnectionState } from "./mcp/client-connection";
 import { DurableObjectOAuthClientProvider } from "./mcp/do-oauth-client-provider";
+import type { TransportType } from "./mcp/types";
 import { genericObservability, type Observability } from "./observability";
+import { DisposableStore } from "./core/events";
 import { MessageType } from "./ai-types";
 
 export type { Connection, ConnectionContext, WSMessage } from "partyserver";
@@ -197,6 +199,8 @@ function getNextCronTime(cron: string) {
   return interval.getNextDate();
 }
 
+export type { TransportType } from "./mcp/types";
+
 /**
  * MCP Server state update message from server -> Client
  */
@@ -221,7 +225,7 @@ export type MCPServer = {
   // This state is specifically about the temporary process of getting a token (if needed).
   // Scope outside of that can't be relied upon because when the DO sleeps, there's no way
   // to communicate a change to a non-ready state.
-  state: "authenticating" | "connecting" | "ready" | "discovering" | "failed";
+  state: MCPConnectionState;
   instructions: string | null;
   capabilities: ServerCapabilities | null;
 };
@@ -314,11 +318,15 @@ export class Agent<
   Props extends Record<string, unknown> = Record<string, unknown>
 > extends Server<Env, Props> {
   private _state = DEFAULT_STATE as State;
+  private _disposables = new DisposableStore();
 
   private _ParentClass: typeof Agent<Env, State> =
     Object.getPrototypeOf(this).constructor;
 
-  mcp: MCPClientManager = new MCPClientManager(this._ParentClass.name, "0.0.1");
+  readonly mcp: MCPClientManager = new MCPClientManager(
+    this._ParentClass.name,
+    "0.0.1"
+  );
 
   /**
    * Initial state for the Agent
@@ -411,8 +419,25 @@ export class Agent<
   constructor(ctx: AgentContext, env: Env) {
     super(ctx, env);
 
-    // Auto-wrap custom methods with agent context
-    this._autoWrapCustomMethods();
+    if (!wrappedClasses.has(this.constructor)) {
+      // Auto-wrap custom methods with agent context
+      this._autoWrapCustomMethods();
+      wrappedClasses.add(this.constructor);
+    }
+
+    // Broadcast server state after background connects (for OAuth servers)
+    this._disposables.add(
+      this.mcp.onConnected(async () => {
+        this.broadcastMcpServers();
+      })
+    );
+
+    // Emit MCP observability events
+    this._disposables.add(
+      this.mcp.onObservabilityEvent((event) => {
+        this.observability?.emit(event);
+      })
+    );
 
     this.sql`
       CREATE TABLE IF NOT EXISTS cf_agents_state (
@@ -468,22 +493,11 @@ export class Agent<
       return agentContext.run(
         { agent: this, connection: undefined, request, email: undefined },
         async () => {
-          if (this.mcp.isCallbackRequest(request)) {
-            await this.mcp.handleCallbackRequest(request);
-
-            // after the MCP connection handshake, we can send updated mcp state
-            this.broadcast(
-              JSON.stringify({
-                mcp: this.getMcpServers(),
-                type: MessageType.CF_AGENT_MCP_SERVERS
-              })
-            );
-
-            // We probably should let the user configure this response/redirect, but this is fine for now.
-            return new Response("<script>window.close();</script>", {
-              headers: { "content-type": "text/html" },
-              status: 200
-            });
+          // Check if this is an OAuth callback and restore state if needed
+          const callbackResult =
+            await this._handlePotentialOAuthCallback(request);
+          if (callbackResult) {
+            return callbackResult;
           }
 
           return this._tryCatch(() => _onRequest(request));
@@ -636,15 +650,20 @@ export class Agent<
             SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers;
           `;
 
-            this.broadcast(
-              JSON.stringify({
-                mcp: this.getMcpServers(),
-                type: MessageType.CF_AGENT_MCP_SERVERS
-              })
-            );
+            this.broadcastMcpServers();
 
             // from DO storage, reconnect to all servers not currently in the oauth flow using our saved auth information
             if (servers && Array.isArray(servers) && servers.length > 0) {
+              // Restore callback URLs for OAuth-enabled servers
+              servers.forEach((server) => {
+                if (server.callback_url) {
+                  // Register the full redirect URL including serverId to avoid ambiguous matches
+                  this.mcp.registerCallbackUrl(
+                    `${server.callback_url}/${server.id}`
+                  );
+                }
+              });
+
               servers.forEach((server) => {
                 this._connectToMcpServerInternal(
                   server.name,
@@ -660,12 +679,7 @@ export class Agent<
                 )
                   .then(() => {
                     // Broadcast updated MCP servers state after each server connects
-                    this.broadcast(
-                      JSON.stringify({
-                        mcp: this.getMcpServers(),
-                        type: MessageType.CF_AGENT_MCP_SERVERS
-                      })
-                    );
+                    this.broadcastMcpServers();
                   })
                   .catch((error) => {
                     console.error(
@@ -673,12 +687,7 @@ export class Agent<
                       error
                     );
                     // Still broadcast even if connection fails, so clients know about the failure
-                    this.broadcast(
-                      JSON.stringify({
-                        mcp: this.getMcpServers(),
-                        type: MessageType.CF_AGENT_MCP_SERVERS
-                      })
-                    );
+                    this.broadcastMcpServers();
                   });
               });
             }
@@ -1371,6 +1380,8 @@ export class Agent<
     // delete all alarms
     await this.ctx.storage.deleteAlarm();
     await this.ctx.storage.deleteAll();
+    this._disposables.dispose();
+    await this.mcp.dispose?.();
     this.ctx.abort("destroyed"); // enforce that the agent is evicted
 
     this.observability?.emit(
@@ -1396,57 +1407,220 @@ export class Agent<
   /**
    * Connect to a new MCP Server
    *
+   * @param serverName Name of the MCP server
    * @param url MCP Server SSE URL
-   * @param callbackHost Base host for the agent, used for the redirect URI.
+   * @param callbackHost Base host for the agent, used for the redirect URI. If not provided, will be derived from the current request.
    * @param agentsPrefix agents routing prefix if not using `agents`
-   * @param options MCP client and transport (header) options
+   * @param options MCP client and transport options
    * @returns authUrl
    */
   async addMcpServer(
     serverName: string,
     url: string,
-    callbackHost: string,
+    callbackHost?: string,
     agentsPrefix = "agents",
     options?: {
       client?: ConstructorParameters<typeof Client>[1];
       transport?: {
-        headers: HeadersInit;
+        headers?: HeadersInit;
+        type?: TransportType;
       };
     }
   ): Promise<{ id: string; authUrl: string | undefined }> {
-    const callbackUrl = `${callbackHost}/${agentsPrefix}/${camelCaseToKebabCase(this._ParentClass.name)}/${this.name}/callback`;
+    // If callbackHost is not provided, derive it from the current request
+    let resolvedCallbackHost = callbackHost;
+    if (!resolvedCallbackHost) {
+      const { request } = getCurrentAgent();
+      if (!request) {
+        throw new Error(
+          "callbackHost is required when not called within a request context"
+        );
+      }
 
-    const result = await this._connectToMcpServerInternal(
-      serverName,
-      url,
-      callbackUrl,
-      options
-    );
+      // Extract the origin from the request
+      const requestUrl = new URL(request.url);
+      resolvedCallbackHost = `${requestUrl.protocol}//${requestUrl.host}`;
+    }
+
+    const callbackUrl = `${resolvedCallbackHost}/${agentsPrefix}/${camelCaseToKebabCase(this._ParentClass.name)}/${this.name}/callback`;
+
+    // Generate a serverId upfront
+    const serverId = nanoid(8);
+
+    // Persist to database BEFORE starting OAuth flow to survive DO hibernation
     this.sql`
-        INSERT
-        OR REPLACE INTO cf_agents_mcp_servers (id, name, server_url, client_id, auth_url, callback_url, server_options)
+        INSERT OR REPLACE INTO cf_agents_mcp_servers (id, name, server_url, client_id, auth_url, callback_url, server_options)
       VALUES (
-        ${result.id},
+        ${serverId},
         ${serverName},
         ${url},
-        ${result.clientId ?? null},
-        ${result.authUrl ?? null},
+        ${null},
+        ${null},
         ${callbackUrl},
         ${options ? JSON.stringify(options) : null}
         );
     `;
 
-    this.broadcast(
-      JSON.stringify({
-        mcp: this.getMcpServers(),
-        type: MessageType.CF_AGENT_MCP_SERVERS
-      })
+    // _connectToMcpServerInternal will call mcp.connect which registers the callback URL
+    const result = await this._connectToMcpServerInternal(
+      serverName,
+      url,
+      callbackUrl,
+      options,
+      { id: serverId }
     );
 
+    // Update database with OAuth client info if auth is required
+    if (result.clientId || result.authUrl) {
+      this.sql`
+        UPDATE cf_agents_mcp_servers
+        SET client_id = ${result.clientId ?? null}, auth_url = ${result.authUrl ?? null}
+        WHERE id = ${serverId}
+      `;
+    }
+
+    this.broadcastMcpServers();
+
     return result;
   }
 
-  async _connectToMcpServerInternal(
+  /**
+   * Handle potential OAuth callback requests after DO hibernation.
+   * Detects OAuth callbacks, restores state from database, and processes the callback.
+   * Returns a Response if this was an OAuth callback, otherwise returns undefined.
+   */
+  private async _handlePotentialOAuthCallback(
+    request: Request
+  ): Promise<Response | undefined> {
+    // Quick check: must be GET with callback pattern and code parameter
+    if (request.method !== "GET") {
+      return undefined;
+    }
+
+    const url = new URL(request.url);
+    const hasCallbackPattern =
+      url.pathname.includes("/callback/") && url.searchParams.has("code");
+
+    if (!hasCallbackPattern) {
+      return undefined;
+    }
+
+    // Extract serverId from callback URL
+    const pathParts = url.pathname.split("/");
+    const callbackIndex = pathParts.indexOf("callback");
+    const serverId = callbackIndex !== -1 ? pathParts[callbackIndex + 1] : null;
+
+    if (!serverId) {
+      return new Response("Invalid callback URL: missing serverId", {
+        status: 400
+      });
+    }
+
+    // Check if callback is already registered AND connection exists (not hibernated)
+    if (
+      this.mcp.isCallbackRequest(request) &&
+      this.mcp.mcpConnections[serverId]
+    ) {
+      // State already restored, handle normally
+      return this._processOAuthCallback(request);
+    }
+
+    // Need to restore from database after hibernation
+    try {
+      const server = this.sql<MCPServerRow>`
+        SELECT id, name, server_url, client_id, auth_url, callback_url, server_options
+        FROM cf_agents_mcp_servers
+        WHERE id = ${serverId}
+      `.find((s) => s.id === serverId);
+
+      if (!server) {
+        return new Response(
+          `OAuth callback failed: Server ${serverId} not found in database`,
+          { status: 404 }
+        );
+      }
+
+      // Register callback URL (restores it after hibernation)
+      if (!server.callback_url) {
+        return new Response(
+          `OAuth callback failed: No callback URL stored for server ${serverId}`,
+          { status: 500 }
+        );
+      }
+
+      this.mcp.registerCallbackUrl(`${server.callback_url}/${server.id}`);
+
+      // Restore connection if not in memory
+      if (!this.mcp.mcpConnections[serverId]) {
+        let parsedOptions:
+          | {
+              client?: ConstructorParameters<typeof Client>[1];
+              transport?: {
+                headers?: HeadersInit;
+                type?: TransportType;
+              };
+            }
+          | undefined;
+        try {
+          parsedOptions = server.server_options
+            ? JSON.parse(server.server_options)
+            : undefined;
+        } catch {
+          return new Response(
+            `OAuth callback failed: Invalid server options in database for ${serverId}`,
+            { status: 500 }
+          );
+        }
+
+        await this._connectToMcpServerInternal(
+          server.name,
+          server.server_url,
+          server.callback_url,
+          parsedOptions,
+          {
+            id: server.id,
+            oauthClientId: server.client_id ?? undefined
+          }
+        );
+      }
+
+      // Now process the OAuth callback
+      return this._processOAuthCallback(request);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Failed to restore MCP state for ${serverId}:`, error);
+      return new Response(
+        `OAuth callback failed during state restoration: ${errorMsg}`,
+        { status: 500 }
+      );
+    }
+  }
+
+  /**
+   * Process an OAuth callback request (assumes state is already restored)
+   */
+  private async _processOAuthCallback(request: Request): Promise<Response> {
+    const result = await this.mcp.handleCallbackRequest(request);
+    this.broadcastMcpServers();
+
+    if (result.authSuccess) {
+      // Start background connection if auth was successful
+      this.mcp
+        .establishConnection(result.serverId)
+        .catch((error) => {
+          console.error("Background connection failed:", error);
+        })
+        .finally(() => {
+          // Broadcast after background connection resolves (success/failure)
+          this.broadcastMcpServers();
+        });
+    }
+
+    // Handle OAuth callback response using MCPClientManager configuration
+    return this.handleOAuthCallbackResponse(result, request);
+  }
+
+  private async _connectToMcpServerInternal(
     _serverName: string,
     url: string,
     callbackUrl: string,
@@ -1462,6 +1636,7 @@ export class Agent<
        */
       transport?: {
         headers?: HeadersInit;
+        type?: TransportType;
       };
     },
     reconnect?: {
@@ -1486,6 +1661,9 @@ export class Agent<
       }
     }
 
+    // Use the transport type specified in options, or default to "auto"
+    const transportType: TransportType = options?.transport?.type ?? "auto";
+
     // allows passing through transport headers if necessary
     // this handles some non-standard bearer auth setups (i.e. MCP server behind CF access instead of OAuth)
     let headerTransportOpts: SSEClientTransportOptions = {};
@@ -1509,7 +1687,8 @@ export class Agent<
       reconnect,
       transport: {
         ...headerTransportOpts,
-        authProvider
+        authProvider,
+        type: transportType
       }
     });
 
@@ -1522,15 +1701,11 @@ export class Agent<
 
   async removeMcpServer(id: string) {
     this.mcp.closeConnection(id);
+    this.mcp.unregisterCallbackUrl(id);
     this.sql`
       DELETE FROM cf_agents_mcp_servers WHERE id = ${id};
     `;
-    this.broadcast(
-      JSON.stringify({
-        mcp: this.getMcpServers(),
-        type: MessageType.CF_AGENT_MCP_SERVERS
-      })
-    );
+    this.broadcastMcpServers();
   }
 
   getMcpServers(): MCPServersState {
@@ -1562,8 +1737,53 @@ export class Agent<
 
     return mcpState;
   }
+
+  private broadcastMcpServers() {
+    this.broadcast(
+      JSON.stringify({
+        mcp: this.getMcpServers(),
+        type: MessageType.CF_AGENT_MCP_SERVERS
+      })
+    );
+  }
+
+  /**
+   * Handle OAuth callback response using MCPClientManager configuration
+   * @param result OAuth callback result
+   * @param request The original request (needed for base URL)
+   * @returns Response for the OAuth callback
+   */
+  private handleOAuthCallbackResponse(
+    result: MCPClientOAuthResult,
+    request: Request
+  ): Response {
+    const config = this.mcp.getOAuthCallbackConfig();
+
+    // Use custom handler if configured
+    if (config?.customHandler) {
+      return config.customHandler(result);
+    }
+
+    // Use redirect URLs if configured
+    if (config?.successRedirect && result.authSuccess) {
+      return Response.redirect(config.successRedirect);
+    }
+
+    if (config?.errorRedirect && !result.authSuccess) {
+      return Response.redirect(
+        `${config.errorRedirect}?error=${encodeURIComponent(result.authError || "Unknown error")}`
+      );
+    }
+
+    // Default behavior - redirect to base URL
+    const baseUrl = new URL(request.url).origin;
+    return Response.redirect(baseUrl);
+  }
 }
 
+// A set of classes that have been wrapped with agent context
+const wrappedClasses = new Set<typeof Agent.prototype.constructor>();
+
 /**
  * Namespace for creating Agent instances
  * @template Agentic Type of the Agent class

package/dist/ai-chat-v5-migration.js.map

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

package/dist/ai-types.js.map

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

package/dist/chunk-AVYJQSLW.js

@@ -1,17 +0,0 @@
-// src/ai-types.ts
-var MessageType = /* @__PURE__ */ ((MessageType2) => {
-  MessageType2["CF_AGENT_CHAT_MESSAGES"] = "cf_agent_chat_messages";
-  MessageType2["CF_AGENT_USE_CHAT_REQUEST"] = "cf_agent_use_chat_request";
-  MessageType2["CF_AGENT_USE_CHAT_RESPONSE"] = "cf_agent_use_chat_response";
-  MessageType2["CF_AGENT_CHAT_CLEAR"] = "cf_agent_chat_clear";
-  MessageType2["CF_AGENT_CHAT_REQUEST_CANCEL"] = "cf_agent_chat_request_cancel";
-  MessageType2["CF_AGENT_MCP_SERVERS"] = "cf_agent_mcp_servers";
-  MessageType2["CF_AGENT_STATE"] = "cf_agent_state";
-  MessageType2["RPC"] = "rpc";
-  return MessageType2;
-})(MessageType || {});
-
-export {
-  MessageType
-};
-//# sourceMappingURL=chunk-AVYJQSLW.js.map

package/dist/chunk-AVYJQSLW.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/ai-types.ts"],"sourcesContent":["import type { UIMessage } from \"ai\";\n\n/**\n * Enum for message types to improve type safety and maintainability\n */\nexport enum MessageType {\n  CF_AGENT_CHAT_MESSAGES = \"cf_agent_chat_messages\",\n  CF_AGENT_USE_CHAT_REQUEST = \"cf_agent_use_chat_request\",\n  CF_AGENT_USE_CHAT_RESPONSE = \"cf_agent_use_chat_response\",\n  CF_AGENT_CHAT_CLEAR = \"cf_agent_chat_clear\",\n  CF_AGENT_CHAT_REQUEST_CANCEL = \"cf_agent_chat_request_cancel\",\n\n  CF_AGENT_MCP_SERVERS = \"cf_agent_mcp_servers\",\n  CF_AGENT_STATE = \"cf_agent_state\",\n  RPC = \"rpc\"\n}\n\n/**\n * Types of messages sent from the Agent to clients\n */\nexport type OutgoingMessage<ChatMessage extends UIMessage = UIMessage> =\n  | {\n      /** Indicates this message is a command to clear chat history */\n      type: MessageType.CF_AGENT_CHAT_CLEAR;\n    }\n  | {\n      /** Indicates this message contains updated chat messages */\n      type: MessageType.CF_AGENT_CHAT_MESSAGES;\n      /** Array of chat messages */\n      messages: ChatMessage[];\n    }\n  | {\n      /** Indicates this message is a response to a chat request */\n      type: MessageType.CF_AGENT_USE_CHAT_RESPONSE;\n      /** Unique ID of the request this response corresponds to */\n      id: string;\n      /** Content body of the response */\n      body: string;\n      /** Whether this is the final chunk of the response */\n      done: boolean;\n      /** Whether this response contains an error */\n      error?: boolean;\n    }\n  | {\n      /** Indicates this message is a command to clear chat history */\n      type: MessageType.CF_AGENT_CHAT_CLEAR;\n    };\n\n/**\n * Types of messages sent from clients to the Agent\n */\nexport type IncomingMessage<ChatMessage extends UIMessage = UIMessage> =\n  | {\n      /** Indicates this message is a command to clear chat history */\n      type: MessageType.CF_AGENT_CHAT_CLEAR;\n    }\n  | {\n      /** Indicates this message is a request to the chat API */\n      type: MessageType.CF_AGENT_USE_CHAT_REQUEST;\n      /** Unique ID for this request */\n      id: string;\n      /** Request initialization options */\n      init: Pick<\n        RequestInit,\n        | \"method\"\n        | \"keepalive\"\n        | \"headers\"\n        | \"body\"\n        | \"redirect\"\n        | \"integrity\"\n        | \"credentials\"\n        | \"mode\"\n        | \"referrer\"\n        | \"referrerPolicy\"\n        | \"window\"\n      >;\n    }\n  | {\n      /** Indicates this message is a command to clear chat history */\n      type: MessageType.CF_AGENT_CHAT_CLEAR;\n    }\n  | {\n      /** Indicates this message contains updated chat messages */\n      type: MessageType.CF_AGENT_CHAT_MESSAGES;\n      /** Array of chat messages */\n      messages: ChatMessage[];\n    }\n  | {\n      /** Indicates the user wants to stop generation of this message */\n      type: MessageType.CF_AGENT_CHAT_REQUEST_CANCEL;\n      id: string;\n    };\n"],"mappings":";AAKO,IAAK,cAAL,kBAAKA,iBAAL;AACL,EAAAA,aAAA,4BAAyB;AACzB,EAAAA,aAAA,+BAA4B;AAC5B,EAAAA,aAAA,gCAA6B;AAC7B,EAAAA,aAAA,yBAAsB;AACtB,EAAAA,aAAA,kCAA+B;AAE/B,EAAAA,aAAA,0BAAuB;AACvB,EAAAA,aAAA,oBAAiB;AACjB,EAAAA,aAAA,SAAM;AATI,SAAAA;AAAA,GAAA;","names":["MessageType"]}

package/dist/chunk-LL2AFX7V.js

@@ -1,109 +0,0 @@
-// src/mcp/do-oauth-client-provider.ts
-var DurableObjectOAuthClientProvider = class {
-  constructor(storage, clientName, baseRedirectUrl) {
-    this.storage = storage;
-    this.clientName = clientName;
-    this.baseRedirectUrl = baseRedirectUrl;
-  }
-  get clientMetadata() {
-    return {
-      client_name: this.clientName,
-      client_uri: this.clientUri,
-      grant_types: ["authorization_code", "refresh_token"],
-      redirect_uris: [this.redirectUrl],
-      response_types: ["code"],
-      token_endpoint_auth_method: "none"
-    };
-  }
-  get clientUri() {
-    return new URL(this.redirectUrl).origin;
-  }
-  get redirectUrl() {
-    return `${this.baseRedirectUrl}/${this.serverId}`;
-  }
-  get clientId() {
-    if (!this._clientId_) {
-      throw new Error("Trying to access clientId before it was set");
-    }
-    return this._clientId_;
-  }
-  set clientId(clientId_) {
-    this._clientId_ = clientId_;
-  }
-  get serverId() {
-    if (!this._serverId_) {
-      throw new Error("Trying to access serverId before it was set");
-    }
-    return this._serverId_;
-  }
-  set serverId(serverId_) {
-    this._serverId_ = serverId_;
-  }
-  keyPrefix(clientId) {
-    return `/${this.clientName}/${this.serverId}/${clientId}`;
-  }
-  clientInfoKey(clientId) {
-    return `${this.keyPrefix(clientId)}/client_info/`;
-  }
-  async clientInformation() {
-    if (!this._clientId_) {
-      return void 0;
-    }
-    return await this.storage.get(
-      this.clientInfoKey(this.clientId)
-    ) ?? void 0;
-  }
-  async saveClientInformation(clientInformation) {
-    await this.storage.put(
-      this.clientInfoKey(clientInformation.client_id),
-      clientInformation
-    );
-    this.clientId = clientInformation.client_id;
-  }
-  tokenKey(clientId) {
-    return `${this.keyPrefix(clientId)}/token`;
-  }
-  async tokens() {
-    if (!this._clientId_) {
-      return void 0;
-    }
-    return await this.storage.get(this.tokenKey(this.clientId)) ?? void 0;
-  }
-  async saveTokens(tokens) {
-    await this.storage.put(this.tokenKey(this.clientId), tokens);
-  }
-  get authUrl() {
-    return this._authUrl_;
-  }
-  /**
-   * Because this operates on the server side (but we need browser auth), we send this url back to the user
-   * and require user interact to initiate the redirect flow
-   */
-  async redirectToAuthorization(authUrl) {
-    const client_id = authUrl.searchParams.get("client_id");
-    if (client_id) {
-      authUrl.searchParams.append("state", client_id);
-    }
-    this._authUrl_ = authUrl.toString();
-  }
-  codeVerifierKey(clientId) {
-    return `${this.keyPrefix(clientId)}/code_verifier`;
-  }
-  async saveCodeVerifier(verifier) {
-    await this.storage.put(this.codeVerifierKey(this.clientId), verifier);
-  }
-  async codeVerifier() {
-    const codeVerifier = await this.storage.get(
-      this.codeVerifierKey(this.clientId)
-    );
-    if (!codeVerifier) {
-      throw new Error("No code verifier found");
-    }
-    return codeVerifier;
-  }
-};
-
-export {
-  DurableObjectOAuthClientProvider
-};
-//# sourceMappingURL=chunk-LL2AFX7V.js.map

package/dist/chunk-LL2AFX7V.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/mcp/do-oauth-client-provider.ts"],"sourcesContent":["import type { OAuthClientProvider } from \"@modelcontextprotocol/sdk/client/auth.js\";\nimport type {\n  OAuthClientInformation,\n  OAuthClientInformationFull,\n  OAuthClientMetadata,\n  OAuthTokens\n} from \"@modelcontextprotocol/sdk/shared/auth.js\";\n\n// A slight extension to the standard OAuthClientProvider interface because `redirectToAuthorization` doesn't give us the interface we need\n// This allows us to track authentication for a specific server and associated dynamic client registration\nexport interface AgentsOAuthProvider extends OAuthClientProvider {\n  authUrl: string | undefined;\n  clientId: string | undefined;\n  serverId: string | undefined;\n}\n\nexport class DurableObjectOAuthClientProvider implements AgentsOAuthProvider {\n  private _authUrl_: string | undefined;\n  private _serverId_: string | undefined;\n  private _clientId_: string | undefined;\n\n  constructor(\n    public storage: DurableObjectStorage,\n    public clientName: string,\n    public baseRedirectUrl: string\n  ) {}\n\n  get clientMetadata(): OAuthClientMetadata {\n    return {\n      client_name: this.clientName,\n      client_uri: this.clientUri,\n      grant_types: [\"authorization_code\", \"refresh_token\"],\n      redirect_uris: [this.redirectUrl],\n      response_types: [\"code\"],\n      token_endpoint_auth_method: \"none\"\n    };\n  }\n\n  get clientUri() {\n    return new URL(this.redirectUrl).origin;\n  }\n\n  get redirectUrl() {\n    return `${this.baseRedirectUrl}/${this.serverId}`;\n  }\n\n  get clientId() {\n    if (!this._clientId_) {\n      throw new Error(\"Trying to access clientId before it was set\");\n    }\n    return this._clientId_;\n  }\n\n  set clientId(clientId_: string) {\n    this._clientId_ = clientId_;\n  }\n\n  get serverId() {\n    if (!this._serverId_) {\n      throw new Error(\"Trying to access serverId before it was set\");\n    }\n    return this._serverId_;\n  }\n\n  set serverId(serverId_: string) {\n    this._serverId_ = serverId_;\n  }\n\n  keyPrefix(clientId: string) {\n    return `/${this.clientName}/${this.serverId}/${clientId}`;\n  }\n\n  clientInfoKey(clientId: string) {\n    return `${this.keyPrefix(clientId)}/client_info/`;\n  }\n\n  async clientInformation(): Promise<OAuthClientInformation | undefined> {\n    if (!this._clientId_) {\n      return undefined;\n    }\n    return (\n      (await this.storage.get<OAuthClientInformation>(\n        this.clientInfoKey(this.clientId)\n      )) ?? undefined\n    );\n  }\n\n  async saveClientInformation(\n    clientInformation: OAuthClientInformationFull\n  ): Promise<void> {\n    await this.storage.put(\n      this.clientInfoKey(clientInformation.client_id),\n      clientInformation\n    );\n    this.clientId = clientInformation.client_id;\n  }\n\n  tokenKey(clientId: string) {\n    return `${this.keyPrefix(clientId)}/token`;\n  }\n\n  async tokens(): Promise<OAuthTokens | undefined> {\n    if (!this._clientId_) {\n      return undefined;\n    }\n    return (\n      (await this.storage.get<OAuthTokens>(this.tokenKey(this.clientId))) ??\n      undefined\n    );\n  }\n\n  async saveTokens(tokens: OAuthTokens): Promise<void> {\n    await this.storage.put(this.tokenKey(this.clientId), tokens);\n  }\n\n  get authUrl() {\n    return this._authUrl_;\n  }\n\n  /**\n   * Because this operates on the server side (but we need browser auth), we send this url back to the user\n   * and require user interact to initiate the redirect flow\n   */\n  async redirectToAuthorization(authUrl: URL): Promise<void> {\n    // We want to track the client ID in state here because the typescript SSE client sometimes does\n    // a dynamic client registration AFTER generating this redirect URL.\n    const client_id = authUrl.searchParams.get(\"client_id\");\n    if (client_id) {\n      authUrl.searchParams.append(\"state\", client_id);\n    }\n    this._authUrl_ = authUrl.toString();\n  }\n\n  codeVerifierKey(clientId: string) {\n    return `${this.keyPrefix(clientId)}/code_verifier`;\n  }\n\n  async saveCodeVerifier(verifier: string): Promise<void> {\n    await this.storage.put(this.codeVerifierKey(this.clientId), verifier);\n  }\n\n  async codeVerifier(): Promise<string> {\n    const codeVerifier = await this.storage.get<string>(\n      this.codeVerifierKey(this.clientId)\n    );\n    if (!codeVerifier) {\n      throw new Error(\"No code verifier found\");\n    }\n    return codeVerifier;\n  }\n}\n"],"mappings":"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","names":[]}