agents 0.0.0-b24b302 → 0.0.0-b30ffda

package/dist/react.d.ts

@@ -1,18 +1,21 @@
-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
@@ -20,11 +23,17 @@ type UseAgentOptions<State = unknown> = Omit<Parameters<typeof usePartySocket>[0
  * @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/react.js

@@ -0,0 +1,104 @@
+import "./chunk-HMLY7DHA.js";
+
+// src/react.tsx
+import { usePartySocket } from "partysocket/react";
+import { useCallback, useRef } from "react";
+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(/-$/, "");
+}
+function useAgent(options) {
+  const agentNamespace = camelCaseToKebabCase(options.agent);
+  const pendingCallsRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const agent = usePartySocket({
+    prefix: "agents",
+    party: agentNamespace,
+    room: options.name || "default",
+    ...options,
+    onMessage: (message) => {
+      if (typeof message.data === "string") {
+        let parsedMessage;
+        try {
+          parsedMessage = JSON.parse(message.data);
+        } catch (error) {
+          return options.onMessage?.(message);
+        }
+        if (parsedMessage.type === "cf_agent_state") {
+          options.onStateUpdate?.(parsedMessage.state, "server");
+          return;
+        }
+        if (parsedMessage.type === "rpc") {
+          const response = parsedMessage;
+          const pending = pendingCallsRef.current.get(response.id);
+          if (!pending) return;
+          if (!response.success) {
+            pending.reject(new Error(response.error));
+            pendingCallsRef.current.delete(response.id);
+            pending.stream?.onError?.(response.error);
+            return;
+          }
+          if ("done" in response) {
+            if (response.done) {
+              pending.resolve(response.result);
+              pendingCallsRef.current.delete(response.id);
+              pending.stream?.onDone?.(response.result);
+            } else {
+              pending.stream?.onChunk?.(response.result);
+            }
+          } else {
+            pending.resolve(response.result);
+            pendingCallsRef.current.delete(response.id);
+          }
+          return;
+        }
+      }
+      options.onMessage?.(message);
+    }
+  });
+  const call = useCallback(
+    (method, args = [], streamOptions) => {
+      return new Promise((resolve, reject) => {
+        const id = Math.random().toString(36).slice(2);
+        pendingCallsRef.current.set(id, {
+          resolve,
+          reject,
+          stream: streamOptions
+        });
+        const request = {
+          type: "rpc",
+          id,
+          method,
+          args
+        };
+        agent.send(JSON.stringify(request));
+      });
+    },
+    [agent]
+  );
+  agent.setState = (state) => {
+    agent.send(JSON.stringify({ type: "cf_agent_state", state }));
+    options.onStateUpdate?.(state, "client");
+  };
+  agent.call = call;
+  agent.agent = agentNamespace;
+  agent.name = options.name || "default";
+  if (agent.agent !== agent.agent.toLowerCase()) {
+    console.warn(
+      `Agent name: ${agent.agent} should probably be in lowercase. Received: ${agent.agent}`
+    );
+  }
+  return agent;
+}
+export {
+  useAgent
+};
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react.tsx"],"sourcesContent":["import type { PartySocket } from \"partysocket\";\nimport { usePartySocket } from \"partysocket/react\";\nimport { useCallback, useRef } from \"react\";\nimport type { RPCRequest, RPCResponse } from \"./\";\nimport type { StreamOptions } from \"./client\";\n\n/**\n * Convert a camelCase string to a kebab-case string\n * @param str The string to convert\n * @returns The kebab-case string\n */\nfunction camelCaseToKebabCase(str: string): string {\n  // If string is all uppercase, convert to lowercase\n  if (str === str.toUpperCase() && str !== str.toLowerCase()) {\n    return str.toLowerCase().replace(/_/g, \"-\");\n  }\n\n  // Otherwise handle camelCase to kebab-case\n  let kebabified = str.replace(\n    /[A-Z]/g,\n    (letter) => `-${letter.toLowerCase()}`\n  );\n  kebabified = kebabified.startsWith(\"-\") ? kebabified.slice(1) : kebabified;\n  // Convert any remaining underscores to hyphens and remove trailing -'s\n  return kebabified.replace(/_/g, \"-\").replace(/-$/, \"\");\n}\n\n/**\n * Options for the useAgent hook\n * @template State Type of the Agent's state\n */\nexport type UseAgentOptions<State = unknown> = Omit<\n  Parameters<typeof usePartySocket>[0],\n  \"party\" | \"room\"\n> & {\n  /** Name of the agent to connect to */\n  agent: string;\n  /** Name of the specific Agent instance */\n  name?: string;\n  /** Called when the Agent's state is updated */\n  onStateUpdate?: (state: State, source: \"server\" | \"client\") => void;\n};\n\n/**\n * React hook for connecting to an Agent\n * @template State Type of the Agent's state\n * @param options Connection options\n * @returns WebSocket connection with setState and call methods\n */\nexport function useAgent<State = unknown>(\n  options: UseAgentOptions<State>\n): PartySocket & {\n  agent: string;\n  name: string;\n  setState: (state: State) => void;\n  call: <T = unknown>(\n    method: string,\n    args?: unknown[],\n    streamOptions?: StreamOptions\n  ) => Promise<T>;\n} {\n  const agentNamespace = camelCaseToKebabCase(options.agent);\n  // Keep track of pending RPC calls\n  const pendingCallsRef = useRef(\n    new Map<\n      string,\n      {\n        resolve: (value: unknown) => void;\n        reject: (error: Error) => void;\n        stream?: StreamOptions;\n      }\n    >()\n  );\n\n  // TODO: if options.query is a function, then use\n  // \"use()\" to get the value and pass it\n  // as a query parameter to usePartySocket\n  const agent = usePartySocket({\n    prefix: \"agents\",\n    party: agentNamespace,\n    room: options.name || \"default\",\n    ...options,\n    onMessage: (message) => {\n      if (typeof message.data === \"string\") {\n        let parsedMessage: Record<string, unknown>;\n        try {\n          parsedMessage = JSON.parse(message.data);\n        } catch (error) {\n          // silently ignore invalid messages for now\n          // TODO: log errors with log levels\n          return options.onMessage?.(message);\n        }\n        if (parsedMessage.type === \"cf_agent_state\") {\n          options.onStateUpdate?.(parsedMessage.state as State, \"server\");\n          return;\n        }\n        if (parsedMessage.type === \"rpc\") {\n          const response = parsedMessage as RPCResponse;\n          const pending = pendingCallsRef.current.get(response.id);\n          if (!pending) return;\n\n          if (!response.success) {\n            pending.reject(new Error(response.error));\n            pendingCallsRef.current.delete(response.id);\n            pending.stream?.onError?.(response.error);\n            return;\n          }\n\n          // Handle streaming responses\n          if (\"done\" in response) {\n            if (response.done) {\n              pending.resolve(response.result);\n              pendingCallsRef.current.delete(response.id);\n              pending.stream?.onDone?.(response.result);\n            } else {\n              pending.stream?.onChunk?.(response.result);\n            }\n          } else {\n            // Non-streaming response\n            pending.resolve(response.result);\n            pendingCallsRef.current.delete(response.id);\n          }\n          return;\n        }\n      }\n      options.onMessage?.(message);\n    },\n  }) as PartySocket & {\n    agent: string;\n    name: string;\n    setState: (state: State) => void;\n    call: <T = unknown>(\n      method: string,\n      args?: unknown[],\n      streamOptions?: StreamOptions\n    ) => Promise<T>;\n  };\n  // Create the call method\n  const call = useCallback(\n    <T = unknown,>(\n      method: string,\n      args: unknown[] = [],\n      streamOptions?: StreamOptions\n    ): Promise<T> => {\n      return new Promise((resolve, reject) => {\n        const id = Math.random().toString(36).slice(2);\n        pendingCallsRef.current.set(id, {\n          resolve: resolve as (value: unknown) => void,\n          reject,\n          stream: streamOptions,\n        });\n\n        const request: RPCRequest = {\n          type: \"rpc\",\n          id,\n          method,\n          args,\n        };\n\n        agent.send(JSON.stringify(request));\n      });\n    },\n    [agent]\n  );\n\n  agent.setState = (state: State) => {\n    agent.send(JSON.stringify({ type: \"cf_agent_state\", state }));\n    options.onStateUpdate?.(state, \"client\");\n  };\n\n  agent.call = call;\n  agent.agent = agentNamespace;\n  agent.name = options.name || \"default\";\n\n  // warn if agent isn't in lowercase\n  if (agent.agent !== agent.agent.toLowerCase()) {\n    console.warn(\n      `Agent name: ${agent.agent} should probably be in lowercase. Received: ${agent.agent}`\n    );\n  }\n\n  return agent;\n}\n"],"mappings":"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","names":[]}

