agents 0.0.0-a20932f → 0.0.0-a45f8f3

package/dist/mcp/client.js

@@ -0,0 +1,9 @@
+import {
+  MCPClientManager,
+  getNamespacedData
+} from "../chunk-UNG3FXYX.js";
+export {
+  MCPClientManager,
+  getNamespacedData
+};
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,41 @@
+import { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import { OAuthClientMetadata, OAuthClientInformation, OAuthClientInformationFull, OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
+
+interface AgentsOAuthProvider extends OAuthClientProvider {
+    authUrl: string | undefined;
+    clientId: string | undefined;
+    serverId: string | undefined;
+}
+declare class DurableObjectOAuthClientProvider implements AgentsOAuthProvider {
+    storage: DurableObjectStorage;
+    clientName: string;
+    baseRedirectUrl: string;
+    private _authUrl_;
+    private _serverId_;
+    private _clientId_;
+    constructor(storage: DurableObjectStorage, clientName: string, baseRedirectUrl: string);
+    get clientMetadata(): OAuthClientMetadata;
+    get redirectUrl(): string;
+    get clientId(): string;
+    set clientId(clientId_: string);
+    get serverId(): string;
+    set serverId(serverId_: string);
+    keyPrefix(clientId: string): string;
+    clientInfoKey(clientId: string): string;
+    clientInformation(): Promise<OAuthClientInformation | undefined>;
+    saveClientInformation(clientInformation: OAuthClientInformationFull): Promise<void>;
+    tokenKey(clientId: string): string;
+    tokens(): Promise<OAuthTokens | undefined>;
+    saveTokens(tokens: OAuthTokens): Promise<void>;
+    get authUrl(): string | undefined;
+    /**
+     * 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
+     */
+    redirectToAuthorization(authUrl: URL): Promise<void>;
+    codeVerifierKey(clientId: string): string;
+    saveCodeVerifier(verifier: string): Promise<void>;
+    codeVerifier(): Promise<string>;
+}
+
+export { type AgentsOAuthProvider, DurableObjectOAuthClientProvider };

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

@@ -0,0 +1,7 @@
+import {
+  DurableObjectOAuthClientProvider
+} from "../chunk-PVQZBKN7.js";
+export {
+  DurableObjectOAuthClientProvider
+};
+//# sourceMappingURL=do-oauth-client-provider.js.map

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

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

package/dist/mcp/index.d.ts

@@ -0,0 +1,107 @@
+import { MCPClientManager } from './client.js';
+import { DurableObject } from 'cloudflare:workers';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Connection, WSMessage } from 'partyserver';
+import { SSEClientTransport, SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport, StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import 'zod';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/shared/protocol.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'ai';
+import './do-oauth-client-provider.js';
+import '@modelcontextprotocol/sdk/client/auth.js';
+import '@modelcontextprotocol/sdk/shared/auth.js';
+
+declare class SSEEdgeClientTransport extends SSEClientTransport {
+    private authProvider;
+    /**
+     * Creates a new EdgeSSEClientTransport, which overrides fetch to be compatible with the CF workers environment
+     */
+    constructor(url: URL, options: SSEClientTransportOptions);
+    authHeaders(): Promise<{
+        Authorization: string;
+    } | undefined>;
+}
+
+declare class StreamableHTTPEdgeClientTransport extends StreamableHTTPClientTransport {
+    private authProvider;
+    /**
+     * Creates a new StreamableHTTPEdgeClientTransport, which overrides fetch to be compatible with the CF workers environment
+     */
+    constructor(url: URL, options: StreamableHTTPClientTransportOptions);
+    authHeaders(): Promise<{
+        Authorization: string;
+    } | undefined>;
+}
+
+interface CORSOptions {
+    origin?: string;
+    methods?: string;
+    headers?: string;
+    maxAge?: number;
+    exposeHeaders?: string;
+}
+type MaybePromise<T> = T | Promise<T>;
+declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Record<string, unknown> = Record<string, unknown>> extends DurableObject<Env> {
+    private _status;
+    private _transport?;
+    private _transportType;
+    private _requestIdToConnectionId;
+    /**
+     * Since McpAgent's _aren't_ yet real "Agents", let's only expose a couple of the methods
+     * to the outer class: initialState/state/setState/onStateUpdate/sql
+     */
+    private _agent;
+    get mcp(): MCPClientManager;
+    protected constructor(ctx: DurableObjectState, env: Env);
+    /**
+     * Agents API allowlist
+     */
+    initialState: State;
+    get state(): State;
+    sql<T = Record<string, string | number | boolean | null>>(strings: TemplateStringsArray, ...values: (string | number | boolean | null)[]): T[];
+    setState(state: State): void;
+    onStateUpdate(state: State | undefined, source: Connection | "server"): void;
+    onStart(): Promise<void>;
+    /**
+     * McpAgent API
+     */
+    abstract server: MaybePromise<McpServer | Server>;
+    props: Props;
+    initRun: boolean;
+    abstract init(): Promise<void>;
+    _init(props: Props): Promise<void>;
+    setInitialized(): Promise<void>;
+    isInitialized(): Promise<boolean>;
+    private _initialize;
+    fetch(request: Request): Promise<Response>;
+    getWebSocket(): WebSocket | null;
+    getWebSocketForResponseID(id: string): WebSocket | null;
+    onMessage(connection: Connection, event: WSMessage): Promise<void>;
+    onSSEMcpMessage(_sessionId: string, request: Request): Promise<Error | null>;
+    webSocketMessage(ws: WebSocket, event: ArrayBuffer | string): Promise<void>;
+    webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+    webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
+    static mount(path: string, { binding, corsOptions }?: {
+        binding?: string;
+        corsOptions?: CORSOptions;
+    }): {
+        fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+    };
+    static serveSSE(path: string, { binding, corsOptions }?: {
+        binding?: string;
+        corsOptions?: CORSOptions;
+    }): {
+        fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+    };
+    static serve(path: string, { binding, corsOptions }?: {
+        binding?: string;
+        corsOptions?: CORSOptions;
+    }): {
+        fetch<Env>(this: void, request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+    };
+}
+
+export { McpAgent, SSEEdgeClientTransport, StreamableHTTPEdgeClientTransport };