agents 0.2.32 → 0.2.34

package/dist/react.d.ts

@@ -1,15 +1,134 @@
-import "./context-_sPQqJWv.js";
-import "./client-BZVYeBmf.js";
-import "./mcp-CzbSsLfc.js";
-import "./do-oauth-client-provider-B-ryFIPr.js";
-import "./index-CyDpAVHZ.js";
-import "./ai-types-U8lYA0o8.js";
-import "./index-B6XHf8p0.js";
-import "./serializable-C4GLimgv.js";
-import "./client-ClORm6f0.js";
-import {
-  n as _testUtils,
-  r as useAgent,
-  t as UseAgentOptions
-} from "./react-DYwejKBr.js";
+import "./context-DcbQ8o7k.js";
+import "./client-BINtT7y-.js";
+import "./ai-types-0OnT3FHg.js";
+import { p as MCPServersState, t as Agent } from "./index-CfZ2mfMI.js";
+import { n as RPCMethod, t as Method } from "./serializable-Crsj26mx.js";
+import { i as StreamOptions } from "./client-CdM5I962.js";
+import { PartySocket } from "partysocket";
+import { usePartySocket } from "partysocket/react";
+
+//#region src/react.d.ts
+type QueryObject = Record<string, string | null>;
+interface CacheEntry {
+  promise: Promise<QueryObject>;
+  expiresAt: number;
+}
+declare function getCacheEntry(key: string): CacheEntry | undefined;
+declare function setCacheEntry(
+  key: string,
+  promise: Promise<QueryObject>,
+  cacheTtl: number
+): CacheEntry;
+declare function deleteCacheEntry(key: string): void;
+declare const _testUtils: {
+  queryCache: Map<string, CacheEntry>;
+  setCacheEntry: typeof setCacheEntry;
+  getCacheEntry: typeof getCacheEntry;
+  deleteCacheEntry: typeof deleteCacheEntry;
+  clearCache: () => void;
+};
+/**
+ * Options for the useAgent hook
+ * @template State Type of the Agent's state
+ */
+type UseAgentOptions<State = unknown> = Omit<
+  Parameters<typeof usePartySocket>[0],
+  "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$1 extends keyof AgentMethods<T>> =
+  ReturnType<AgentMethods<T>[K$1]> extends Promise<any>
+    ? ReturnType<AgentMethods<T>[K$1]>
+    : Promise<ReturnType<AgentMethods<T>[K$1]>>;
+type OptionalArgsAgentMethodCall<AgentT> = <
+  K$1 extends keyof OptionalAgentMethods<AgentT>
+>(
+  method: K$1,
+  args?: Parameters<OptionalAgentMethods<AgentT>[K$1]>,
+  streamOptions?: StreamOptions
+) => AgentPromiseReturnType<AgentT, K$1>;
+type RequiredArgsAgentMethodCall<AgentT> = <
+  K$1 extends keyof RequiredAgentMethods<AgentT>
+>(
+  method: K$1,
+  args: Parameters<RequiredAgentMethods<AgentT>[K$1]>,
+  streamOptions?: StreamOptions
+) => AgentPromiseReturnType<AgentT, K$1>;
+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
+ */
+declare function useAgent<State = unknown>(
+  options: UseAgentOptions<State>
+): PartySocket & {
+  agent: string;
+  name: string;
+  setState: (state: State) => void;
+  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>;
+};
+//#endregion
 export { UseAgentOptions, _testUtils, useAgent };
+//# sourceMappingURL=react.d.ts.map

package/dist/schedule.d.ts

@@ -23,46 +23,19 @@ declare const scheduleSchema: z.ZodObject<
     when: z.ZodObject<
       {
         cron: z.ZodOptional<z.ZodString>;
-        date: z.ZodOptional<z.ZodDate>;
+        date: z.ZodOptional<z.ZodCoercedDate<unknown>>;
         delayInSeconds: z.ZodOptional<z.ZodNumber>;
-        type: z.ZodEnum<["scheduled", "delayed", "cron", "no-schedule"]>;
+        type: z.ZodEnum<{
+          cron: "cron";
+          scheduled: "scheduled";
+          delayed: "delayed";
+          "no-schedule": "no-schedule";
+        }>;
       },