package/dist/schedule.d.ts

@@ -1,43 +1,53 @@
-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/dist/schedule.js

@@ -0,0 +1,73 @@
+import "./chunk-HMLY7DHA.js";
+
+// src/schedule.ts
+import { z } from "zod";
+function unstable_getSchedulePrompt(event) {
+  return `
+[Schedule Parser Component]
+
+Current time: ${event.date.toUTCString()}
+
+This component parses natural language scheduling requests into a structured format. It extracts:
+1. A clean task description (without timing information)
+2. Scheduling details in one of these formats:
+   - scheduled: Specific date/time events
+   - delayed: Relative time delays (in seconds)
+   - cron: Recurring patterns
+   - no-schedule: Tasks without timing
+
+Rules:
+- Task descriptions should be clean and focused on the action
+- Use numbers (0-6) for days in cron patterns (0=Sunday)
+- For recurring tasks, use standard cron syntax
+- For relative times, convert to seconds
+- For specific dates, use the current time as reference
+
+Example outputs:
+{
+  "description": "meeting with team",
+  "when": {
+    "type": "scheduled",
+    "date": "tomorrow at 14:00"
+  }
+}
+
+{
+  "description": "backup database",
+  "when": {
+    "type": "cron",
+    "cron": "0 0 * * *"
+  }
+}
+
+{
+  "description": "send report",
+  "when": {
+    "type": "delayed",
+    "delayInSeconds": 1800
+  }
+}
+
+[End Schedule Parser Component]
+`;
+}
+var unstable_scheduleSchema = z.object({
+  description: z.string().describe("A description of the task"),
+  when: z.object({
+    type: z.enum(["scheduled", "delayed", "cron", "no-schedule"]).describe("The type of scheduling details"),
+    date: z.coerce.date().optional().describe(
+      "execute task at the specified date and time (only use if the type is scheduled)"
+    ),
+    delayInSeconds: z.number().optional().describe(
+      "execute task after a delay in seconds (only use if the type is delayed)"
+    ),
+    cron: z.string().optional().describe(
+      "execute task on a recurring interval specified as cron syntax (only use if the type is cron)"
+    )
+  })
+});
+export {
+  unstable_getSchedulePrompt,
+  unstable_scheduleSchema
+};
+//# sourceMappingURL=schedule.js.map

