agents 0.0.0-bcae0ba → 0.0.0-c3e8618

package/dist/mcp/index.d.ts

@@ -0,0 +1,41 @@
+import { DurableObject } from 'cloudflare:workers';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Connection } from 'partyserver';
+
+interface CORSOptions {
+    origin?: string;
+    methods?: string;
+    headers?: string;
+    maxAge?: number;
+}
+declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Record<string, unknown> = Record<string, unknown>> extends DurableObject<Env> {
+    #private;
+    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;
+    /**
+     * McpAgent API
+     */
+    abstract server: McpServer;
+    private transport;
+    props: Props;
+    initRun: boolean;
+    abstract init(): Promise<void>;
+    _init(props: Props): Promise<void>;
+    onSSE(path: string): Promise<Response>;
+    onMCPMessage(request: Request): Promise<Response>;
+    static mount(path: string, { binding, corsOptions, }?: {
+        binding?: string;
+        corsOptions?: CORSOptions;
+    }): {
+        fetch: (request: Request, env: Record<string, DurableObjectNamespace<McpAgent>>, ctx: ExecutionContext) => Promise<Response>;
+    };
+}
+
+export { McpAgent };

package/dist/react.d.ts

@@ -1,21 +1,18 @@
-import { PartySocket } from "partysocket";
-import { usePartySocket } from "partysocket/react";
-import { StreamOptions } from "./client.js";
+import { PartySocket } from 'partysocket';
+import { usePartySocket } from 'partysocket/react';
+import { StreamOptions } from './client.js';
 
 /**
  * Options for the useAgent hook
  * @template State Type of the Agent's state
  */
-type UseAgentOptions<State = unknown> = Omit<
-  Parameters<typeof usePartySocket>[0],
-  "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;
+type UseAgentOptions<State = unknown> = Omit<Parameters<typeof usePartySocket>[0], "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;
 };
 /**
  * React hook for connecting to an Agent
@@ -23,17 +20,11 @@ type UseAgentOptions<State = unknown> = Omit<
  * @param options Connection options
  * @returns WebSocket connection with setState and call methods
  */
