agents 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -1,46 +1,560 @@
-import { n as AgentEmail } from "./context-DcbQ8o7k.js";
-import { h as TransportType } from "./client-DFotUKH_.js";
-import "./ai-types-0OnT3FHg.js";
+import { n as AgentEmail } from "./internal_context-neg89p5n.js";
 import {
-  C as createCatchAllEmailResolver,
-  D as routeAgentEmail,
-  E as getCurrentAgent,
-  O as routeAgentRequest,
-  S as createAddressBasedEmailResolver,
-  T as getAgentByName,
-  _ as Schedule,
-  a as CallableMetadata,
-  b as WSMessage,
-  c as EmailResolver,
-  d as MCPServer,
-  f as MCPServerMessage,
-  g as RPCResponse,
-  h as RPCRequest,
-  i as AgentOptions,
-  k as unstable_callable,
-  l as EmailRoutingOptions,
-  m as QueueItem,
-  n as AgentContext,
-  o as Connection,
-  p as MCPServersState,
-  r as AgentNamespace,
-  s as ConnectionContext,
-  t as Agent,
-  u as EmailSendOptions,
-  v as StateUpdateMessage,
-  w as createHeaderBasedEmailResolver,
-  x as callable,
-  y as StreamingResponse
-} from "./index-CT2tCrLr.js";
+  h as TransportType,
+  t as MCPClientManager,
+  u as MCPConnectionState
+} from "./client-CbcnyqCo.js";
+import { t as Observability } from "./index-B7Ny-XfU.js";
+import { t as MessageType } from "./types-C5vR2Gzv.js";
+import {
+  Connection,
+  Connection as Connection$1,
+  ConnectionContext,
+  PartyServerOptions,
+  Server,
+  WSMessage
+} from "partyserver";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  Prompt,
+  Resource,
+  ServerCapabilities,
+  Tool
+} from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/index.d.ts
+
+/**
+ * RPC request message from client
+ */
+type RPCRequest = {
+  type: "rpc";
+  id: string;
+  method: string;
+  args: unknown[];
+};
+/**
+ * State update message from client
+ */
+type StateUpdateMessage = {
+  type: MessageType.CF_AGENT_STATE;
+  state: unknown;
+};
+/**
+ * RPC response message to client
+ */
+type RPCResponse = {
+  type: MessageType.RPC;
+  id: string;
+} & (
+  | {
+      success: true;
+      result: unknown;
+      done?: false;
+    }
+  | {
+      success: true;
+      result: unknown;
+      done: true;
+    }
+  | {
+      success: false;
+      error: string;
+    }
+);
+/**
+ * Metadata for a callable method
+ */
+type CallableMetadata = {
+  /** Optional description of what the method does */
+  description?: string;
+  /** Whether the method supports streaming responses */
+  streaming?: boolean;
+};
+/**
+ * Decorator that marks a method as callable by clients
+ * @param metadata Optional metadata about the callable method
+ */
+declare function callable(
+  metadata?: CallableMetadata
+): <This, Args extends unknown[], Return>(
+  target: (this: This, ...args: Args) => Return,
+  context: ClassMethodDecoratorContext
+) => (this: This, ...args: Args) => Return;
+/**
+ * Decorator that marks a method as callable by clients
+ * @deprecated this has been renamed to callable, and unstable_callable will be removed in the next major version
+ * @param metadata Optional metadata about the callable method
+ */
+declare const unstable_callable: (metadata?: CallableMetadata) => void;
+type QueueItem<T = string> = {
+  id: string;
+  payload: T;
+  callback: keyof Agent<Cloudflare.Env>;
+  created_at: number;
+};
+/**
+ * Represents a scheduled task within an Agent
+ * @template T Type of the payload data
+ */
+type Schedule<T = string> = {
+  /** Unique identifier for the schedule */
+  id: string;
+  /** Name of the method to be called */
+  callback: string;
+  /** Data to be passed to the callback */
+  payload: T;
+} & (
+  | {
+      /** Type of schedule for one-time execution at a specific time */
+      type: "scheduled";
+      /** Timestamp when the task should execute */
+      time: number;
+    }
+  | {
+      /** Type of schedule for delayed execution */
+      type: "delayed";
+      /** Timestamp when the task should execute */
+      time: number;
+      /** Number of seconds to delay execution */
+      delayInSeconds: number;
+    }
+  | {
+      /** Type of schedule for recurring execution based on cron expression */
+      type: "cron";
+      /** Timestamp for the next execution */
+      time: number;
+      /** Cron expression defining the schedule */
+      cron: string;
+    }
+);
+/**
+ * MCP Server state update message from server -> Client
+ */
+type MCPServerMessage = {
+  type: MessageType.CF_AGENT_MCP_SERVERS;
+  mcp: MCPServersState;
+};
+type MCPServersState = {
+  servers: {
+    [id: string]: MCPServer;
+  };
+  tools: (Tool & {
+    serverId: string;
+  })[];
+  prompts: (Prompt & {
+    serverId: string;
+  })[];
+  resources: (Resource & {
+    serverId: string;
+  })[];
+};
+type MCPServer = {
+  name: string;
+  server_url: string;
+  auth_url: string | null;
+  state: MCPConnectionState;
+  instructions: string | null;
+  capabilities: ServerCapabilities | null;
+};
+declare function getCurrentAgent<
+  T extends Agent<Cloudflare.Env> = Agent<Cloudflare.Env>
+>(): {
+  agent: T | undefined;
+  connection: Connection$1 | undefined;
+  request: Request | undefined;
+  email: AgentEmail | undefined;
+};
+/**
+ * Base class for creating Agent implementations
+ * @template Env Environment type containing bindings
+ * @template State State type to store within the Agent
+ */
+declare class Agent<
+  Env extends Cloudflare.Env = Cloudflare.Env,
+  State = unknown,
+  Props extends Record<string, unknown> = Record<string, unknown>
+> extends Server<Env, Props> {
+  private _state;
+  private _disposables;
+  private _destroyed;
+  private _ParentClass;
+  readonly mcp: MCPClientManager;
+  /**
+   * Initial state for the Agent
+   * Override to provide default state values
+   */
+  initialState: State;
+  /**
+   * Current state of the Agent
+   */
+  get state(): State;
+  /**
+   * Agent configuration options
+   */
+  static options: {
+    /** Whether the Agent should hibernate when inactive */
+    hibernate: boolean;
+  };
+  /**
+   * The observability implementation to use for the Agent
+   */
+  observability?: Observability;
+  /**
+   * Execute SQL queries against the Agent's database
+   * @template T Type of the returned rows
+   * @param strings SQL query template strings
+   * @param values Values to be inserted into the query
+   * @returns Array of query results
+   */
+  sql<T = Record<string, string | number | boolean | null>>(
+    strings: TemplateStringsArray,
+    ...values: (string | number | boolean | null)[]
+  ): T[];
+  constructor(ctx: AgentContext, env: Env);
+  private _setStateInternal;
+  /**
+   * Update the Agent's state
+   * @param state New state to set
+   */
+  setState(state: State): void;
+  /**
+   * Called when the Agent's state is updated
+   * @param state Updated state
+   * @param source Source of the state update ("server" or a client connection)
+   */
+  onStateUpdate(
+    state: State | undefined,
+    source: Connection$1 | "server"
+  ): void;
+  /**
+   * Called when the Agent receives an email via routeAgentEmail()
+   * Override this method to handle incoming emails
+   * @param email Email message to process
+   */
+  _onEmail(email: AgentEmail): Promise<void>;
+  /**
+   * Reply to an email
+   * @param email The email to reply to
+   * @param options Options for the reply
+   * @returns void
+   */
+  replyToEmail(
+    email: AgentEmail,
+    options: {
+      fromName: string;
+      subject?: string | undefined;
+      body: string;
+      contentType?: string;
+      headers?: Record<string, string>;
+    }
+  ): Promise<void>;
+  private _tryCatch;
+  /**
+   * Automatically wrap custom methods with agent context
+   * This ensures getCurrentAgent() works in all custom methods without decorators
+   */
+  private _autoWrapCustomMethods;
+  onError(connection: Connection$1, error: unknown): void | Promise<void>;
+  onError(error: unknown): void | Promise<void>;
+  /**
+   * Render content (not implemented in base class)
+   */
+  render(): void;
+  /**
+   * Queue a task to be executed in the future
+   * @param payload Payload to pass to the callback
+   * @param callback Name of the method to call
+   * @returns The ID of the queued task
+   */
+  queue<T = unknown>(callback: keyof this, payload: T): Promise<string>;
+  private _flushingQueue;
+  private _flushQueue;
+  /**
+   * Dequeue a task by ID
+   * @param id ID of the task to dequeue
+   */
+  dequeue(id: string): Promise<void>;
+  /**
+   * Dequeue all tasks
+   */
+  dequeueAll(): Promise<void>;
+  /**
+   * Dequeue all tasks by callback
+   * @param callback Name of the callback to dequeue
+   */
+  dequeueAllByCallback(callback: string): Promise<void>;
+  /**
+   * Get a queued task by ID
+   * @param id ID of the task to get
+   * @returns The task or undefined if not found
+   */
+  getQueue(id: string): Promise<QueueItem<string> | undefined>;
+  /**
+   * Get all queues by key and value
+   * @param key Key to filter by
+   * @param value Value to filter by
+   * @returns Array of matching QueueItem objects
+   */
+  getQueues(key: string, value: string): Promise<QueueItem<string>[]>;
+  /**
+   * Schedule a task to be executed in the future
+   * @template T Type of the payload data
+   * @param when When to execute the task (Date, seconds delay, or cron expression)
+   * @param callback Name of the method to call
+   * @param payload Data to pass to the callback
+   * @returns Schedule object representing the scheduled task
+   */
+  schedule<T = string>(
+    when: Date | string | number,
+    callback: keyof this,
+    payload?: T
+  ): Promise<Schedule<T>>;
+  /**
+   * Get a scheduled task by ID
+   * @template T Type of the payload data
+   * @param id ID of the scheduled task
+   * @returns The Schedule object or undefined if not found
+   */
+  getSchedule<T = string>(id: string): Promise<Schedule<T> | undefined>;
+  /**
+   * Get scheduled tasks matching the given criteria
+   * @template T Type of the payload data
+   * @param criteria Criteria to filter schedules
+   * @returns Array of matching Schedule objects
+   */
+  getSchedules<T = string>(criteria?: {
+    id?: string;
+    type?: "scheduled" | "delayed" | "cron";
+    timeRange?: {
+      start?: Date;
+      end?: Date;
+    };
+  }): Schedule<T>[];
+  /**
+   * Cancel a scheduled task
+   * @param id ID of the task to cancel
+   * @returns true if the task was cancelled, false if the task was not found
+   */
+  cancelSchedule(id: string): Promise<boolean>;
+  private _scheduleNextAlarm;
+  /**
+   * Method called when an alarm fires.
+   * Executes any scheduled tasks that are due.
+   *
+   * @remarks
+   * To schedule a task, please use the `this.schedule` method instead.
+   * See {@link https://developers.cloudflare.com/agents/api-reference/schedule-tasks/}
+   */
+  readonly alarm: () => Promise<void>;
+  /**
+   * Destroy the Agent, removing all state and scheduled tasks
+   */
+  destroy(): Promise<void>;
+  /**
+   * Get all methods marked as callable on this Agent
+   * @returns A map of method names to their metadata
+   */
+  private _isCallable;
+  /**
+   * 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. 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 options
+   * @returns Server id and state - either "authenticating" with authUrl, or "ready"
+   * @throws If connection or discovery fails
+   */
+  addMcpServer(
+    serverName: string,
+    url: string,
+    callbackHost?: string,
+    agentsPrefix?: string,
+    options?: {
+      client?: ConstructorParameters<typeof Client>[1];
+      transport?: {
+        headers?: HeadersInit;
+        type?: TransportType;
+      };
+    }
+  ): Promise<
+    | {
+        id: string;
+        state: typeof MCPConnectionState.AUTHENTICATING;
+        authUrl: string;
+      }
+    | {
+        id: string;
+        state: typeof MCPConnectionState.READY;
+        authUrl?: undefined;
+      }
+  >;
+  removeMcpServer(id: string): Promise<void>;
+  getMcpServers(): MCPServersState;
+  private broadcastMcpServers;
+  /**
+   * Handle MCP OAuth callback request if it's an OAuth callback.
+   *
+   * This method encapsulates the entire OAuth callback flow:
+   * 1. Checks if the request is an MCP OAuth callback
+   * 2. Processes the OAuth code exchange
+   * 3. Establishes the connection if successful
+   * 4. Broadcasts MCP server state updates
+   * 5. Returns the appropriate HTTP response
+   *
+   * @param request The incoming HTTP request
+   * @returns Response if this was an OAuth callback, null otherwise
+   */
+  private handleMcpOAuthCallback;
+  /**
+   * 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;
+}
+/**
+ * Namespace for creating Agent instances
+ * @template Agentic Type of the Agent class
+ * @deprecated Use DurableObjectNamespace instead
+ */
+type AgentNamespace<Agentic extends Agent<Cloudflare.Env>> =
+  DurableObjectNamespace<Agentic>;
+/**
+ * Agent's durable context
+ */
+type AgentContext = DurableObjectState;
+/**
+ * Configuration options for Agent routing
+ */
+type AgentOptions<Env> = PartyServerOptions<Env> & {
+  /**
+   * Whether to enable CORS for the Agent
+   */
+  cors?: boolean | HeadersInit | undefined;
+};
+/**
+ * Route a request to the appropriate Agent
+ * @param request Request to route
+ * @param env Environment containing Agent bindings
+ * @param options Routing options
+ * @returns Response from the Agent or undefined if no route matched
+ */
+declare function routeAgentRequest<Env>(
+  request: Request,
+  env: Env,
+  options?: AgentOptions<Env>
+): Promise<Response | null>;
+type EmailResolver<Env> = (
+  email: ForwardableEmailMessage,
+  env: Env
+) => Promise<{
+  agentName: string;
+  agentId: string;
+} | null>;
+/**
+ * Create a resolver that uses the message-id header to determine the agent to route the email to
+ * @returns A function that resolves the agent to route the email to
+ */
+declare function createHeaderBasedEmailResolver<Env>(): EmailResolver<Env>;
+/**
+ * Create a resolver that uses the email address to determine the agent to route the email to
+ * @param defaultAgentName The default agent name to use if the email address does not contain a sub-address
+ * @returns A function that resolves the agent to route the email to
+ */
+declare function createAddressBasedEmailResolver<Env>(
+  defaultAgentName: string
+): EmailResolver<Env>;
+/**
+ * Create a resolver that uses the agentName and agentId to determine the agent to route the email to
+ * @param agentName The name of the agent to route the email to
+ * @param agentId The id of the agent to route the email to
+ * @returns A function that resolves the agent to route the email to
+ */
+declare function createCatchAllEmailResolver<Env>(
+  agentName: string,
+  agentId: string
+): EmailResolver<Env>;
+type EmailRoutingOptions<Env> = AgentOptions<Env> & {
+  resolver: EmailResolver<Env>;
+};
+/**
+ * Route an email to the appropriate Agent
+ * @param email The email to route
+ * @param env The environment containing the Agent bindings
+ * @param options The options for routing the email
+ * @returns A promise that resolves when the email has been routed
+ */
+declare function routeAgentEmail<Env extends Cloudflare.Env = Cloudflare.Env>(
+  email: ForwardableEmailMessage,
+  env: Env,
+  options: EmailRoutingOptions<Env>
+): Promise<void>;
+type EmailSendOptions = {
+  to: string;
+  subject: string;
+  body: string;
+  contentType?: string;
+  headers?: Record<string, string>;
+  includeRoutingHeaders?: boolean;
+  agentName?: string;
+  agentId?: string;
+  domain?: string;
+};
+/**
+ * Get or create an Agent by name
+ * @template Env Environment type containing bindings
+ * @template T Type of the Agent class
+ * @param namespace Agent namespace
+ * @param name Name of the Agent instance
+ * @param options Options for Agent creation
+ * @returns Promise resolving to an Agent instance stub
+ */
+declare function getAgentByName<
+  Env extends Cloudflare.Env = Cloudflare.Env,
+  T extends Agent<Env> = Agent<Env>,
+  Props extends Record<string, unknown> = Record<string, unknown>
+>(
+  namespace: DurableObjectNamespace<T>,
+  name: string,
+  options?: {
+    jurisdiction?: DurableObjectJurisdiction;
+    locationHint?: DurableObjectLocationHint;
+    props?: Props;
+  }
+): Promise<DurableObjectStub<T>>;
+/**
+ * A wrapper for streaming responses in callable methods
+ */
+declare class StreamingResponse {
+  private _connection;
+  private _id;
+  private _closed;
+  constructor(connection: Connection$1, id: string);
+  /**
+   * Send a chunk of data to the client
+   * @param chunk The data to send
+   */
+  send(chunk: unknown): void;
+  /**
+   * End the stream and send the final chunk (if any)
+   * @param finalChunk Optional final chunk of data to send
+   */
+  end(finalChunk?: unknown): void;
+}
+//#endregion
 export {
   Agent,
   AgentContext,
-  AgentEmail,
+  type AgentEmail,
   AgentNamespace,
   AgentOptions,
   CallableMetadata,
-  Connection,
-  ConnectionContext,
+  type Connection,
+  type ConnectionContext,
   EmailResolver,
   EmailRoutingOptions,
   EmailSendOptions,
@@ -53,8 +567,8 @@ export {
   Schedule,
   StateUpdateMessage,
   StreamingResponse,
-  TransportType,
-  WSMessage,
+  type TransportType,
+  type WSMessage,
   callable,
   createAddressBasedEmailResolver,
   createCatchAllEmailResolver,
@@ -65,3 +579,4 @@ export {
   routeAgentRequest,
   unstable_callable
 };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,7 @@
-import "./context-BkKbAa1R.js";
-import "./client-DjTPRM8-.js";
-import "./client-QZa2Rq0l.js";
-import "./do-oauth-client-provider-B1fVIshX.js";
-import { a as createCatchAllEmailResolver, c as getCurrentAgent, d as unstable_callable, i as createAddressBasedEmailResolver, l as routeAgentEmail, n as StreamingResponse, o as createHeaderBasedEmailResolver, r as callable, s as getAgentByName, t as Agent, u as routeAgentRequest } from "./src-BZDh910Z.js";
+import "./client-CEO0P7vN.js";
+import "./internal_context-oN047Id3.js";
+import "./client-C7SOlYfK.js";
+import "./do-oauth-client-provider-BfPFgQU0.js";
+import { a as createCatchAllEmailResolver, c as getCurrentAgent, d as unstable_callable, i as createAddressBasedEmailResolver, l as routeAgentEmail, n as StreamingResponse, o as createHeaderBasedEmailResolver, r as callable, s as getAgentByName, t as Agent, u as routeAgentRequest } from "./src-CXf5SiV4.js";
 
 export { Agent, StreamingResponse, callable, createAddressBasedEmailResolver, createCatchAllEmailResolver, createHeaderBasedEmailResolver, getAgentByName, getCurrentAgent, routeAgentEmail, routeAgentRequest, unstable_callable };

package/dist/{context-DcbQ8o7k.d.ts → internal_context-neg89p5n.d.ts}

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Connection } from "partyserver";
 
-//#region src/context.d.ts
+//#region src/internal_context.d.ts
 type AgentEmail = {
   from: string;
   to: string;
@@ -21,4 +21,4 @@ type AgentContextStore = {
 declare const agentContext: AsyncLocalStorage<AgentContextStore>;
 //#endregion
 export { AgentEmail as n, agentContext as r, AgentContextStore as t };
-//# sourceMappingURL=context-DcbQ8o7k.d.ts.map
+//# sourceMappingURL=internal_context-neg89p5n.d.ts.map

package/dist/{context-BkKbAa1R.js → internal_context-oN047Id3.js}

@@ -1,8 +1,8 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
-//#region src/context.ts
+//#region src/internal_context.ts
 const agentContext = new AsyncLocalStorage();
 
 //#endregion
 export { agentContext as t };
-//# sourceMappingURL=context-BkKbAa1R.js.map
+//# sourceMappingURL=internal_context-oN047Id3.js.map

package/dist/internal_context-oN047Id3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal_context-oN047Id3.js","names":[],"sources":["../src/internal_context.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\nimport type { Connection } from \"partyserver\";\n\nexport type AgentEmail = {\n  from: string;\n  to: string;\n  getRaw: () => Promise<Uint8Array>;\n  headers: Headers;\n  rawSize: number;\n  setReject: (reason: string) => void;\n  forward: (rcptTo: string, headers?: Headers) => Promise<void>;\n  reply: (options: { from: string; to: string; raw: string }) => Promise<void>;\n};\n\nexport type AgentContextStore = {\n  // Using unknown to avoid circular dependency with Agent\n  agent: unknown;\n  connection: Connection | undefined;\n  request: Request | undefined;\n  email: AgentEmail | undefined;\n};\n\nexport const agentContext = new AsyncLocalStorage<AgentContextStore>();\n"],"mappings":";;;AAsBA,MAAa,eAAe,IAAI,mBAAsC"}

package/dist/{context.d.ts → internal_context.d.ts}

@@ -2,5 +2,5 @@ import {
   n as AgentEmail,
   r as agentContext,
   t as AgentContextStore
-} from "./context-DcbQ8o7k.js";
+} from "./internal_context-neg89p5n.js";
 export { AgentContextStore, AgentEmail, agentContext };

package/dist/internal_context.js

@@ -0,0 +1,3 @@
+import { t as agentContext } from "./internal_context-oN047Id3.js";
+
+export { agentContext };

package/dist/mcp/client.d.ts

@@ -1,2 +1,2 @@
-import { a as MCPConnectionResult, c as RegisterServerOptions, i as MCPClientOAuthResult, l as getNamespacedData, n as MCPClientManagerOptions, o as MCPDiscoverResult, r as MCPClientOAuthCallbackConfig, s as MCPServerOptions, t as MCPClientManager } from "../client-DFotUKH_.js";
+import { a as MCPConnectionResult, c as RegisterServerOptions, i as MCPClientOAuthResult, l as getNamespacedData, n as MCPClientManagerOptions, o as MCPDiscoverResult, r as MCPClientOAuthCallbackConfig, s as MCPServerOptions, t as MCPClientManager } from "../client-CbcnyqCo.js";
 export { MCPClientManager, MCPClientManagerOptions, MCPClientOAuthCallbackConfig, MCPClientOAuthResult, MCPConnectionResult, MCPDiscoverResult, MCPServerOptions, RegisterServerOptions, getNamespacedData };

package/dist/mcp/client.js

@@ -1,4 +1,4 @@
-import { n as getNamespacedData, t as MCPClientManager } from "../client-QZa2Rq0l.js";
-import "../do-oauth-client-provider-B1fVIshX.js";
+import { n as getNamespacedData, t as MCPClientManager } from "../client-C7SOlYfK.js";
+import "../do-oauth-client-provider-BfPFgQU0.js";
 
 export { MCPClientManager, getNamespacedData };

package/dist/mcp/do-oauth-client-provider.d.ts

@@ -1,2 +1,2 @@
-import { n as DurableObjectOAuthClientProvider, t as AgentsOAuthProvider } from "../do-oauth-client-provider--To1Tsjj.js";
+import { n as DurableObjectOAuthClientProvider, t as AgentsOAuthProvider } from "../do-oauth-client-provider-BH9zFtSy.js";
 export { AgentsOAuthProvider, DurableObjectOAuthClientProvider };

package/dist/mcp/do-oauth-client-provider.js

@@ -1,3 +1,3 @@
-import { t as DurableObjectOAuthClientProvider } from "../do-oauth-client-provider-B1fVIshX.js";
+import { t as DurableObjectOAuthClientProvider } from "../do-oauth-client-provider-BfPFgQU0.js";
 
 export { DurableObjectOAuthClientProvider };