package/dist/schedule.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schedule.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport type Schedule = z.infer<typeof unstable_scheduleSchema>;\n\nexport function unstable_getSchedulePrompt(event: { date: Date }) {\n  return `\n[Schedule Parser Component]\n\nCurrent time: ${event.date.toUTCString()}\n\nThis component parses natural language scheduling requests into a structured format. It extracts:\n1. A clean task description (without timing information)\n2. Scheduling details in one of these formats:\n   - scheduled: Specific date/time events\n   - delayed: Relative time delays (in seconds)\n   - cron: Recurring patterns\n   - no-schedule: Tasks without timing\n\nRules:\n- Task descriptions should be clean and focused on the action\n- Use numbers (0-6) for days in cron patterns (0=Sunday)\n- For recurring tasks, use standard cron syntax\n- For relative times, convert to seconds\n- For specific dates, use the current time as reference\n\nExample outputs:\n{\n  \"description\": \"meeting with team\",\n  \"when\": {\n    \"type\": \"scheduled\",\n    \"date\": \"tomorrow at 14:00\"\n  }\n}\n\n{\n  \"description\": \"backup database\",\n  \"when\": {\n    \"type\": \"cron\",\n    \"cron\": \"0 0 * * *\"\n  }\n}\n\n{\n  \"description\": \"send report\",\n  \"when\": {\n    \"type\": \"delayed\",\n    \"delayInSeconds\": 1800\n  }\n}\n\n[End Schedule Parser Component]\n`;\n}\n\nexport const unstable_scheduleSchema = z.object({\n  description: z.string().describe(\"A description of the task\"),\n  when: z.object({\n    type: z\n      .enum([\"scheduled\", \"delayed\", \"cron\", \"no-schedule\"])\n      .describe(\"The type of scheduling details\"),\n    date: z.coerce\n      .date()\n      .optional()\n      .describe(\n        \"execute task at the specified date and time (only use if the type is scheduled)\"\n      ),\n    delayInSeconds: z\n      .number()\n      .optional()\n      .describe(\n        \"execute task after a delay in seconds (only use if the type is delayed)\"\n      ),\n    cron: z\n      .string()\n      .optional()\n      .describe(\n        \"execute task on a recurring interval specified as cron syntax (only use if the type is cron)\"\n      ),\n  }),\n});\n"],"mappings":";;;AAAA,SAAS,SAAS;AAIX,SAAS,2BAA2B,OAAuB;AAChE,SAAO;AAAA;AAAA;AAAA,gBAGO,MAAM,KAAK,YAAY,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4CxC;AAEO,IAAM,0BAA0B,EAAE,OAAO;AAAA,EAC9C,aAAa,EAAE,OAAO,EAAE,SAAS,2BAA2B;AAAA,EAC5D,MAAM,EAAE,OAAO;AAAA,IACb,MAAM,EACH,KAAK,CAAC,aAAa,WAAW,QAAQ,aAAa,CAAC,EACpD,SAAS,gCAAgC;AAAA,IAC5C,MAAM,EAAE,OACL,KAAK,EACL,SAAS,EACT;AAAA,MACC;AAAA,IACF;AAAA,IACF,gBAAgB,EACb,OAAO,EACP,SAAS,EACT;AAAA,MACC;AAAA,IACF;AAAA,IACF,MAAM,EACH,OAAO,EACP,SAAS,EACT;AAAA,MACC;AAAA,IACF;AAAA,EACJ,CAAC;AACH,CAAC;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents",
-  "version": "0.0.0-b24b302",
+  "version": "0.0.0-b30ffda",
   "main": "src/index.ts",
   "type": "module",
   "scripts": {
@@ -38,6 +38,11 @@
       "require": "./dist/ai-chat-agent.js",
       "import": "./dist/ai-chat-agent.js"
     },
+    "./ai-types": {
+      "types": "./dist/ai-types.d.ts",
+      "require": "./dist/ai-types.js",
+      "import": "./dist/ai-types.js"
+    },
     "./schedule": {
       "types": "./dist/schedule.d.ts",
       "require": "./dist/schedule.js",
@@ -52,6 +57,11 @@
       "types": "./dist/mcp/client.d.ts",
       "require": "./dist/mcp/client.js",
       "import": "./dist/mcp/client.js"
+    },
+    "./mcp/do-oauth-client-provider": {
+      "types": "./dist/mcp/do-oauth-client-provider.d.ts",
+      "require": "./dist/mcp/do-oauth-client-provider.js",
+      "import": "./dist/mcp/do-oauth-client-provider.js"
     }
   },
   "keywords": [],
@@ -67,12 +77,10 @@
   "license": "MIT",
   "description": "A home for your AI agents",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.9.0",
     "cron-schedule": "^5.0.4",
     "nanoid": "^5.1.5",
     "partyserver": "^0.0.66",
     "partysocket": "1.1.3"
-  },
-  "devDependencies": {
-    "@modelcontextprotocol/sdk": "^1.8.0"
   }
 }

package/src/index.ts

@@ -15,8 +15,6 @@ import { AsyncLocalStorage } from "node:async_hooks";
 
 export type { Connection, WSMessage, ConnectionContext } from "partyserver";
 
-import { WorkflowEntrypoint as CFWorkflowEntrypoint } from "cloudflare:workers";
-
 /**
  * RPC request message from client
  */
@@ -119,11 +117,6 @@ export function unstable_callable(metadata: CallableMetadata = {}) {
   };
 }
 
-/**
- * A class for creating workflow entry points that can be used with Cloudflare Workers
- */
-export class WorkflowEntrypoint extends CFWorkflowEntrypoint {}
-
 /**
  * Represents a scheduled task within an Agent
  * @template T Type of the payload data