-declare function useAgent<State = unknown>(
-  options: UseAgentOptions<State>
-): PartySocket & {
-  agent: string;
-  name: string;
-  setState: (state: State) => void;
-  call: <T = unknown>(
-    method: string,
-    args?: unknown[],
-    streamOptions?: StreamOptions
-  ) => Promise<T>;
+declare function useAgent<State = unknown>(options: UseAgentOptions<State>): PartySocket & {
+    agent: string;
+    name: string;
+    setState: (state: State) => void;
+    call: <T = unknown>(method: string, args?: unknown[], streamOptions?: StreamOptions) => Promise<T>;
 };
 
 export { type UseAgentOptions, useAgent };

package/dist/schedule.d.ts

@@ -1,53 +1,43 @@
-import { z } from "zod";
+import { z } from 'zod';
 
 type Schedule = z.infer<typeof unstable_scheduleSchema>;
-declare function unstable_getSchedulePrompt(event: { date: Date }): string;
-declare const unstable_scheduleSchema: z.ZodObject<
-  {
+declare function unstable_getSchedulePrompt(event: {
+    date: Date;
+}): string;
+declare const unstable_scheduleSchema: z.ZodObject<{
     description: z.ZodString;
-    when: z.ZodObject<
-      {
+    when: z.ZodObject<{
         type: z.ZodEnum<["scheduled", "delayed", "cron", "no-schedule"]>;
         date: z.ZodOptional<z.ZodDate>;
         delayInSeconds: z.ZodOptional<z.ZodNumber>;
         cron: z.ZodOptional<z.ZodString>;
-      },
-      "strip",
-      z.ZodTypeAny,
-      {
+    }, "strip", z.ZodTypeAny, {
         type: "scheduled" | "delayed" | "cron" | "no-schedule";
         cron?: string | undefined;
         delayInSeconds?: number | undefined;
         date?: Date | undefined;
-      },
-      {
+    }, {
         type: "scheduled" | "delayed" | "cron" | "no-schedule";
         cron?: string | undefined;
         delayInSeconds?: number | undefined;
         date?: Date | undefined;
-      }
-    >;
-  },
-  "strip",
-  z.ZodTypeAny,
-  {
+    }>;
+}, "strip", z.ZodTypeAny, {
     description: string;
     when: {
-      type: "scheduled" | "delayed" | "cron" | "no-schedule";
-      cron?: string | undefined;
-      delayInSeconds?: number | undefined;
-      date?: Date | undefined;
+        type: "scheduled" | "delayed" | "cron" | "no-schedule";
+        cron?: string | undefined;
+        delayInSeconds?: number | undefined;
+        date?: Date | undefined;
     };
-  },
-  {
+}, {
     description: string;
     when: {
-      type: "scheduled" | "delayed" | "cron" | "no-schedule";
-      cron?: string | undefined;
-      delayInSeconds?: number | undefined;
-      date?: Date | undefined;
+        type: "scheduled" | "delayed" | "cron" | "no-schedule";
+        cron?: string | undefined;
+        delayInSeconds?: number | undefined;
+        date?: Date | undefined;
     };
-  }
->;
+}>;
 
 export { type Schedule, unstable_getSchedulePrompt, unstable_scheduleSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents",
-  "version": "0.0.0-bcae0ba",
+  "version": "0.0.0-c3e8618",
   "main": "src/index.ts",
   "type": "module",
   "scripts": {
@@ -42,6 +42,16 @@
       "types": "./dist/schedule.d.ts",
       "require": "./dist/schedule.js",
       "import": "./dist/schedule.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "require": "./dist/mcp/index.js",
+      "import": "./dist/mcp/index.js"
+    },
+    "./mcp/client": {
+      "types": "./dist/mcp/client.d.ts",
+      "require": "./dist/mcp/client.js",
+      "import": "./dist/mcp/client.js"
     }
   },
   "keywords": [],
@@ -58,8 +68,11 @@
   "description": "A home for your AI agents",
   "dependencies": {
     "cron-schedule": "^5.0.4",
-    "nanoid": "^5.1.3",
-    "partyserver": "^0.0.65",
-    "partysocket": "0.0.0-548c226"
+    "nanoid": "^5.1.5",
+    "partyserver": "^0.0.66",
+    "partysocket": "1.1.3"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.8.0"
   }
 }

package/src/index.ts

