agents 0.0.0-dfa677f → 0.0.0-e19fea6

package/dist/mcp-BH1fJeiU.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Base event structure for all observability events
+ */
+type BaseEvent<
+  T extends string,
+  Payload extends Record<string, unknown> = {}
+> = {
+  type: T;
+  /**
+   * The unique identifier for the event
+   */
+  id: string;
+  /**
+   * The message to display in the logs for this event, should the implementation choose to display
+   * a human-readable message.
+   */
+  displayMessage: string;
+  /**
+   * The payload of the event
+   */
+  payload: Payload & Record<string, unknown>;
+  /**
+   * The timestamp of the event in milliseconds since epoch
+   */
+  timestamp: number;
+};
+
+/**
+ * MCP-specific observability events
+ * These track the lifecycle of MCP connections and operations
+ */
+type MCPObservabilityEvent =
+  | BaseEvent<
+      "mcp:client:preconnect",
+      {
+        serverId: string;
+      }
+    >
+  | BaseEvent<
+      "mcp:client:connect",
+      {
+        url: string;
+        transport: string;
+        state: string;
+        error?: string;
+      }
+    >
+  | BaseEvent<
+      "mcp:client:authorize",
+      {
+        serverId: string;
+        authUrl: string;
+        clientId?: string;
+      }
+    >
+  | BaseEvent<"mcp:client:discover", {}>;
+
+export type { BaseEvent as B, MCPObservabilityEvent as M };

package/dist/observability/index.d.ts

@@ -0,0 +1,34 @@
+import { B as BaseEvent, M as MCPObservabilityEvent } from '../mcp-BH1fJeiU.js';
+
+/**
+ * Agent-specific observability events
+ * These track the lifecycle and operations of an Agent
+ */
+type AgentObservabilityEvent = BaseEvent<"state:update", {}> | BaseEvent<"rpc", {
+    method: string;
+    streaming?: boolean;
+}> | BaseEvent<"message:request" | "message:response", {}> | BaseEvent<"message:clear"> | BaseEvent<"schedule:create" | "schedule:execute" | "schedule:cancel", {
+    callback: string;
+    id: string;
+}> | BaseEvent<"destroy"> | BaseEvent<"connect", {
+    connectionId: string;
+}>;
+
+/**
+ * Union of all observability event types from different domains
+ */
+type ObservabilityEvent = AgentObservabilityEvent | MCPObservabilityEvent;
+interface Observability {
+    /**
+     * Emit an event for the Agent's observability implementation to handle.
+     * @param event - The event to emit
+     * @param ctx - The execution context of the invocation (optional)
+     */
+    emit(event: ObservabilityEvent, ctx?: DurableObjectState): void;
+}
+/**
+ * A generic observability implementation that logs events to the console.
+ */
+declare const genericObservability: Observability;
+
+export { type Observability, type ObservabilityEvent, genericObservability };

package/dist/observability/index.js

@@ -0,0 +1,12 @@
+import {
+  genericObservability
+} from "../chunk-254F4GDT.js";
+import "../chunk-3OT2NNEW.js";
+import "../chunk-Z44WASMA.js";
+import "../chunk-QEVM4BVL.js";
+import "../chunk-BER7KXUJ.js";
+import "../chunk-PR4QN5HX.js";
+export {
+  genericObservability
+};
+//# sourceMappingURL=index.js.map

package/dist/observability/index.js.map

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

package/dist/react.d.ts

@@ -1,27 +1,104 @@
 import { PartySocket } from "partysocket";
 import { usePartySocket } from "partysocket/react";
+import { MCPServersState, Agent } from "./index.js";
 import { StreamOptions } from "./client.js";
+import { Method, RPCMethod } from "./serializable.js";
+import "cloudflare:workers";
+import "@modelcontextprotocol/sdk/client/index.js";
+import "@modelcontextprotocol/sdk/types.js";
+import "partyserver";
+import "./client-DVoPb3-C.js";
+import "zod";
+import "@modelcontextprotocol/sdk/shared/protocol.js";
+import "ai";
+import "./mcp-BH1fJeiU.js";
+import "@modelcontextprotocol/sdk/client/sse.js";
+import "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import "./mcp/do-oauth-client-provider.js";
+import "@modelcontextprotocol/sdk/client/auth.js";
+import "@modelcontextprotocol/sdk/shared/auth.js";
+import "./observability/index.js";
+import "./ai-types.js";
 
+type QueryObject = Record<string, string | null>;
 /**
  * Options for the useAgent hook
  * @template State Type of the Agent's state
  */
 type UseAgentOptions<State = unknown> = Omit<
   Parameters<typeof usePartySocket>[0],
-  "party" | "room"
+  "party" | "room" | "query"
 > & {
   /** Name of the agent to connect to */
   agent: string;
   /** Name of the specific Agent instance */
   name?: string;
+  /** Query parameters - can be static object or async function */
+  query?: QueryObject | (() => Promise<QueryObject>);
+  /** Dependencies for async query caching */
+  queryDeps?: unknown[];
+  /** Cache TTL in milliseconds for auth tokens/time-sensitive data */
+  cacheTtl?: number;
   /** Called when the Agent's state is updated */
   onStateUpdate?: (state: State, source: "server" | "client") => void;
+  /** Called when MCP server state is updated */
+  onMcpUpdate?: (mcpServers: MCPServersState) => void;
 };
