agents 0.0.0-e03246e → 0.0.0-e135cf5

package/dist/client.d.ts

@@ -1,84 +1,17 @@
+import "./serializable-CymX8ovI.js";
 import {
-  PartySocketOptions,
-  PartyFetchOptions,
-  PartySocket,
-} from "partysocket";
-
-/**
- * Options for creating an AgentClient
- */
-type AgentClientOptions<State = unknown> = Omit<
-  PartySocketOptions,
-  "party" | "room"
-> & {
-  /** Name of the agent to connect to */
-  agent: string;
-  /** Name of the specific Agent instance */
-  name?: string;
-  /** Called when the Agent's state is updated */
-  onStateUpdate?: (state: State, source: "server" | "client") => void;
-};
-/**
- * Options for streaming RPC calls
- */
-type StreamOptions = {
-  /** Called when a chunk of data is received */
-  onChunk?: (chunk: unknown) => void;
-  /** Called when the stream ends */
-  onDone?: (finalChunk: unknown) => void;
-  /** Called when an error occurs */
-  onError?: (error: string) => void;
-};
-/**
- * Options for the agentFetch function
- */
-type AgentClientFetchOptions = Omit<PartyFetchOptions, "party" | "room"> & {
-  /** Name of the agent to connect to */
-  agent: string;
-  /** Name of the specific Agent instance */
-  name?: string;
-};
-/**
- * WebSocket client for connecting to an Agent
- */
-declare class AgentClient<State = unknown> extends PartySocket {
-  #private;
-  /**
-   * @deprecated Use agentFetch instead
-   */
-  static fetch(_opts: PartyFetchOptions): Promise<Response>;
-  agent: string;
-  name: string;
-  constructor(options: AgentClientOptions<State>);
-  setState(state: State): void;
-  /**
-   * Call a method on the Agent
-   * @param method Name of the method to call
-   * @param args Arguments to pass to the method
-   * @param streamOptions Options for handling streaming responses
-   * @returns Promise that resolves with the method's return value
-   */
-  call<T = unknown>(
-    method: string,
-    args?: unknown[],
-    streamOptions?: StreamOptions
-  ): Promise<T>;
-}
-/**
- * Make an HTTP request to an Agent
- * @param opts Connection options
- * @param init Request initialization options
- * @returns Promise resolving to a Response
- */
-declare function agentFetch(
-  opts: AgentClientFetchOptions,
-  init?: RequestInit
-): Promise<Response>;
-
+  a as agentFetch,
+  i as StreamOptions,
+  n as AgentClientFetchOptions,
+  o as camelCaseToKebabCase,
+  r as AgentClientOptions,
+  t as AgentClient
+} from "./client-CbWe9FBd.js";
 export {
   AgentClient,
-  type AgentClientFetchOptions,
-  type AgentClientOptions,
-  type StreamOptions,
+  AgentClientFetchOptions,
+  AgentClientOptions,
+  StreamOptions,
   agentFetch,
+  camelCaseToKebabCase
 };

package/dist/client.js

@@ -1,131 +1,4 @@
-import {
-  __privateAdd,
-  __privateGet,
-  __privateSet
-} from "./chunk-HMLY7DHA.js";
+import "./ai-types-B3aQaFv3.js";
+import { n as agentFetch, r as camelCaseToKebabCase, t as AgentClient } from "./client-BfiZ3HQd.js";
 