@@ -11,6 +11,8 @@ import {
 import { parseCronExpression } from "cron-schedule";
 import { nanoid } from "nanoid";
 
+import { AsyncLocalStorage } from "node:async_hooks";
+
 export type { Connection, WSMessage, ConnectionContext } from "partyserver";
 
 import { WorkflowEntrypoint as CFWorkflowEntrypoint } from "cloudflare:workers";
@@ -168,6 +170,12 @@ const STATE_WAS_CHANGED = "cf_state_was_changed";
 
 const DEFAULT_STATE = {} as unknown;
 
+export const unstable_context = new AsyncLocalStorage<{
+  agent: Agent<unknown>;
+  connection: Connection | undefined;
+  request: Request | undefined;
+}>();
+
 /**
  * Base class for creating Agent implementations
  * @template Env Environment type containing bindings
@@ -256,7 +264,7 @@ export class Agent<Env, State = unknown> extends Server<Env> {
       return [...this.ctx.storage.sql.exec(query, ...values)] as T[];
     } catch (e) {
       console.error(`failed to execute sql query: ${query}`, e);
-      throw e;
+      throw this.onError(e);
     }
   }
   constructor(ctx: AgentContext, env: Env) {
@@ -270,7 +278,7 @@ export class Agent<Env, State = unknown> extends Server<Env> {
     `;
 
     void this.ctx.blockConcurrencyWhile(async () => {
-      try {
+      return this.#tryCatch(async () => {
         // Create alarms table if it doesn't exist
         this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_schedules (
@@ -287,97 +295,105 @@ export class Agent<Env, State = unknown> extends Server<Env> {
 
         // execute any pending alarms and schedule the next alarm
         await this.alarm();
-      } catch (e) {
-        console.error(e);
-        throw e;
-      }
+      });
     });
 
     const _onMessage = this.onMessage.bind(this);
     this.onMessage = async (connection: Connection, message: WSMessage) => {
-      if (typeof message !== "string") {
-        return _onMessage(connection, message);
-      }
-
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(message);
-      } catch (e) {
-        // silently fail and let the onMessage handler handle it
-        return _onMessage(connection, message);
-      }
-
-      if (isStateUpdateMessage(parsed)) {
-        this.#setStateInternal(parsed.state as State, connection);
-        return;
-      }
-
-      if (isRPCRequest(parsed)) {
-        try {
-          const { id, method, args } = parsed;
-
-          // Check if method exists and is callable
-          const methodFn = this[method as keyof this];
-          if (typeof methodFn !== "function") {
-            throw new Error(`Method ${method} does not exist`);
+      return unstable_context.run(
+        { agent: this, connection, request: undefined },
+        async () => {
+          if (typeof message !== "string") {
+            return this.#tryCatch(() => _onMessage(connection, message));
           }
 
-          if (!this.isCallable(method)) {
-            throw new Error(`Method ${method} is not callable`);
+          let parsed: unknown;
+          try {
+            parsed = JSON.parse(message);
+          } catch (e) {
+            // silently fail and let the onMessage handler handle it
+            return this.#tryCatch(() => _onMessage(connection, message));
           }
 
-          // biome-ignore lint/complexity/noBannedTypes: <explanation>
-          const metadata = callableMetadata.get(methodFn as Function);
+          if (isStateUpdateMessage(parsed)) {
+            this.#setStateInternal(parsed.state as State, connection);
+            return;
+          }
 
-          // For streaming methods, pass a StreamingResponse object
-          if (metadata?.streaming) {
-            const stream = new StreamingResponse(connection, id);
-            await methodFn.apply(this, [stream, ...args]);
+          if (isRPCRequest(parsed)) {
+            try {
+              const { id, method, args } = parsed;
+
+              // Check if method exists and is callable
+              const methodFn = this[method as keyof this];
+              if (typeof methodFn !== "function") {
+                throw new Error(`Method ${method} does not exist`);
+              }
+
+              if (!this.#isCallable(method)) {
+                throw new Error(`Method ${method} is not callable`);
+              }
+
+              // biome-ignore lint/complexity/noBannedTypes: <explanation>
+              const metadata = callableMetadata.get(methodFn as Function);
+
+              // For streaming methods, pass a StreamingResponse object
+              if (metadata?.streaming) {
+                const stream = new StreamingResponse(connection, id);
+                await methodFn.apply(this, [stream, ...args]);
+                return;
+              }
+
+              // For regular methods, execute and send response
+              const result = await methodFn.apply(this, args);
+              const response: RPCResponse = {
+                type: "rpc",
+                id,
+                success: true,
+                result,
+                done: true,
+              };
+              connection.send(JSON.stringify(response));
+            } catch (e) {
+              // Send error response
+              const response: RPCResponse = {
+                type: "rpc",
+                id: parsed.id,
+                success: false,
+                error:
+                  e instanceof Error ? e.message : "Unknown error occurred",
+              };
+              connection.send(JSON.stringify(response));
+              console.error("RPC error:", e);
+            }
             return;
           }
 
-          // For regular methods, execute and send response
-          const result = await methodFn.apply(this, args);
-          const response: RPCResponse = {
-            type: "rpc",
-            id,
-            success: true,
-            result,
-            done: true,
-          };
-          connection.send(JSON.stringify(response));
-        } catch (e) {
-          // Send error response
-          const response: RPCResponse = {
-            type: "rpc",
-            id: parsed.id,
-            success: false,
-            error: e instanceof Error ? e.message : "Unknown error occurred",
-          };
-          connection.send(JSON.stringify(response));
-          console.error("RPC error:", e);
+          return this.#tryCatch(() => _onMessage(connection, message));
         }
-        return;
-      }
-
-      return _onMessage(connection, message);
+      );
     };
 
     const _onConnect = this.onConnect.bind(this);
     this.onConnect = (connection: Connection, ctx: ConnectionContext) => {
       // TODO: This is a hack to ensure the state is sent after the connection is established
       // must fix this
-      setTimeout(() => {
-        if (this.state) {
-          connection.send(
-            JSON.stringify({
-              type: "cf_agent_state",
-              state: this.state,
-            })
-          );
+      return unstable_context.run(
+        { agent: this, connection, request: ctx.request },
+        async () => {
+          setTimeout(() => {
+            if (this.state) {
+              connection.send(
+                JSON.stringify({
+                  type: "cf_agent_state",
+                  state: this.state,
+                })
+              );
+            }
+            return this.#tryCatch(() => _onConnect(connection, ctx));
+          }, 20);
         }
-        _onConnect(connection, ctx);
-      }, 20);
+      );
     };
   }
 
@@ -398,7 +414,15 @@ export class Agent<Env, State = unknown> extends Server<Env> {
       }),
       source !== "server" ? [source.id] : []
     );
-    this.onStateUpdate(state, source);
+    return this.#tryCatch(() => {
+      const { connection, request } = unstable_context.getStore() || {};
+      return unstable_context.run(
+        { agent: this, connection, request },
+        async () => {
+          return this.onStateUpdate(state, source);
+        }
+      );
+    });
   }
 
   /**
@@ -423,7 +447,47 @@ export class Agent<Env, State = unknown> extends Server<Env> {
    * @param email Email message to process
    */
   onEmail(email: ForwardableEmailMessage) {
-    throw new Error("Not implemented");
+    return unstable_context.run(
+      { agent: this, connection: undefined, request: undefined },
+      async () => {
+        console.error("onEmail not implemented");
+      }
+    );
+  }
+
+  async #tryCatch<T>(fn: () => T | Promise<T>) {
+    try {
+      return await fn();
+    } catch (e) {
+      throw this.onError(e);
+    }
+  }
+
+  override onError(
+    connection: Connection,
+    error: unknown
+  ): void | Promise<void>;
+  override onError(error: unknown): void | Promise<void>;
+  override onError(connectionOrError: Connection | unknown, error?: unknown) {
+    let theError: unknown;
+    if (connectionOrError && error) {
+      theError = error;
+      // this is a websocket connection error
+      console.error(
+        "Error on websocket connection:",
+        (connectionOrError as Connection).id,
+        theError
+      );
+      console.error(
+        "Override onError(connection, error) to handle websocket connection errors"
+      );
+    } else {
+      theError = connectionOrError;
+      // this is a server error
+      console.error("Error on server:", theError);
+      console.error("Override onError(error) to handle server errors");
+    }
+    throw theError;
   }
 
   /**
@@ -465,7 +529,7 @@ export class Agent<Env, State = unknown> extends Server<Env> {
         )}, 'scheduled', ${timestamp})
       `;
 
-      await this.scheduleNextAlarm();
+      await this.#scheduleNextAlarm();
 
       return {
         id,
@@ -486,7 +550,7 @@ export class Agent<Env, State = unknown> extends Server<Env> {
         )}, 'delayed', ${when}, ${timestamp})
       `;
 
-      await this.scheduleNextAlarm();
+      await this.#scheduleNextAlarm();
 
       return {
         id,
@@ -508,7 +572,7 @@ export class Agent<Env, State = unknown> extends Server<Env> {
         )}, 'cron', ${when}, ${timestamp})
       `;
 
-      await this.scheduleNextAlarm();
+      await this.#scheduleNextAlarm();
 
       return {
         id,
@@ -532,7 +596,10 @@ export class Agent<Env, State = unknown> extends Server<Env> {
     const result = this.sql<Schedule<string>>`
       SELECT * FROM cf_agents_schedules WHERE id = ${id}
     `;
-    if (!result) return undefined;
+    if (!result) {
+      console.error(`schedule ${id} not found`);
+      return undefined;
+    }
 
     return { ...result[0], payload: JSON.parse(result[0].payload) as T };
   }
@@ -545,7 +612,6 @@ export class Agent<Env, State = unknown> extends Server<Env> {
    */
   getSchedules<T = string>(
     criteria: {
-      description?: string;
       id?: string;
       type?: "scheduled" | "delayed" | "cron";
       timeRange?: { start?: Date; end?: Date };
@@ -559,11 +625,6 @@ export class Agent<Env, State = unknown> extends Server<Env> {
       params.push(criteria.id);
     }
 
-    if (criteria.description) {
-      query += " AND description = ?";
-      params.push(criteria.description);
-    }
-
     if (criteria.type) {
       query += " AND type = ?";
       params.push(criteria.type);
@@ -598,11 +659,11 @@ export class Agent<Env, State = unknown> extends Server<Env> {
   async cancelSchedule(id: string): Promise<boolean> {
     this.sql`DELETE FROM cf_agents_schedules WHERE id = ${id}`;
 
-    await this.scheduleNextAlarm();
+    await this.#scheduleNextAlarm();
     return true;
   }
 
-  private async scheduleNextAlarm() {
+  async #scheduleNextAlarm() {
     // Find the next schedule that needs to be executed
     const result = this.sql`
       SELECT time FROM cf_agents_schedules 
@@ -636,16 +697,21 @@ export class Agent<Env, State = unknown> extends Server<Env> {
         console.error(`callback ${row.callback} not found`);
         continue;
       }
-      try {
-        (
-          callback as (
-            payload: unknown,
-            schedule: Schedule<unknown>
-          ) => Promise<void>
-        ).bind(this)(JSON.parse(row.payload as string), row);
-      } catch (e) {
-        console.error(`error executing callback ${row.callback}`, e);
-      }
+      await unstable_context.run(
+        { agent: this, connection: undefined, request: undefined },
+        async () => {
+          try {
+            await (
+              callback as (
+                payload: unknown,
+                schedule: Schedule<unknown>
+              ) => Promise<void>
+            ).bind(this)(JSON.parse(row.payload as string), row);
+          } catch (e) {
+            console.error(`error executing callback "${row.callback}"`, e);
+          }
+        }
+      );
       if (row.type === "cron") {
         // Update next execution time for cron schedules
         const nextExecutionTime = getNextCronTime(row.cron);
@@ -663,7 +729,7 @@ export class Agent<Env, State = unknown> extends Server<Env> {
     }
 
     // Schedule the next alarm
-    await this.scheduleNextAlarm();
+    await this.#scheduleNextAlarm();
   }
 
   /**
@@ -683,7 +749,7 @@ export class Agent<Env, State = unknown> extends Server<Env> {
    * Get all methods marked as callable on this Agent
    * @returns A map of method names to their metadata
    */
-  private isCallable(method: string): boolean {
+  #isCallable(method: string): boolean {
     // biome-ignore lint/complexity/noBannedTypes: <explanation>
     return callableMetadata.has(this[method as keyof this] as Function);
   }
@@ -756,7 +822,8 @@ export async function routeAgentRequest<Env>(
   if (
     response &&
     corsHeaders &&
-    request.headers.get("upgrade") !== "websocket"
+    request.headers.get("upgrade")?.toLowerCase() !== "websocket" &&
+    request.headers.get("Upgrade")?.toLowerCase() !== "websocket"
   ) {
     response = new Response(response.body, {
       headers: {