+type AllOptional<T> = T extends [infer A, ...infer R]
+  ? undefined extends A
+    ? AllOptional<R>
+    : false
+  : true;
+type RPCMethods<T> = {
+  [K in keyof T as T[K] extends RPCMethod<T[K]> ? K : never]: RPCMethod<T[K]>;
+};
+type OptionalParametersMethod<T extends RPCMethod> =
+  AllOptional<Parameters<T>> extends true ? T : never;
+type AgentMethods<T> = Omit<RPCMethods<T>, keyof Agent<any, any>>;
+type OptionalAgentMethods<T> = {
+  [K in keyof AgentMethods<T> as AgentMethods<T>[K] extends OptionalParametersMethod<
+    AgentMethods<T>[K]
+  >
+    ? K
+    : never]: OptionalParametersMethod<AgentMethods<T>[K]>;
+};
+type RequiredAgentMethods<T> = Omit<
+  AgentMethods<T>,
+  keyof OptionalAgentMethods<T>
+>;
+type AgentPromiseReturnType<T, K extends keyof AgentMethods<T>> =
+  ReturnType<AgentMethods<T>[K]> extends Promise<any>
+    ? ReturnType<AgentMethods<T>[K]>
+    : Promise<ReturnType<AgentMethods<T>[K]>>;
+type OptionalArgsAgentMethodCall<AgentT> = <
+  K extends keyof OptionalAgentMethods<AgentT>
+>(
+  method: K,
+  args?: Parameters<OptionalAgentMethods<AgentT>[K]>,
+  streamOptions?: StreamOptions
+) => AgentPromiseReturnType<AgentT, K>;
+type RequiredArgsAgentMethodCall<AgentT> = <
+  K extends keyof RequiredAgentMethods<AgentT>
+>(
+  method: K,
+  args: Parameters<RequiredAgentMethods<AgentT>[K]>,
+  streamOptions?: StreamOptions
+) => AgentPromiseReturnType<AgentT, K>;
+type AgentMethodCall<AgentT> = OptionalArgsAgentMethodCall<AgentT> &
+  RequiredArgsAgentMethodCall<AgentT>;
+type UntypedAgentMethodCall = <T = unknown>(
+  method: string,
+  args?: unknown[],
+  streamOptions?: StreamOptions
+) => Promise<T>;
+type AgentStub<T> = {
+  [K in keyof AgentMethods<T>]: (
+    ...args: Parameters<AgentMethods<T>[K]>
+  ) => AgentPromiseReturnType<AgentMethods<T>, K>;
+};
+type UntypedAgentStub = Record<string, Method>;
 /**
  * React hook for connecting to an Agent
- * @template State Type of the Agent's state
- * @param options Connection options
- * @returns WebSocket connection with setState and call methods
  */
 declare function useAgent<State = unknown>(
   options: UseAgentOptions<State>
@@ -29,11 +106,22 @@ declare function useAgent<State = unknown>(
   agent: string;
   name: string;
   setState: (state: State) => void;
-  call: <T = unknown>(
-    method: string,
-    args?: unknown[],
-    streamOptions?: StreamOptions
-  ) => Promise<T>;
+  call: UntypedAgentMethodCall;
+  stub: UntypedAgentStub;
+};
+declare function useAgent<
+  AgentT extends {
+    get state(): State;
+  },
+  State
+>(
+  options: UseAgentOptions<State>
+): PartySocket & {
+  agent: string;
+  name: string;
+  setState: (state: State) => void;
+  call: AgentMethodCall<AgentT>;
+  stub: AgentStub<AgentT>;
 };
 
 export { type UseAgentOptions, useAgent };

package/dist/react.js

@@ -1,50 +1,144 @@
-import "./chunk-HMLY7DHA.js";
+import "./chunk-BER7KXUJ.js";
+import "./chunk-PR4QN5HX.js";
 
 // src/react.tsx
 import { usePartySocket } from "partysocket/react";
-import { useCallback, useRef } from "react";
+import { useCallback, useRef, use, useMemo, useEffect } 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(/-$/, "");
+}
+var queryCache = /* @__PURE__ */ new Map();
+function arraysEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!Object.is(a[i], b[i])) return false;
+  }
+  return true;
+}
+function findCacheEntry(targetKey) {
+  for (const [existingKey, entry] of queryCache.entries()) {
+    if (arraysEqual(existingKey, targetKey)) {
+      if (Date.now() > entry.expiresAt) {
+        queryCache.delete(existingKey);
+        return void 0;
+      }
+      entry.refCount++;
+      return entry.promise;
+    }
+  }
+  return void 0;
+}
+function setCacheEntry(key, value, cacheTtl) {
+  for (const [existingKey] of queryCache.entries()) {
+    if (arraysEqual(existingKey, key)) {
+      queryCache.delete(existingKey);
+      break;
+    }
+  }
+  const expiresAt = cacheTtl ? Date.now() + cacheTtl : Date.now() + 5 * 60 * 1e3;
+  queryCache.set(key, { promise: value, refCount: 1, expiresAt, cacheTtl });
+}
+function decrementCacheEntry(targetKey) {
+  for (const [existingKey, entry] of queryCache.entries()) {
+    if (arraysEqual(existingKey, targetKey)) {
+      entry.refCount--;
+      if (entry.refCount <= 0) {
+        queryCache.delete(existingKey);
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function createCacheKey(agentNamespace, name, deps) {
+  return [agentNamespace, name || "default", ...deps];
+}
 function useAgent(options) {
+  const agentNamespace = camelCaseToKebabCase(options.agent);
+  const { query, queryDeps, cacheTtl, ...restOptions } = options;
   const pendingCallsRef = useRef(
     /* @__PURE__ */ new Map()
   );
-  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));
-      });
-    },
-    []
-  );
+  const cacheKey = useMemo(() => {
+    const deps = queryDeps || [];
+    return createCacheKey(agentNamespace, options.name, deps);
+  }, [agentNamespace, options.name, queryDeps]);
+  const queryPromise = useMemo(() => {
+    if (!query || typeof query !== "function") {
+      return null;
+    }
+    const existingPromise = findCacheEntry(cacheKey);
+    if (existingPromise) {
+      return existingPromise;
+    }
+    const promise = query().catch((error) => {
+      console.error(
+        `[useAgent] Query failed for agent "${options.agent}":`,
+        error
+      );
+      decrementCacheEntry(cacheKey);
+      throw error;
+    });
+    setCacheEntry(cacheKey, promise, cacheTtl);
+    return promise;
+  }, [cacheKey, query, options.agent, cacheTtl]);
+  let resolvedQuery;
+  if (query) {
+    if (typeof query === "function") {
+      const queryResult = use(queryPromise);
+      if (queryResult) {
+        for (const [key, value] of Object.entries(queryResult)) {
+          if (value !== null && value !== void 0 && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+            console.warn(
+              `[useAgent] Query parameter "${key}" is an object and will be converted to "[object Object]". Query parameters should be string, number, boolean, or null.`
+            );
+          }
+        }
+        resolvedQuery = queryResult;
+      }
+    } else {
+      resolvedQuery = query;
+    }
+  }
+  useEffect(() => {
+    return () => {
+      if (queryPromise) {
+        decrementCacheEntry(cacheKey);
+      }
+    };
+  }, [cacheKey, queryPromise]);
   const agent = usePartySocket({
+    party: agentNamespace,
     prefix: "agents",
-    party: options.agent,
     room: options.name || "default",
-    ...options,
+    query: resolvedQuery,
+    ...restOptions,
     onMessage: (message) => {
       if (typeof message.data === "string") {
         let parsedMessage;
         try {
           parsedMessage = JSON.parse(message.data);
-        } catch (error) {
+        } catch (_error) {
           return options.onMessage?.(message);
         }
-        if (parsedMessage.type === "cf_agent_state") {
+        if (parsedMessage.type === "cf_agent_state" /* CF_AGENT_STATE */) {
           options.onStateUpdate?.(parsedMessage.state, "server");
           return;
         }
-        if (parsedMessage.type === "rpc") {
+        if (parsedMessage.type === "cf_agent_mcp_servers" /* CF_AGENT_MCP_SERVERS */) {
+          options.onMcpUpdate?.(parsedMessage.mcp);
+          return;
+        }
+        if (parsedMessage.type === "rpc" /* RPC */) {
           const response = parsedMessage;
           const pending = pendingCallsRef.current.get(response.id);
           if (!pending) return;
@@ -72,23 +166,48 @@ function useAgent(options) {
       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, {
+          reject,
+          resolve,
+          stream: streamOptions
+        });
+        const request = {
+          args,
+          id,
+          method,
+          type: "rpc" /* RPC */
+        };
+        agent.send(JSON.stringify(request));
+      });
+    },
+    [agent]
+  );
   agent.setState = (state) => {
-    agent.send(JSON.stringify({ type: "cf_agent_state", state }));
+    agent.send(JSON.stringify({ state, type: "cf_agent_state" /* CF_AGENT_STATE */ }));
     options.onStateUpdate?.(state, "client");
   };
   agent.call = call;
-  agent.agent = options.agent;
+  agent.agent = agentNamespace;
   agent.name = options.name || "default";
+  agent.stub = new Proxy(
+    {},
+    {
+      get: (_target, method) => {
+        return (...args) => {
+          return call(method, args);
+        };
+      }
+    }
+  );
   if (agent.agent !== agent.agent.toLowerCase()) {
     console.warn(
       `Agent name: ${agent.agent} should probably be in lowercase. Received: ${agent.agent}`
     );
   }
-  if (agent.name !== agent.name.toLowerCase()) {
-    console.warn(
-      `Agent instance name: ${agent.name} should probably be in lowercase. Received: ${agent.name}`
-    );
-  }
   return agent;
 }
 export {

package/dist/react.js.map

@@ -1 +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 * 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  // 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  // 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    []\n  );\n\n  const agent = usePartySocket({\n    prefix: \"agents\",\n    party: options.agent,\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\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 = options.agent;\n  agent.name = options.name || \"default\";\n\n  // warn if agent or name 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  if (agent.name !== agent.name.toLowerCase()) {\n    console.warn(\n      `Agent instance name: ${agent.name} should probably be in lowercase. Received: ${agent.name}`\n    );\n  }\n\n  return agent;\n}\n"],"mappings":";;;AACA,SAAS,sBAAsB;AAC/B,SAAS,aAAa,cAAc;AA0B7B,SAAS,SACd,SAUA;AAEA,QAAM,kBAAkB;AAAA,IACtB,oBAAI,IAOF;AAAA,EACJ;AAGA,QAAM,OAAO;AAAA,IACX,CACE,QACA,OAAkB,CAAC,GACnB,kBACe;AACf,aAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,cAAM,KAAK,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC;AAC7C,wBAAgB,QAAQ,IAAI,IAAI;AAAA,UAC9B;AAAA,UACA;AAAA,UACA,QAAQ;AAAA,QACV,CAAC;AAED,cAAM,UAAsB;AAAA,UAC1B,MAAM;AAAA,UACN;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAEA,cAAM,KAAK,KAAK,UAAU,OAAO,CAAC;AAAA,MACpC,CAAC;AAAA,IACH;AAAA,IACA,CAAC;AAAA,EACH;AAEA,QAAM,QAAQ,eAAe;AAAA,IAC3B,QAAQ;AAAA,IACR,OAAO,QAAQ;AAAA,IACf,MAAM,QAAQ,QAAQ;AAAA,IACtB,GAAG;AAAA,IACH,WAAW,CAAC,YAAY;AACtB,UAAI,OAAO,QAAQ,SAAS,UAAU;AACpC,YAAI;AACJ,YAAI;AACF,0BAAgB,KAAK,MAAM,QAAQ,IAAI;AAAA,QACzC,SAAS,OAAO;AAGd,iBAAO,QAAQ,YAAY,OAAO;AAAA,QACpC;AACA,YAAI,cAAc,SAAS,kBAAkB;AAC3C,kBAAQ,gBAAgB,cAAc,OAAgB,QAAQ;AAC9D;AAAA,QACF;AACA,YAAI,cAAc,SAAS,OAAO;AAChC,gBAAM,WAAW;AACjB,gBAAM,UAAU,gBAAgB,QAAQ,IAAI,SAAS,EAAE;AACvD,cAAI,CAAC,QAAS;AAEd,cAAI,CAAC,SAAS,SAAS;AACrB,oBAAQ,OAAO,IAAI,MAAM,SAAS,KAAK,CAAC;AACxC,4BAAgB,QAAQ,OAAO,SAAS,EAAE;AAC1C,oBAAQ,QAAQ,UAAU,SAAS,KAAK;AACxC;AAAA,UACF;AAGA,cAAI,UAAU,UAAU;AACtB,gBAAI,SAAS,MAAM;AACjB,sBAAQ,QAAQ,SAAS,MAAM;AAC/B,8BAAgB,QAAQ,OAAO,SAAS,EAAE;AAC1C,sBAAQ,QAAQ,SAAS,SAAS,MAAM;AAAA,YAC1C,OAAO;AACL,sBAAQ,QAAQ,UAAU,SAAS,MAAM;AAAA,YAC3C;AAAA,UACF,OAAO;AAEL,oBAAQ,QAAQ,SAAS,MAAM;AAC/B,4BAAgB,QAAQ,OAAO,SAAS,EAAE;AAAA,UAC5C;AACA;AAAA,QACF;AAAA,MACF;AACA,cAAQ,YAAY,OAAO;AAAA,IAC7B;AAAA,EACF,CAAC;AAWD,QAAM,WAAW,CAAC,UAAiB;AACjC,UAAM,KAAK,KAAK,UAAU,EAAE,MAAM,kBAAkB,MAAM,CAAC,CAAC;AAC5D,YAAQ,gBAAgB,OAAO,QAAQ;AAAA,EACzC;AAEA,QAAM,OAAO;AACb,QAAM,QAAQ,QAAQ;AACtB,QAAM,OAAO,QAAQ,QAAQ;AAG7B,MAAI,MAAM,UAAU,MAAM,MAAM,YAAY,GAAG;AAC7C,YAAQ;AAAA,MACN,eAAe,MAAM,KAAK,+CAA+C,MAAM,KAAK;AAAA,IACtF;AAAA,EACF;AACA,MAAI,MAAM,SAAS,MAAM,KAAK,YAAY,GAAG;AAC3C,YAAQ;AAAA,MACN,wBAAwB,MAAM,IAAI,+CAA+C,MAAM,IAAI;AAAA,IAC7F;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/react.tsx"],"sourcesContent":["import type { PartySocket } from \"partysocket\";\nimport { usePartySocket } from \"partysocket/react\";\nimport { useCallback, useRef, use, useMemo, useEffect } from \"react\";\nimport type { Agent, MCPServersState, RPCRequest, RPCResponse } from \"./\";\nimport type { StreamOptions } from \"./client\";\nimport type { Method, RPCMethod } from \"./serializable\";\nimport { MessageType } from \"./ai-types\";\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\ntype QueryObject = Record<string, string | null>;\n\nconst queryCache = new Map<\n  unknown[],\n  {\n    promise: Promise<QueryObject>;\n    refCount: number;\n    expiresAt: number;\n    cacheTtl?: number;\n  }\n>();\n\nfunction arraysEqual(a: unknown[], b: unknown[]): boolean {\n  if (a === b) return true;\n  if (a.length !== b.length) return false;\n\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) return false;\n  }\n  return true;\n}\n\nfunction findCacheEntry(\n  targetKey: unknown[]\n): Promise<QueryObject> | undefined {\n  for (const [existingKey, entry] of queryCache.entries()) {\n    if (arraysEqual(existingKey, targetKey)) {\n      // Check if entry has expired\n      if (Date.now() > entry.expiresAt) {\n        queryCache.delete(existingKey);\n        return undefined;\n      }\n      entry.refCount++;\n      return entry.promise;\n    }\n  }\n  return undefined;\n}\n\nfunction setCacheEntry(\n  key: unknown[],\n  value: Promise<QueryObject>,\n  cacheTtl?: number\n): void {\n  // Remove any existing entry with matching members\n  for (const [existingKey] of queryCache.entries()) {\n    if (arraysEqual(existingKey, key)) {\n      queryCache.delete(existingKey);\n      break;\n    }\n  }\n\n  const expiresAt = cacheTtl\n    ? Date.now() + cacheTtl\n    : Date.now() + 5 * 60 * 1000; // Default 5 minutes\n  queryCache.set(key, { promise: value, refCount: 1, expiresAt, cacheTtl });\n}\n\nfunction decrementCacheEntry(targetKey: unknown[]): boolean {\n  for (const [existingKey, entry] of queryCache.entries()) {\n    if (arraysEqual(existingKey, targetKey)) {\n      entry.refCount--;\n      if (entry.refCount <= 0) {\n        queryCache.delete(existingKey);\n      }\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction createCacheKey(\n  agentNamespace: string,\n  name: string | undefined,\n  deps: unknown[]\n): unknown[] {\n  return [agentNamespace, name || \"default\", ...deps];\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\" | \"query\"\n> & {\n  /** Name of the agent to connect to */\n  agent: string;\n  /** Name of the specific Agent instance */\n  name?: string;\n  /** Query parameters - can be static object or async function */\n  query?: QueryObject | (() => Promise<QueryObject>);\n  /** Dependencies for async query caching */\n  queryDeps?: unknown[];\n  /** Cache TTL in milliseconds for auth tokens/time-sensitive data */\n  cacheTtl?: number;\n  /** Called when the Agent's state is updated */\n  onStateUpdate?: (state: State, source: \"server\" | \"client\") => void;\n  /** Called when MCP server state is updated */\n  onMcpUpdate?: (mcpServers: MCPServersState) => void;\n};\n\ntype AllOptional<T> = T extends [infer A, ...infer R]\n  ? undefined extends A\n    ? AllOptional<R>\n    : false\n  : true; // no params means optional by default\n\ntype RPCMethods<T> = {\n  [K in keyof T as T[K] extends RPCMethod<T[K]> ? K : never]: RPCMethod<T[K]>;\n};\n\ntype OptionalParametersMethod<T extends RPCMethod> =\n  AllOptional<Parameters<T>> extends true ? T : never;\n\n// all methods of the Agent, excluding the ones that are declared in the base Agent class\n// biome-ignore lint: suppressions/parse\ntype AgentMethods<T> = Omit<RPCMethods<T>, keyof Agent<any, any>>;\n\ntype OptionalAgentMethods<T> = {\n  [K in keyof AgentMethods<T> as AgentMethods<T>[K] extends OptionalParametersMethod<\n    AgentMethods<T>[K]\n  >\n    ? K\n    : never]: OptionalParametersMethod<AgentMethods<T>[K]>;\n};\n\ntype RequiredAgentMethods<T> = Omit<\n  AgentMethods<T>,\n  keyof OptionalAgentMethods<T>\n>;\n\ntype AgentPromiseReturnType<T, K extends keyof AgentMethods<T>> =\n  // biome-ignore lint: suppressions/parse\n  ReturnType<AgentMethods<T>[K]> extends Promise<any>\n    ? ReturnType<AgentMethods<T>[K]>\n    : Promise<ReturnType<AgentMethods<T>[K]>>;\n\ntype OptionalArgsAgentMethodCall<AgentT> = <\n  K extends keyof OptionalAgentMethods<AgentT>\n>(\n  method: K,\n  args?: Parameters<OptionalAgentMethods<AgentT>[K]>,\n  streamOptions?: StreamOptions\n) => AgentPromiseReturnType<AgentT, K>;\n\ntype RequiredArgsAgentMethodCall<AgentT> = <\n  K extends keyof RequiredAgentMethods<AgentT>\n>(\n  method: K,\n  args: Parameters<RequiredAgentMethods<AgentT>[K]>,\n  streamOptions?: StreamOptions\n) => AgentPromiseReturnType<AgentT, K>;\n\ntype AgentMethodCall<AgentT> = OptionalArgsAgentMethodCall<AgentT> &\n  RequiredArgsAgentMethodCall<AgentT>;\n\ntype UntypedAgentMethodCall = <T = unknown>(\n  method: string,\n  args?: unknown[],\n  streamOptions?: StreamOptions\n) => Promise<T>;\n\ntype AgentStub<T> = {\n  [K in keyof AgentMethods<T>]: (\n    ...args: Parameters<AgentMethods<T>[K]>\n  ) => AgentPromiseReturnType<AgentMethods<T>, K>;\n};\n\n// we neet to use Method instead of RPCMethod here for retro-compatibility\ntype UntypedAgentStub = Record<string, Method>;\n\n/**\n * React hook for connecting to an Agent\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: UntypedAgentMethodCall;\n  stub: UntypedAgentStub;\n};\nexport function useAgent<\n  AgentT extends {\n    get state(): State;\n  },\n  State\n>(\n  options: UseAgentOptions<State>\n): PartySocket & {\n  agent: string;\n  name: string;\n  setState: (state: State) => void;\n  call: AgentMethodCall<AgentT>;\n  stub: AgentStub<AgentT>;\n};\nexport function useAgent<State>(\n  options: UseAgentOptions<unknown>\n): PartySocket & {\n  agent: string;\n  name: string;\n  setState: (state: State) => void;\n  call: UntypedAgentMethodCall | AgentMethodCall<unknown>;\n  stub: UntypedAgentStub;\n} {\n  const agentNamespace = camelCaseToKebabCase(options.agent);\n  const { query, queryDeps, cacheTtl, ...restOptions } = options;\n\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  // Handle both sync and async query patterns\n  const cacheKey = useMemo(() => {\n    const deps = queryDeps || [];\n    return createCacheKey(agentNamespace, options.name, deps);\n  }, [agentNamespace, options.name, queryDeps]);\n\n  const queryPromise = useMemo(() => {\n    if (!query || typeof query !== \"function\") {\n      return null;\n    }\n\n    const existingPromise = findCacheEntry(cacheKey);\n    if (existingPromise) {\n      return existingPromise;\n    }\n\n    const promise = query().catch((error) => {\n      console.error(\n        `[useAgent] Query failed for agent \"${options.agent}\":`,\n        error\n      );\n      decrementCacheEntry(cacheKey); // Remove failed promise from cache\n      throw error; // Re-throw for Suspense error boundary\n    });\n\n    setCacheEntry(cacheKey, promise, cacheTtl);\n\n    return promise;\n  }, [cacheKey, query, options.agent, cacheTtl]);\n\n  let resolvedQuery: QueryObject | undefined;\n\n  if (query) {\n    if (typeof query === \"function\") {\n      // Use React's use() to resolve the promise\n      const queryResult = use(queryPromise!);\n\n      // Check for non-primitive values and warn\n      if (queryResult) {\n        for (const [key, value] of Object.entries(queryResult)) {\n          if (\n            value !== null &&\n            value !== undefined &&\n            typeof value !== \"string\" &&\n            typeof value !== \"number\" &&\n            typeof value !== \"boolean\"\n          ) {\n            console.warn(\n              `[useAgent] Query parameter \"${key}\" is an object and will be converted to \"[object Object]\". ` +\n                \"Query parameters should be string, number, boolean, or null.\"\n            );\n          }\n        }\n        resolvedQuery = queryResult;\n      }\n    } else {\n      // Sync query - use directly\n      resolvedQuery = query;\n    }\n  }\n\n  // Cleanup cache on unmount\n  useEffect(() => {\n    return () => {\n      if (queryPromise) {\n        decrementCacheEntry(cacheKey);\n      }\n    };\n  }, [cacheKey, queryPromise]);\n\n  const agent = usePartySocket({\n    party: agentNamespace,\n    prefix: \"agents\",\n    room: options.name || \"default\",\n    query: resolvedQuery,\n    ...restOptions,\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 === MessageType.CF_AGENT_STATE) {\n          options.onStateUpdate?.(parsedMessage.state as State, \"server\");\n          return;\n        }\n        if (parsedMessage.type === MessageType.CF_AGENT_MCP_SERVERS) {\n          options.onMcpUpdate?.(parsedMessage.mcp as MCPServersState);\n          return;\n        }\n        if (parsedMessage.type === MessageType.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: UntypedAgentMethodCall;\n    stub: UntypedAgentStub;\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          reject,\n          resolve: resolve as (value: unknown) => void,\n          stream: streamOptions\n        });\n\n        const request: RPCRequest = {\n          args,\n          id,\n          method,\n          type: MessageType.RPC\n        };\n\n        agent.send(JSON.stringify(request));\n      });\n    },\n    [agent]\n  );\n\n  agent.setState = (state: State) => {\n    agent.send(JSON.stringify({ state, type: MessageType.CF_AGENT_STATE }));\n    options.onStateUpdate?.(state, \"client\");\n  };\n\n  agent.call = call;\n  agent.agent = agentNamespace;\n  agent.name = options.name || \"default\";\n  // biome-ignore lint: suppressions/parse\n  agent.stub = new Proxy<any>(\n    {},\n    {\n      get: (_target, method) => {\n        return (...args: unknown[]) => {\n          return call(method as string, args);\n        };\n      }\n    }\n  );\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":";;;;AACA,SAAS,sBAAsB;AAC/B,SAAS,aAAa,QAAQ,KAAK,SAAS,iBAAiB;AAW7D,SAAS,qBAAqB,KAAqB;AAEjD,MAAI,QAAQ,IAAI,YAAY,KAAK,QAAQ,IAAI,YAAY,GAAG;AAC1D,WAAO,IAAI,YAAY,EAAE,QAAQ,MAAM,GAAG;AAAA,EAC5C;AAGA,MAAI,aAAa,IAAI;AAAA,IACnB;AAAA,IACA,CAAC,WAAW,IAAI,OAAO,YAAY,CAAC;AAAA,EACtC;AACA,eAAa,WAAW,WAAW,GAAG,IAAI,WAAW,MAAM,CAAC,IAAI;AAEhE,SAAO,WAAW,QAAQ,MAAM,GAAG,EAAE,QAAQ,MAAM,EAAE;AACvD;AAIA,IAAM,aAAa,oBAAI,IAQrB;AAEF,SAAS,YAAY,GAAc,GAAuB;AACxD,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAElC,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,QAAI,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAG,QAAO;AAAA,EACrC;AACA,SAAO;AACT;AAEA,SAAS,eACP,WACkC;AAClC,aAAW,CAAC,aAAa,KAAK,KAAK,WAAW,QAAQ,GAAG;AACvD,QAAI,YAAY,aAAa,SAAS,GAAG;AAEvC,UAAI,KAAK,IAAI,IAAI,MAAM,WAAW;AAChC,mBAAW,OAAO,WAAW;AAC7B,eAAO;AAAA,MACT;AACA,YAAM;AACN,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,cACP,KACA,OACA,UACM;AAEN,aAAW,CAAC,WAAW,KAAK,WAAW,QAAQ,GAAG;AAChD,QAAI,YAAY,aAAa,GAAG,GAAG;AACjC,iBAAW,OAAO,WAAW;AAC7B;AAAA,IACF;AAAA,EACF;AAEA,QAAM,YAAY,WACd,KAAK,IAAI,IAAI,WACb,KAAK,IAAI,IAAI,IAAI,KAAK;AAC1B,aAAW,IAAI,KAAK,EAAE,SAAS,OAAO,UAAU,GAAG,WAAW,SAAS,CAAC;AAC1E;AAEA,SAAS,oBAAoB,WAA+B;AAC1D,aAAW,CAAC,aAAa,KAAK,KAAK,WAAW,QAAQ,GAAG;AACvD,QAAI,YAAY,aAAa,SAAS,GAAG;AACvC,YAAM;AACN,UAAI,MAAM,YAAY,GAAG;AACvB,mBAAW,OAAO,WAAW;AAAA,MAC/B;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,eACP,gBACA,MACA,MACW;AACX,SAAO,CAAC,gBAAgB,QAAQ,WAAW,GAAG,IAAI;AACpD;AA0HO,SAAS,SACd,SAOA;AACA,QAAM,iBAAiB,qBAAqB,QAAQ,KAAK;AACzD,QAAM,EAAE,OAAO,WAAW,UAAU,GAAG,YAAY,IAAI;AAGvD,QAAM,kBAAkB;AAAA,IACtB,oBAAI,IAOF;AAAA,EACJ;AAGA,QAAM,WAAW,QAAQ,MAAM;AAC7B,UAAM,OAAO,aAAa,CAAC;AAC3B,WAAO,eAAe,gBAAgB,QAAQ,MAAM,IAAI;AAAA,EAC1D,GAAG,CAAC,gBAAgB,QAAQ,MAAM,SAAS,CAAC;AAE5C,QAAM,eAAe,QAAQ,MAAM;AACjC,QAAI,CAAC,SAAS,OAAO,UAAU,YAAY;AACzC,aAAO;AAAA,IACT;AAEA,UAAM,kBAAkB,eAAe,QAAQ;AAC/C,QAAI,iBAAiB;AACnB,aAAO;AAAA,IACT;AAEA,UAAM,UAAU,MAAM,EAAE,MAAM,CAAC,UAAU;AACvC,cAAQ;AAAA,QACN,sCAAsC,QAAQ,KAAK;AAAA,QACnD;AAAA,MACF;AACA,0BAAoB,QAAQ;AAC5B,YAAM;AAAA,IACR,CAAC;AAED,kBAAc,UAAU,SAAS,QAAQ;AAEzC,WAAO;AAAA,EACT,GAAG,CAAC,UAAU,OAAO,QAAQ,OAAO,QAAQ,CAAC;AAE7C,MAAI;AAEJ,MAAI,OAAO;AACT,QAAI,OAAO,UAAU,YAAY;AAE/B,YAAM,cAAc,IAAI,YAAa;AAGrC,UAAI,aAAa;AACf,mBAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,WAAW,GAAG;AACtD,cACE,UAAU,QACV,UAAU,UACV,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,WACjB;AACA,oBAAQ;AAAA,cACN,+BAA+B,GAAG;AAAA,YAEpC;AAAA,UACF;AAAA,QACF;AACA,wBAAgB;AAAA,MAClB;AAAA,IACF,OAAO;AAEL,sBAAgB;AAAA,IAClB;AAAA,EACF;AAGA,YAAU,MAAM;AACd,WAAO,MAAM;AACX,UAAI,cAAc;AAChB,4BAAoB,QAAQ;AAAA,MAC9B;AAAA,IACF;AAAA,EACF,GAAG,CAAC,UAAU,YAAY,CAAC;AAE3B,QAAM,QAAQ,eAAe;AAAA,IAC3B,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,MAAM,QAAQ,QAAQ;AAAA,IACtB,OAAO;AAAA,IACP,GAAG;AAAA,IACH,WAAW,CAAC,YAAY;AACtB,UAAI,OAAO,QAAQ,SAAS,UAAU;AACpC,YAAI;AACJ,YAAI;AACF,0BAAgB,KAAK,MAAM,QAAQ,IAAI;AAAA,QACzC,SAAS,QAAQ;AAGf,iBAAO,QAAQ,YAAY,OAAO;AAAA,QACpC;AACA,YAAI,cAAc,gDAAqC;AACrD,kBAAQ,gBAAgB,cAAc,OAAgB,QAAQ;AAC9D;AAAA,QACF;AACA,YAAI,cAAc,4DAA2C;AAC3D,kBAAQ,cAAc,cAAc,GAAsB;AAC1D;AAAA,QACF;AACA,YAAI,cAAc,0BAA0B;AAC1C,gBAAM,WAAW;AACjB,gBAAM,UAAU,gBAAgB,QAAQ,IAAI,SAAS,EAAE;AACvD,cAAI,CAAC,QAAS;AAEd,cAAI,CAAC,SAAS,SAAS;AACrB,oBAAQ,OAAO,IAAI,MAAM,SAAS,KAAK,CAAC;AACxC,4BAAgB,QAAQ,OAAO,SAAS,EAAE;AAC1C,oBAAQ,QAAQ,UAAU,SAAS,KAAK;AACxC;AAAA,UACF;AAGA,cAAI,UAAU,UAAU;AACtB,gBAAI,SAAS,MAAM;AACjB,sBAAQ,QAAQ,SAAS,MAAM;AAC/B,8BAAgB,QAAQ,OAAO,SAAS,EAAE;AAC1C,sBAAQ,QAAQ,SAAS,SAAS,MAAM;AAAA,YAC1C,OAAO;AACL,sBAAQ,QAAQ,UAAU,SAAS,MAAM;AAAA,YAC3C;AAAA,UACF,OAAO;AAEL,oBAAQ,QAAQ,SAAS,MAAM;AAC/B,4BAAgB,QAAQ,OAAO,SAAS,EAAE;AAAA,UAC5C;AACA;AAAA,QACF;AAAA,MACF;AACA,cAAQ,YAAY,OAAO;AAAA,IAC7B;AAAA,EACF,CAAC;AAQD,QAAM,OAAO;AAAA,IACX,CACE,QACA,OAAkB,CAAC,GACnB,kBACe;AACf,aAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,cAAM,KAAK,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC;AAC7C,wBAAgB,QAAQ,IAAI,IAAI;AAAA,UAC9B;AAAA,UACA;AAAA,UACA,QAAQ;AAAA,QACV,CAAC;AAED,cAAM,UAAsB;AAAA,UAC1B;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAEA,cAAM,KAAK,KAAK,UAAU,OAAO,CAAC;AAAA,MACpC,CAAC;AAAA,IACH;AAAA,IACA,CAAC,KAAK;AAAA,EACR;AAEA,QAAM,WAAW,CAAC,UAAiB;AACjC,UAAM,KAAK,KAAK,UAAU,EAAE,OAAO,4CAAiC,CAAC,CAAC;AACtE,YAAQ,gBAAgB,OAAO,QAAQ;AAAA,EACzC;AAEA,QAAM,OAAO;AACb,QAAM,QAAQ;AACd,QAAM,OAAO,QAAQ,QAAQ;AAE7B,QAAM,OAAO,IAAI;AAAA,IACf,CAAC;AAAA,IACD;AAAA,MACE,KAAK,CAAC,SAAS,WAAW;AACxB,eAAO,IAAI,SAAoB;AAC7B,iBAAO,KAAK,QAAkB,IAAI;AAAA,QACpC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAGA,MAAI,MAAM,UAAU,MAAM,MAAM,YAAY,GAAG;AAC7C,YAAQ;AAAA,MACN,eAAe,MAAM,KAAK,+CAA+C,MAAM,KAAK;AAAA,IACtF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/schedule.d.ts

@@ -1,30 +1,43 @@
 import { z } from "zod";
 
-type Schedule = z.infer<typeof unstable_scheduleSchema>;
+/**
+ * Get the schedule prompt for a given event
+ * @param event - The event to get the schedule prompt for
+ * @returns The schedule prompt
+ */
+declare function getSchedulePrompt(event: { date: Date }): string;
+/**
+ * @deprecated this has been renamed to getSchedulePrompt, and unstable_getSchedulePrompt will be removed in the next major version
+ * @param event - The event to get the schedule prompt for
+ * @returns The schedule prompt
+ */
 declare function unstable_getSchedulePrompt(event: { date: Date }): string;
-declare const unstable_scheduleSchema: z.ZodObject<
+/**
+ * The schema for the schedule prompt
+ */
+declare const scheduleSchema: z.ZodObject<
   {
     description: z.ZodString;
     when: z.ZodObject<
       {
-        type: z.ZodEnum<["scheduled", "delayed", "cron", "no-schedule"]>;
+        cron: z.ZodOptional<z.ZodString>;
         date: z.ZodOptional<z.ZodDate>;
         delayInSeconds: z.ZodOptional<z.ZodNumber>;
-        cron: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<["scheduled", "delayed", "cron", "no-schedule"]>;
       },
       "strip",
       z.ZodTypeAny,
       {
         type: "scheduled" | "delayed" | "cron" | "no-schedule";
+        date?: Date | undefined;
         cron?: string | undefined;
         delayInSeconds?: number | undefined;
-        date?: Date | undefined;
       },
       {
         type: "scheduled" | "delayed" | "cron" | "no-schedule";
+        date?: Date | undefined;
         cron?: string | undefined;
         delayInSeconds?: number | undefined;
-        date?: Date | undefined;
       }
     >;
   },
@@ -34,20 +47,81 @@ declare const unstable_scheduleSchema: z.ZodObject<
     description: string;
     when: {
       type: "scheduled" | "delayed" | "cron" | "no-schedule";
+      date?: Date | undefined;
       cron?: string | undefined;
       delayInSeconds?: number | undefined;
+    };
+  },
+  {
+    description: string;
+    when: {
+      type: "scheduled" | "delayed" | "cron" | "no-schedule";
       date?: Date | undefined;
+      cron?: string | undefined;
+      delayInSeconds?: number | undefined;
     };
+  }
+>;
+/**
+ * The type for the schedule prompt
+ */
+type Schedule = z.infer<typeof scheduleSchema>;
+/**
+ * @deprecated this has been renamed to scheduleSchema, and unstable_scheduleSchema will be removed in the next major version
+ * @returns The schedule schema
+ */
+declare const unstable_scheduleSchema: z.ZodObject<
+  {
+    description: z.ZodString;
+    when: z.ZodObject<
+      {
+        cron: z.ZodOptional<z.ZodString>;
+        date: z.ZodOptional<z.ZodDate>;
+        delayInSeconds: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<["scheduled", "delayed", "cron", "no-schedule"]>;
+      },
+      "strip",
+      z.ZodTypeAny,
+      {
+        type: "scheduled" | "delayed" | "cron" | "no-schedule";
+        date?: Date | undefined;
+        cron?: string | undefined;
+        delayInSeconds?: number | undefined;
+      },
+      {
+        type: "scheduled" | "delayed" | "cron" | "no-schedule";
+        date?: Date | undefined;
+        cron?: string | undefined;
+        delayInSeconds?: number | undefined;
+      }
+    >;
   },
+  "strip",
+  z.ZodTypeAny,
   {
     description: string;
     when: {
       type: "scheduled" | "delayed" | "cron" | "no-schedule";
+      date?: Date | undefined;
       cron?: string | undefined;
       delayInSeconds?: number | undefined;
+    };
+  },
+  {
+    description: string;
+    when: {
+      type: "scheduled" | "delayed" | "cron" | "no-schedule";
       date?: Date | undefined;
+      cron?: string | undefined;
+      delayInSeconds?: number | undefined;
     };
   }
 >;
 
-export { type Schedule, unstable_getSchedulePrompt, unstable_scheduleSchema };
+export {
+  type Schedule,
+  getSchedulePrompt,
+  scheduleSchema,
+  unstable_getSchedulePrompt,
+  unstable_scheduleSchema
+};