-// src/client.ts
-import {
-  PartySocket
-} from "partysocket";
-function camelCaseToKebabCase(str) {
-  if (str === str.toUpperCase() && str !== str.toLowerCase()) {
-    return str.toLowerCase().replace(/_/g, "-");
-  }
-  let kebabified = str.replace(
-    /[A-Z]/g,
-    (letter) => `-${letter.toLowerCase()}`
-  );
-  kebabified = kebabified.startsWith("-") ? kebabified.slice(1) : kebabified;
-  return kebabified.replace(/_/g, "-").replace(/-$/, "");
-}
-var _options, _pendingCalls;
-var AgentClient = class extends PartySocket {
-  constructor(options) {
-    const agentNamespace = camelCaseToKebabCase(options.agent);
-    super({
-      prefix: "agents",
-      party: agentNamespace,
-      room: options.name || "default",
-      ...options
-    });
-    __privateAdd(this, _options);
-    __privateAdd(this, _pendingCalls, /* @__PURE__ */ new Map());
-    this.agent = agentNamespace;
-    this.name = options.name || "default";
-    __privateSet(this, _options, options);
-    this.addEventListener("message", (event) => {
-      if (typeof event.data === "string") {
-        let parsedMessage;
-        try {
-          parsedMessage = JSON.parse(event.data);
-        } catch (error) {
-          return;
-        }
-        if (parsedMessage.type === "cf_agent_state") {
-          __privateGet(this, _options).onStateUpdate?.(parsedMessage.state, "server");
-          return;
-        }
-        if (parsedMessage.type === "rpc") {
-          const response = parsedMessage;
-          const pending = __privateGet(this, _pendingCalls).get(response.id);
-          if (!pending) return;
-          if (!response.success) {
-            pending.reject(new Error(response.error));
-            __privateGet(this, _pendingCalls).delete(response.id);
-            pending.stream?.onError?.(response.error);
-            return;
-          }
-          if ("done" in response) {
-            if (response.done) {
-              pending.resolve(response.result);
-              __privateGet(this, _pendingCalls).delete(response.id);
-              pending.stream?.onDone?.(response.result);
-            } else {
-              pending.stream?.onChunk?.(response.result);
-            }
-          } else {
-            pending.resolve(response.result);
-            __privateGet(this, _pendingCalls).delete(response.id);
-          }
-        }
-      }
-    });
-  }
-  /**
-   * @deprecated Use agentFetch instead
-   */
-  static fetch(_opts) {
-    throw new Error(
-      "AgentClient.fetch is not implemented, use agentFetch instead"
-    );
-  }
-  setState(state) {
-    this.send(JSON.stringify({ type: "cf_agent_state", state }));
-    __privateGet(this, _options).onStateUpdate?.(state, "client");
-  }
-  /**
-   * Call a method on the Agent
-   * @param method Name of the method to call
-   * @param args Arguments to pass to the method
-   * @param streamOptions Options for handling streaming responses
-   * @returns Promise that resolves with the method's return value
-   */
-  async call(method, args = [], streamOptions) {
-    return new Promise((resolve, reject) => {
-      const id = Math.random().toString(36).slice(2);
-      __privateGet(this, _pendingCalls).set(id, {
-        resolve: (value) => resolve(value),
-        reject,
-        stream: streamOptions,
-        type: null
-      });
-      const request = {
-        type: "rpc",
-        id,
-        method,
-        args
-      };
-      this.send(JSON.stringify(request));
-    });
-  }
-};
-_options = new WeakMap();
-_pendingCalls = new WeakMap();
-function agentFetch(opts, init) {
-  const agentNamespace = camelCaseToKebabCase(opts.agent);
-  return PartySocket.fetch(
-    {
-      prefix: "agents",
-      party: agentNamespace,
-      room: opts.name || "default",
-      ...opts
-    },
-    init
-  );
-}
-export {
-  AgentClient,
-  agentFetch
-};
-//# sourceMappingURL=client.js.map
+export { AgentClient, agentFetch, camelCaseToKebabCase };

package/dist/codemode/ai.d.ts

@@ -0,0 +1,27 @@
+import { ToolSet } from "ai";
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+//#region src/codemode/ai.d.ts
+declare class CodeModeProxy extends WorkerEntrypoint<Cloudflare.Env, {
+  binding: string;
+  name: string;
+  callback: string;
+}> {
+  callFunction(options: {
+    functionName: string;
+    args: unknown[];
+  }): Promise<any>;
+}
+declare function experimental_codemode(options: {
+  tools: ToolSet;
+  prompt: string;
+  globalOutbound: Fetcher;
+  loader: WorkerLoader;
+  proxy: Fetcher<CodeModeProxy>;
+}): Promise<{
+  prompt: string;
+  tools: ToolSet;
+}>;
+//#endregion
+export { CodeModeProxy, experimental_codemode };
+//# sourceMappingURL=ai.d.ts.map

package/dist/codemode/ai.js