-      "strip",
-      z.ZodTypeAny,
-      {
-        type: "cron" | "scheduled" | "delayed" | "no-schedule";
-        date?: Date | undefined;
-        cron?: string | undefined;
-        delayInSeconds?: number | undefined;
-      },
-      {
-        type: "cron" | "scheduled" | "delayed" | "no-schedule";
-        date?: Date | undefined;
-        cron?: string | undefined;
-        delayInSeconds?: number | undefined;
-      }
+      z.core.$strip
     >;
   },
-  "strip",
-  z.ZodTypeAny,
-  {
-    description: string;
-    when: {
-      type: "cron" | "scheduled" | "delayed" | "no-schedule";
-      date?: Date | undefined;
-      cron?: string | undefined;
-      delayInSeconds?: number | undefined;
-    };
-  },
-  {
-    description: string;
-    when: {
-      type: "cron" | "scheduled" | "delayed" | "no-schedule";
-      date?: Date | undefined;
-      cron?: string | undefined;
-      delayInSeconds?: number | undefined;
-    };
-  }
+  z.core.$strip
 >;
 /**
  * The type for the schedule prompt
@@ -78,46 +51,19 @@ declare const unstable_scheduleSchema: z.ZodObject<
     when: z.ZodObject<
       {
         cron: z.ZodOptional<z.ZodString>;
-        date: z.ZodOptional<z.ZodDate>;
+        date: z.ZodOptional<z.ZodCoercedDate<unknown>>;
         delayInSeconds: z.ZodOptional<z.ZodNumber>;
-        type: z.ZodEnum<["scheduled", "delayed", "cron", "no-schedule"]>;
+        type: z.ZodEnum<{
+          cron: "cron";
+          scheduled: "scheduled";
+          delayed: "delayed";
+          "no-schedule": "no-schedule";
+        }>;
       },
-      "strip",
-      z.ZodTypeAny,
-      {
-        type: "cron" | "scheduled" | "delayed" | "no-schedule";
-        date?: Date | undefined;
-        cron?: string | undefined;
-        delayInSeconds?: number | undefined;
-      },
-      {
-        type: "cron" | "scheduled" | "delayed" | "no-schedule";
-        date?: Date | undefined;
-        cron?: string | undefined;
-        delayInSeconds?: number | undefined;
-      }
+      z.core.$strip
     >;
   },
-  "strip",
-  z.ZodTypeAny,
-  {
-    description: string;
-    when: {
-      type: "cron" | "scheduled" | "delayed" | "no-schedule";
-      date?: Date | undefined;
-      cron?: string | undefined;
-      delayInSeconds?: number | undefined;
-    };
-  },
-  {
-    description: string;
-    when: {
-      type: "cron" | "scheduled" | "delayed" | "no-schedule";
-      date?: Date | undefined;
-      cron?: string | undefined;
-      delayInSeconds?: number | undefined;
-    };
-  }
+  z.core.$strip
 >;
 //#endregion
 export {

package/dist/{serializable-C4GLimgv.d.ts → serializable-Crsj26mx.d.ts}

@@ -36,4 +36,4 @@ export {
   SerializableReturnValue as r,
   Method as t
 };
-//# sourceMappingURL=serializable-C4GLimgv.d.ts.map
+//# sourceMappingURL=serializable-Crsj26mx.d.ts.map

package/dist/serializable.d.ts

@@ -3,5 +3,5 @@ import {
   n as RPCMethod,
   r as SerializableReturnValue,
   t as Method
-} from "./serializable-C4GLimgv.js";
+} from "./serializable-Crsj26mx.js";
 export { Method, RPCMethod, SerializableReturnValue, SerializableValue };