@@ -0,0 +1,151 @@
+import "../ai-types-B3aQaFv3.js";
+import "../client-BfiZ3HQd.js";
+import "../client-DZhjV_XA.js";
+import "../do-oauth-client-provider-CswoD5Lu.js";
+import { s as getAgentByName } from "../src-C8K3lu37.js";
+import { generateObject, tool } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { z } from "zod/v3";
+import { compile } from "json-schema-to-typescript";
+import { createTypeAlias, printNode, zodToTs } from "zod-to-ts";
+import { WorkerEntrypoint, env } from "cloudflare:workers";
+
+//#region src/codemode/ai.ts
+function toCamelCase(str) {
+	return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/^[a-z]/, (letter) => letter.toUpperCase());
+}
+var CodeModeProxy = class extends WorkerEntrypoint {
+	async callFunction(options) {
+		return (await getAgentByName(env[this.ctx.props.binding], this.ctx.props.name))[this.ctx.props.callback](options.functionName, options.args);
+	}
+};
+async function experimental_codemode(options) {
+	const generatedTypes = await generateTypes(options.tools);
+	return {
+		prompt: `You are a helpful assistant. You have access to the "codemode" tool that can do different things: 
+  
+  ${getToolDescriptions(options.tools)} 
+  
+  If the user asks to do anything that be achieveable by the codemode tool, then simply pass over control to it by giving it a simple function description. Don't be too verbose.
+  
+  `,
+		tools: { codemode: tool({
+			description: "codemode: a tool that can generate code to achieve a goal",
+			inputSchema: z.object({ functionDescription: z.string() }),
+			outputSchema: z.object({
+				code: z.string(),
+				result: z.any()
+			}),
+			execute: async ({ functionDescription }) => {
+				try {
+					const response = await generateObject({
+						model: openai("gpt-4.1"),
+						schema: z.object({ code: z.string() }),
+						prompt: `You are a code generating machine.
+
+      In addition to regular javascript, you can also use the following functions:
+
+      ${generatedTypes}      
+
+      Respond only with the code, nothing else. Output javascript code.
+
+      Generate an async function that achieves the goal. This async function doesn't accept any arguments.
+
+      Here is user input: ${functionDescription}`
+					});
+					const result = await createEvaluator(response.object.code, {
+						proxy: options.proxy,
+						loader: options.loader
+					})();
+					return {
+						code: response.object.code,
+						result
+					};
+				} catch (error) {
+					console.error("error", error);
+					throw error;
+				}
+			}
+		}) }
+	};
+}
+function createEvaluator(code, options) {
+	return async () => {
+		return await options.loader.get(`code-${Math.random()}`, () => {
+			return {
+				compatibilityDate: "2025-06-01",
+				compatibilityFlags: ["nodejs_compat"],
+				mainModule: "foo.js",
+				modules: { "foo.js": `
+import { env, WorkerEntrypoint } from "cloudflare:workers";
+
+export default class CodeModeWorker extends WorkerEntrypoint {
+  async evaluate() {
+    try {
+      const { CodeModeProxy } = env;
+      const codemode = new Proxy(
+        {},
+        {
+          get: (target, prop) => {
+            return (args) => {
+              return CodeModeProxy.callFunction({
+                functionName: prop,
+                args: args,                
+              });
+            };
+          }
+        }
+      );
+
+      return await ${code}();
+    } catch (err) {
+      return {
+        err: err.message,
+        stack: err.stack
+      };
+    }
+  }
+}
+            
+        ` },
+				env: { CodeModeProxy: options.proxy },
+				globalOutbound: null
+			};
+		}).getEntrypoint().evaluate();
+	};
+}
+async function generateTypes(tools) {
+	let availableTools = "";
+	let availableTypes = "";
+	for (const [toolName, tool$1] of Object.entries(tools)) {
+		const inputJsonType = tool$1.inputSchema.jsonSchema ? await compile(tool$1.inputSchema.jsonSchema, `${toCamelCase(toolName)}Input`, {
+			format: false,
+			bannerComment: " "
+		}) : printNode(createTypeAlias(zodToTs(tool$1.inputSchema, `${toCamelCase(toolName)}Input`).node, `${toCamelCase(toolName)}Input`));
+		const outputJsonType = tool$1.outputSchema?.jsonSchema ? await compile(tool$1.outputSchema?.jsonSchema, `${toCamelCase(toolName)}Output`, {
+			format: false,
+			bannerComment: " "
+		}) : tool$1.outputSchema ? printNode(createTypeAlias(zodToTs(tool$1.outputSchema, `${toCamelCase(toolName)}Output`).node, `${toCamelCase(toolName)}Output`)) : `interface ${toCamelCase(toolName)}Output { [key: string]: any }`;
+		const InputType = inputJsonType.trim().replace("export interface", "interface");
+		const OutputType = outputJsonType.trim().replace("export interface", "interface");
+		availableTypes += `\n${InputType}`;
+		availableTypes += `\n${OutputType}`;
+		availableTools += `\n\t/*\n\t${tool$1.description?.trim()}\n\t*/`;
+		availableTools += `\n\t${toolName}: (input: ${toCamelCase(toolName)}Input) => Promise<${toCamelCase(toolName)}Output>;`;
+		availableTools += "\n";
+	}
+	availableTools = `\ndeclare const codemode: {${availableTools}}`;
+	return `
+${availableTypes}
+${availableTools}
+      `;
+}
+function getToolDescriptions(tools) {
+	return Object.entries(tools).map(([_toolName, tool$1]) => {
+		return `\n- ${tool$1.description?.trim()}`;
+	}).join("");
+}
+
+//#endregion
+export { CodeModeProxy, experimental_codemode };
+//# sourceMappingURL=ai.js.map

package/dist/codemode/ai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.js","names":["tool","compileJsonSchemaToTs","printNodeZodToTs"],"sources":["../../src/codemode/ai.ts"],"sourcesContent":["import { generateObject, tool, type ToolSet } from \"ai\";\nimport { openai } from \"@ai-sdk/openai\";\nimport { z } from \"zod/v3\";\nimport { compile as compileJsonSchemaToTs } from \"json-schema-to-typescript\";\nimport {\n  zodToTs,\n  printNode as printNodeZodToTs,\n  createTypeAlias\n} from \"zod-to-ts\";\nimport { getAgentByName } from \"..\";\nimport { env, WorkerEntrypoint } from \"cloudflare:workers\";\n\nfunction toCamelCase(str: string) {\n  return str\n    .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())\n    .replace(/^[a-z]/, (letter) => letter.toUpperCase());\n}\n\nexport class CodeModeProxy extends WorkerEntrypoint<\n  Cloudflare.Env,\n  {\n    binding: string;\n    name: string;\n    callback: string;\n  }\n> {\n  async callFunction(options: { functionName: string; args: unknown[] }) {\n    const stub = (await getAgentByName(\n      // @ts-expect-error\n      env[this.ctx.props.binding] as AgentNamespace<T>,\n      this.ctx.props.name\n    )) as DurableObjectStub;\n    // @ts-expect-error\n    return stub[this.ctx.props.callback](options.functionName, options.args);\n  }\n}\n\nexport async function experimental_codemode(options: {\n  tools: ToolSet;\n  prompt: string;\n  globalOutbound: Fetcher;\n  loader: WorkerLoader;\n  proxy: Fetcher<CodeModeProxy>;\n}): Promise<{\n  prompt: string;\n  tools: ToolSet;\n}> {\n  const generatedTypes = await generateTypes(options.tools);\n  const prompt = `You are a helpful assistant. You have access to the \"codemode\" tool that can do different things: \n  \n  ${getToolDescriptions(options.tools)} \n  \n  If the user asks to do anything that be achieveable by the codemode tool, then simply pass over control to it by giving it a simple function description. Don't be too verbose.\n  \n  `;\n\n  const codemodeTool = tool({\n    description: \"codemode: a tool that can generate code to achieve a goal\",\n    inputSchema: z.object({\n      functionDescription: z.string()\n    }),\n    outputSchema: z.object({\n      code: z.string(),\n      result: z.any()\n    }),\n    execute: async ({ functionDescription }) => {\n      try {\n        const response = await generateObject({\n          model: openai(\"gpt-4.1\"),\n          schema: z.object({\n            code: z.string()\n          }),\n          prompt: `You are a code generating machine.\n\n      In addition to regular javascript, you can also use the following functions:\n\n      ${generatedTypes}      \n\n      Respond only with the code, nothing else. Output javascript code.\n\n      Generate an async function that achieves the goal. This async function doesn't accept any arguments.\n\n      Here is user input: ${functionDescription}` // insert ts types for the tools here\n        });\n\n        // console.log(\"args\", response.object.args);\n        const evaluator = createEvaluator(response.object.code, {\n          proxy: options.proxy,\n          loader: options.loader\n        });\n        const result = await evaluator();\n        return { code: response.object.code, result: result };\n      } catch (error) {\n        console.error(\"error\", error);\n        throw error;\n        // return { code: \"\", result: error };\n      }\n    }\n  });\n\n  return { prompt, tools: { codemode: codemodeTool } };\n}\n\nfunction createEvaluator(\n  code: string,\n  options: {\n    loader: WorkerLoader;\n    proxy: Fetcher<CodeModeProxy>;\n  }\n) {\n  return async () => {\n    const worker = options.loader.get(`code-${Math.random()}`, () => {\n      return {\n        compatibilityDate: \"2025-06-01\",\n        compatibilityFlags: [\"nodejs_compat\"],\n        mainModule: \"foo.js\",\n        modules: {\n          \"foo.js\": `\nimport { env, WorkerEntrypoint } from \"cloudflare:workers\";\n\nexport default class CodeModeWorker extends WorkerEntrypoint {\n  async evaluate() {\n    try {\n      const { CodeModeProxy } = env;\n      const codemode = new Proxy(\n        {},\n        {\n          get: (target, prop) => {\n            return (args) => {\n              return CodeModeProxy.callFunction({\n                functionName: prop,\n                args: args,                \n              });\n            };\n          }\n        }\n      );\n\n      return await ${code}();\n    } catch (err) {\n      return {\n        err: err.message,\n        stack: err.stack\n      };\n    }\n  }\n}\n            \n        `\n        },\n        env: {\n          // insert keys and bindings to tools/ts functions here\n          CodeModeProxy: options.proxy\n        },\n        globalOutbound: null\n      };\n    });\n\n    // @ts-expect-error TODO: fix this\n    return await worker.getEntrypoint().evaluate();\n  };\n}\n\nasync function generateTypes(tools: ToolSet) {\n  let availableTools = \"\";\n  let availableTypes = \"\";\n\n  for (const [toolName, tool] of Object.entries(tools)) {\n    // @ts-expect-error TODO: fix this\n    const inputJsonType = tool.inputSchema.jsonSchema\n      ? await compileJsonSchemaToTs(\n          // @ts-expect-error TODO: fix this\n          tool.inputSchema.jsonSchema,\n          `${toCamelCase(toolName)}Input`,\n          {\n            format: false,\n            bannerComment: \" \"\n          }\n        )\n      : printNodeZodToTs(\n          createTypeAlias(\n            zodToTs(\n              // @ts-expect-error TODO: fix this\n              tool.inputSchema,\n              `${toCamelCase(toolName)}Input`\n            ).node,\n            `${toCamelCase(toolName)}Input`\n          )\n        );\n\n    const outputJsonType =\n      // @ts-expect-error TODO: fix this\n      tool.outputSchema?.jsonSchema\n        ? await compileJsonSchemaToTs(\n            // @ts-expect-error TODO: fix this\n            tool.outputSchema?.jsonSchema,\n            `${toCamelCase(toolName)}Output`,\n            {\n              format: false,\n              bannerComment: \" \"\n            }\n          )\n        : tool.outputSchema\n          ? printNodeZodToTs(\n              createTypeAlias(\n                zodToTs(\n                  // @ts-expect-error TODO: fix this\n                  tool.outputSchema,\n                  `${toCamelCase(toolName)}Output`\n                ).node,\n                `${toCamelCase(toolName)}Output`\n              )\n            )\n          : `interface ${toCamelCase(toolName)}Output { [key: string]: any }`;\n\n    const InputType = inputJsonType\n      .trim()\n      .replace(\"export interface\", \"interface\");\n\n    const OutputType = outputJsonType\n      .trim()\n      .replace(\"export interface\", \"interface\");\n\n    availableTypes += `\\n${InputType}`;\n    availableTypes += `\\n${OutputType}`;\n    availableTools += `\\n\\t/*\\n\\t${tool.description?.trim()}\\n\\t*/`;\n    availableTools += `\\n\\t${toolName}: (input: ${toCamelCase(toolName)}Input) => Promise<${toCamelCase(toolName)}Output>;`;\n    availableTools += \"\\n\";\n  }\n\n  availableTools = `\\ndeclare const codemode: {${availableTools}}`;\n\n  return `\n${availableTypes}\n${availableTools}\n      `;\n}\n\nfunction getToolDescriptions(tools: ToolSet) {\n  return Object.entries(tools)\n    .map(([_toolName, tool]) => {\n      return `\\n- ${tool.description?.trim()}`;\n    })\n    .join(\"\");\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAS,YAAY,KAAa;AAChC,QAAO,IACJ,QAAQ,cAAc,GAAG,WAAW,OAAO,aAAa,CAAC,CACzD,QAAQ,WAAW,WAAW,OAAO,aAAa,CAAC;;AAGxD,IAAa,gBAAb,cAAmC,iBAOjC;CACA,MAAM,aAAa,SAAoD;AAOrE,UANc,MAAM,eAElB,IAAI,KAAK,IAAI,MAAM,UACnB,KAAK,IAAI,MAAM,KAChB,EAEW,KAAK,IAAI,MAAM,UAAU,QAAQ,cAAc,QAAQ,KAAK;;;AAI5E,eAAsB,sBAAsB,SASzC;CACD,MAAM,iBAAiB,MAAM,cAAc,QAAQ,MAAM;AAqDzD,QAAO;EAAE,QApDM;;IAEb,oBAAoB,QAAQ,MAAM,CAAC;;;;;EAkDpB,OAAO,EAAE,UA5CL,KAAK;GACxB,aAAa;GACb,aAAa,EAAE,OAAO,EACpB,qBAAqB,EAAE,QAAQ,EAChC,CAAC;GACF,cAAc,EAAE,OAAO;IACrB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,KAAK;IAChB,CAAC;GACF,SAAS,OAAO,EAAE,0BAA0B;AAC1C,QAAI;KACF,MAAM,WAAW,MAAM,eAAe;MACpC,OAAO,OAAO,UAAU;MACxB,QAAQ,EAAE,OAAO,EACf,MAAM,EAAE,QAAQ,EACjB,CAAC;MACF,QAAQ;;;;QAIV,eAAe;;;;;;4BAMK;MACnB,CAAC;KAOF,MAAM,SAAS,MAJG,gBAAgB,SAAS,OAAO,MAAM;MACtD,OAAO,QAAQ;MACf,QAAQ,QAAQ;MACjB,CAAC,EAC8B;AAChC,YAAO;MAAE,MAAM,SAAS,OAAO;MAAc;MAAQ;aAC9C,OAAO;AACd,aAAQ,MAAM,SAAS,MAAM;AAC7B,WAAM;;;GAIX,CAAC,EAEgD;EAAE;;AAGtD,SAAS,gBACP,MACA,SAIA;AACA,QAAO,YAAY;AAiDjB,SAAO,MAhDQ,QAAQ,OAAO,IAAI,QAAQ,KAAK,QAAQ,UAAU;AAC/D,UAAO;IACL,mBAAmB;IACnB,oBAAoB,CAAC,gBAAgB;IACrC,YAAY;IACZ,SAAS,EACP,UAAU;;;;;;;;;;;;;;;;;;;;;qBAqBC,KAAK;;;;;;;;;;WAWjB;IACD,KAAK,EAEH,eAAe,QAAQ,OACxB;IACD,gBAAgB;IACjB;IACD,CAGkB,eAAe,CAAC,UAAU;;;AAIlD,eAAe,cAAc,OAAgB;CAC3C,IAAI,iBAAiB;CACrB,IAAI,iBAAiB;AAErB,MAAK,MAAM,CAAC,UAAUA,WAAS,OAAO,QAAQ,MAAM,EAAE;EAEpD,MAAM,gBAAgBA,OAAK,YAAY,aACnC,MAAMC,QAEJD,OAAK,YAAY,YACjB,GAAG,YAAY,SAAS,CAAC,QACzB;GACE,QAAQ;GACR,eAAe;GAChB,CACF,GACDE,UACE,gBACE,QAEEF,OAAK,aACL,GAAG,YAAY,SAAS,CAAC,OAC1B,CAAC,MACF,GAAG,YAAY,SAAS,CAAC,OAC1B,CACF;EAEL,MAAM,iBAEJA,OAAK,cAAc,aACf,MAAMC,QAEJD,OAAK,cAAc,YACnB,GAAG,YAAY,SAAS,CAAC,SACzB;GACE,QAAQ;GACR,eAAe;GAChB,CACF,GACDA,OAAK,eACHE,UACE,gBACE,QAEEF,OAAK,cACL,GAAG,YAAY,SAAS,CAAC,QAC1B,CAAC,MACF,GAAG,YAAY,SAAS,CAAC,QAC1B,CACF,GACD,aAAa,YAAY,SAAS,CAAC;EAE3C,MAAM,YAAY,cACf,MAAM,CACN,QAAQ,oBAAoB,YAAY;EAE3C,MAAM,aAAa,eAChB,MAAM,CACN,QAAQ,oBAAoB,YAAY;AAE3C,oBAAkB,KAAK;AACvB,oBAAkB,KAAK;AACvB,oBAAkB,aAAaA,OAAK,aAAa,MAAM,CAAC;AACxD,oBAAkB,OAAO,SAAS,YAAY,YAAY,SAAS,CAAC,oBAAoB,YAAY,SAAS,CAAC;AAC9G,oBAAkB;;AAGpB,kBAAiB,8BAA8B,eAAe;AAE9D,QAAO;EACP,eAAe;EACf,eAAe;;;AAIjB,SAAS,oBAAoB,OAAgB;AAC3C,QAAO,OAAO,QAAQ,MAAM,CACzB,KAAK,CAAC,WAAWA,YAAU;AAC1B,SAAO,OAAOA,OAAK,aAAa,MAAM;GACtC,CACD,KAAK,GAAG"}

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

@@ -0,0 +1,93 @@
+import { nanoid } from "nanoid";
+
+//#region 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;
+		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;
+		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 stateToken = nanoid();
+		authUrl.searchParams.set("state", stateToken);
+		this._authUrl_ = authUrl.toString();
+	}
+	codeVerifierKey(clientId) {
+		return `${this.keyPrefix(clientId)}/code_verifier`;
+	}
+	async saveCodeVerifier(verifier) {
+		const key = this.codeVerifierKey(this.clientId);
+		if (await this.storage.get(key)) return;
+		await this.storage.put(key, verifier);
+	}
+	async codeVerifier() {
+		const codeVerifier = await this.storage.get(this.codeVerifierKey(this.clientId));
+		if (!codeVerifier) throw new Error("No code verifier found");
+		return codeVerifier;
+	}
+};
+
+//#endregion
+export { DurableObjectOAuthClientProvider as t };
+//# sourceMappingURL=do-oauth-client-provider-CswoD5Lu.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"do-oauth-client-provider-CswoD5Lu.js","names":["storage: DurableObjectStorage","clientName: string","baseRedirectUrl: string"],"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\";\nimport { nanoid } from \"nanoid\";\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    // Generate secure random token for state parameter\n    const stateToken = nanoid();\n    authUrl.searchParams.set(\"state\", stateToken);\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    const key = this.codeVerifierKey(this.clientId);\n\n    // Don't overwrite existing verifier to preserve first PKCE verifier\n    const existing = await this.storage.get<string>(key);\n    if (existing) {\n      return;\n    }\n\n    await this.storage.put(key, 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":";;;AAiBA,IAAa,mCAAb,MAA6E;CAK3E,YACE,AAAOA,SACP,AAAOC,YACP,AAAOC,iBACP;EAHO;EACA;EACA;;CAGT,IAAI,iBAAsC;AACxC,SAAO;GACL,aAAa,KAAK;GAClB,YAAY,KAAK;GACjB,aAAa,CAAC,sBAAsB,gBAAgB;GACpD,eAAe,CAAC,KAAK,YAAY;GACjC,gBAAgB,CAAC,OAAO;GACxB,4BAA4B;GAC7B;;CAGH,IAAI,YAAY;AACd,SAAO,IAAI,IAAI,KAAK,YAAY,CAAC;;CAGnC,IAAI,cAAc;AAChB,SAAO,GAAG,KAAK,gBAAgB,GAAG,KAAK;;CAGzC,IAAI,WAAW;AACb,MAAI,CAAC,KAAK,WACR,OAAM,IAAI,MAAM,8CAA8C;AAEhE,SAAO,KAAK;;CAGd,IAAI,SAAS,WAAmB;AAC9B,OAAK,aAAa;;CAGpB,IAAI,WAAW;AACb,MAAI,CAAC,KAAK,WACR,OAAM,IAAI,MAAM,8CAA8C;AAEhE,SAAO,KAAK;;CAGd,IAAI,SAAS,WAAmB;AAC9B,OAAK,aAAa;;CAGpB,UAAU,UAAkB;AAC1B,SAAO,IAAI,KAAK,WAAW,GAAG,KAAK,SAAS,GAAG;;CAGjD,cAAc,UAAkB;AAC9B,SAAO,GAAG,KAAK,UAAU,SAAS,CAAC;;CAGrC,MAAM,oBAAiE;AACrE,MAAI,CAAC,KAAK,WACR;AAEF,SACG,MAAM,KAAK,QAAQ,IAClB,KAAK,cAAc,KAAK,SAAS,CAClC,IAAK;;CAIV,MAAM,sBACJ,mBACe;AACf,QAAM,KAAK,QAAQ,IACjB,KAAK,cAAc,kBAAkB,UAAU,EAC/C,kBACD;AACD,OAAK,WAAW,kBAAkB;;CAGpC,SAAS,UAAkB;AACzB,SAAO,GAAG,KAAK,UAAU,SAAS,CAAC;;CAGrC,MAAM,SAA2C;AAC/C,MAAI,CAAC,KAAK,WACR;AAEF,SACG,MAAM,KAAK,QAAQ,IAAiB,KAAK,SAAS,KAAK,SAAS,CAAC,IAClE;;CAIJ,MAAM,WAAW,QAAoC;AACnD,QAAM,KAAK,QAAQ,IAAI,KAAK,SAAS,KAAK,SAAS,EAAE,OAAO;;CAG9D,IAAI,UAAU;AACZ,SAAO,KAAK;;;;;;CAOd,MAAM,wBAAwB,SAA6B;EAEzD,MAAM,aAAa,QAAQ;AAC3B,UAAQ,aAAa,IAAI,SAAS,WAAW;AAC7C,OAAK,YAAY,QAAQ,UAAU;;CAGrC,gBAAgB,UAAkB;AAChC,SAAO,GAAG,KAAK,UAAU,SAAS,CAAC;;CAGrC,MAAM,iBAAiB,UAAiC;EACtD,MAAM,MAAM,KAAK,gBAAgB,KAAK,SAAS;AAI/C,MADiB,MAAM,KAAK,QAAQ,IAAY,IAAI,CAElD;AAGF,QAAM,KAAK,QAAQ,IAAI,KAAK,SAAS;;CAGvC,MAAM,eAAgC;EACpC,MAAM,eAAe,MAAM,KAAK,QAAQ,IACtC,KAAK,gBAAgB,KAAK,SAAS,CACpC;AACD,MAAI,CAAC,aACH,OAAM,IAAI,MAAM,yBAAyB;AAE3C,SAAO"}

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

@@ -0,0 +1,55 @@
+import { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import {
+  OAuthClientInformation,
+  OAuthClientInformationFull,
+  OAuthClientMetadata,
+  OAuthTokens
+} from "@modelcontextprotocol/sdk/shared/auth.js";
+
+//#region src/mcp/do-oauth-client-provider.d.ts
+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 clientUri(): string;
+  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>;
+}
+//#endregion
+export { DurableObjectOAuthClientProvider as n, AgentsOAuthProvider as t };
+//# sourceMappingURL=do-oauth-client-provider-DGc5pP0l.d.ts.map