agents 0.22.0 → 0.24.0

package/dist/client.d.ts

@@ -1,285 +1,26 @@
-import { c as Agent } from "./agent-routing-CnkaHb-v.js";
+import { t as AgentTransport } from "./transport-protocol-ZTew5Wso.js";
 import {
-  ClientParameters,
-  Method,
-  RPCMethod,
-  SerializableReturnValue,
-  SerializableValue
-} from "./serializable.js";
-import {
-  PartyFetchOptions,
-  PartySocket,
-  PartySocketOptions
-} from "partysocket";
-
-//#region src/client.d.ts
-declare class AgentConnectionError extends Error {
-  code: number;
-  reason: string;
-  wasClean: boolean;
-  constructor(event: CloseEvent);
-}
-declare function isTerminalCloseEvent(event: CloseEvent): boolean;
-type TerminalReconnectOptions = {
-  shouldReconnectOnClose?: (event: CloseEvent) => boolean;
-};
-/**
- * Options for creating an AgentClient
- */
-type AgentClientOptions<State = unknown> = Omit<
-  PartySocketOptions,
-  "party" | "room"
-> &
-  TerminalReconnectOptions & {
-    /** Name of the agent to connect to (ignored if basePath is set) */ agent: string /** Name of the specific Agent instance (ignored if basePath is set) */;
-    name?: string;
-    /**
-     * Full URL path - bypasses agent/name URL construction.
-     * When set, the client connects to this path directly.
-     * Server must handle routing manually (e.g., with getAgentByName + fetch).
-     * @example
-     * // Client connects to /user, server routes based on session
-     * useAgent({ agent: "UserAgent", basePath: "user" })
-     */
-    basePath?: string /** Called when the Agent's state is updated */;
-    onStateUpdate?: (
-      state: State,
-      source: "server" | "client"
-    ) => void /** Called when a state update fails (e.g., connection is readonly) */;
-    onStateUpdateError?: (error: string) => void;
-    /**
-     * Called when the server sends the agent's identity on connect.
-     * Useful when using basePath, as the actual instance name is determined server-side.
-     * @param name The actual agent instance name
-     * @param agent The agent class name (kebab-case)
-     */
-    onIdentity?: (name: string, agent: string) => void;
-    /**
-     * Called when identity changes on reconnect (different instance than before).
-     * If not provided and identity changes, a warning will be logged.
-     * @param oldName Previous instance name
-     * @param newName New instance name
-     * @param oldAgent Previous agent class name
-     * @param newAgent New agent class name
-     */
-    onIdentityChange?: (
-      oldName: string,
-      newName: string,
-      oldAgent: string,
-      newAgent: string
-    ) => void;
-    /**
-     * Additional path to append to the URL.
-     * Works with both standard routing and basePath.
-     * @example
-     * // With basePath: /user/settings
-     * { basePath: "user", path: "settings" }
-     * // Standard: /agents/my-agent/room/settings
-     * { agent: "MyAgent", name: "room", path: "settings" }
-     */
-    path?: string;
-    /**
-     * Default timeout (in milliseconds) applied to non-streaming `call()`s
-     * that don't pass an explicit `timeout`. Defaults to 30 000 ms.
-     * Set to `0` to disable. Streaming calls never get a default timeout.
-     */
-    defaultCallTimeout?: number /** Called when the connection closes with a terminal code and will not reconnect. */;
-    onConnectionError?: (error: AgentConnectionError) => void;
-  };
-/**
- * Default timeout (in milliseconds) applied to non-streaming RPC calls
- * that don't pass an explicit `timeout`. Acts as a backstop so calls
- * whose response is lost (e.g. the connection drops mid-flight) reject
- * instead of hanging forever. Override per client via
- * `defaultCallTimeout`, or per call via `timeout` (0 disables).
- */
-declare const DEFAULT_CALL_TIMEOUT_MS = 30000;
-/**
- * Options for streaming RPC calls
- */
-type StreamOptions = {
-  /** Called when a chunk of data is received */ onChunk?: (
-    chunk: unknown
-  ) => void /** Called when the stream ends */;
-  onDone?: (finalChunk: unknown) => void /** Called when an error occurs */;
-  onError?: (error: string) => void;
-};
-/**
- * Options for RPC calls
- */
-type CallOptions = {
-  /** Timeout in milliseconds. If the call doesn't complete within this time, it will be rejected. */ timeout?: number /** Streaming options for handling streaming responses */;
-  stream?: StreamOptions;
-};
-/**
- * Options for the agentFetch function
- */
-type AgentClientFetchOptions = Omit<PartyFetchOptions, "party" | "room"> & {
-  /** Name of the agent to connect to (ignored if basePath is set) */ agent: string /** Name of the specific Agent instance (ignored if basePath is set) */;
-  name?: string;
-  /**
-   * Full URL path - bypasses agent/name URL construction.
-   * When set, the request is made to this path directly.
-   */
-  basePath?: string;
-};
-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<ClientParameters<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 AgentStub<T> = {
-  [K in keyof AgentMethods<T>]: (
-    ...args: ClientParameters<AgentMethods<T>[K]>
-  ) => AgentPromiseReturnType<AgentMethods<T>, K>;
-};
-type UntypedAgentStub = Record<string, Method>;
-type AgentClientStub<AgentT> = keyof AgentMethods<AgentT> extends never
-  ? UntypedAgentStub
-  : AgentStub<AgentT>;
-type OptionalArgsAgentClientCall<AgentT> = <
-  K extends keyof OptionalAgentMethods<AgentT>
->(
-  method: K,
-  args?: ClientParameters<OptionalAgentMethods<AgentT>[K]>,
-  options?: CallOptions | StreamOptions
-) => AgentPromiseReturnType<AgentT, K>;
-type RequiredArgsAgentClientCall<AgentT> = <
-  K extends keyof RequiredAgentMethods<AgentT>
->(
-  method: K,
-  args: ClientParameters<RequiredAgentMethods<AgentT>[K]>,
-  options?: CallOptions | StreamOptions
-) => AgentPromiseReturnType<AgentT, K>;
-type TypedAgentClientCall<AgentT> = OptionalArgsAgentClientCall<AgentT> &
-  RequiredArgsAgentClientCall<AgentT>;
-type UntypedAgentClientCall = {
-  <T extends SerializableReturnValue>(
-    method: string,
-    args?: SerializableValue[],
-    options?: CallOptions | StreamOptions
-  ): Promise<T>;
-  <T = unknown>(
-    method: string,
-    args?: unknown[],
-    options?: CallOptions | StreamOptions
-  ): Promise<T>;
-};
-type AgentClientCall<AgentT> = keyof AgentMethods<AgentT> extends never
-  ? UntypedAgentClientCall
-  : TypedAgentClientCall<AgentT>;
-/**
- * Creates a proxy that wraps RPC method calls.
- * Internal JS methods (toJSON, then, etc.) return undefined to avoid
- * triggering RPC calls during serialization (e.g., console.log)
- */
-declare function createStubProxy<T = Record<string, Method>>(
-  call: (method: string, args: unknown[]) => unknown
-): T;
-/**
- * WebSocket client for connecting to an Agent
- */
-declare class AgentClient<
-  AgentT = unknown,
-  State = AgentT extends {
-    get state(): infer S;
-  }
-    ? S
-    : AgentT
-> extends PartySocket {
-  /**
-   * @deprecated Use agentFetch instead
-   */
-  static fetch(_opts: PartyFetchOptions): Promise<Response>;
-  agent: string;
-  name: string;
-  call: AgentClientCall<AgentT>;
-  stub: AgentClientStub<AgentT>;
-  /**
-   * The current agent state, updated on server broadcasts and client setState calls.
-   * Starts as undefined until the first state message is received from the server.
-   */
-  state: State | undefined;
-  /**
-   * Whether the client has received identity from the server.
-   * Becomes true after the first identity message is received.
-   * Resets to false on connection close.
-   */
-  identified: boolean;
-  /**
-   * Terminal connection error, if the server closed the socket with a code
-   * that should not be retried automatically.
-   */
-  connectionError: AgentConnectionError | null;
-  /**
-   * Promise that resolves when identity has been received from the server.
-   * Useful for waiting before making calls that depend on knowing the instance.
-   * Resets on connection close so it can be awaited again after reconnect.
-   */
-  get ready(): Promise<void>;
-  private options;
-  private _pendingCalls;
-  private _readyPromise;
-  private _resolveReady;
-  private _previousName;
-  private _previousAgent;
-  private _resetReady;
-  constructor(options: AgentClientOptions<State>);
-  /**
-   * Reject pending RPC calls with the given reason.
-   * With `onlyTransmitted`, calls still sitting in the send buffer are
-   * kept pending (they'll be flushed on reconnect).
-   */
-  private _rejectPendingCalls;
-  setState(state: State): void;
-  /**
-   * Close the connection and immediately reject all pending RPC calls.
-   * This provides immediate feedback on intentional close rather than
-   * waiting for the WebSocket close handshake to complete.
-   *
-   * Note: Any calls made after `close()` will be rejected when the
-   * underlying WebSocket close event fires.
-   */
-  close(code?: number, reason?: string): void;
-  /**
-   * Call a method on the Agent.
-   * When AgentT is provided, method names are inferred from the agent's methods.
-   * Falls back to untyped string-based calls when AgentT is not provided.
-   */
-  private _callImpl;
-}
-/**
- * Make an HTTP request to an Agent
- * @param opts Connection options
- * @param init Request initialization options
- * @returns Promise resolving to a Response
- */
-declare function agentFetch(
-  opts: AgentClientFetchOptions,
-  init?: RequestInit
-): Promise<Response>;
-//#endregion
+  _ as createStubProxy,
+  a as AgentMethods,
+  b as splitCallOptions,
+  c as CallOptions,
+  d as OptionalAgentMethods,
+  f as RPCMethods,
+  g as agentFetch,
+  h as UntypedAgentStub,
+  i as AgentConnectionError,
+  l as DEFAULT_CALL_TIMEOUT_MS,
+  m as StreamOptions,
+  n as AgentClientFetchOptions,
+  o as AgentPromiseReturnType,
+  p as RequiredAgentMethods,
+  r as AgentClientOptions,
+  s as AgentStub,
+  t as AgentClient,
+  u as NativeCallQueue,
+  v as isTerminalCloseEvent,
+  y as nativeCall
+} from "./client-BxdkCuVy.js";
 export {
   AgentClient,
   AgentClientFetchOptions,
@@ -288,8 +29,10 @@ export {
   AgentMethods,
   AgentPromiseReturnType,
   AgentStub,
+  type AgentTransport,
   CallOptions,
   DEFAULT_CALL_TIMEOUT_MS,
+  NativeCallQueue,
   OptionalAgentMethods,
   RPCMethods,
   RequiredAgentMethods,
@@ -297,6 +40,7 @@ export {
   UntypedAgentStub,
   agentFetch,
   createStubProxy,
-  isTerminalCloseEvent
+  isTerminalCloseEvent,
+  nativeCall,
+  splitCallOptions
 };
-//# sourceMappingURL=client.d.ts.map

package/dist/client.js

@@ -1,274 +1,2 @@
-import { camelCaseToKebabCase, isInternalJsStubProp } from "./utils.js";
-import "./types.js";
-import { PartySocket } from "partysocket";
-//#region src/client.ts
-var AgentConnectionError = class extends Error {
-	constructor(event) {
-		const reason = event.reason || `WebSocket closed with code ${event.code}`;
-		super(`Agent connection closed: ${reason}`);
-		this.name = "AgentConnectionError";
-		this.code = event.code;
-		this.reason = event.reason;
-		this.wasClean = event.wasClean;
-	}
-};
-function isTerminalCloseEvent(event) {
-	return event.code === 1008 || event.code >= 4e3 && event.code <= 4999;
-}
-/**
-* Default timeout (in milliseconds) applied to non-streaming RPC calls
-* that don't pass an explicit `timeout`. Acts as a backstop so calls
-* whose response is lost (e.g. the connection drops mid-flight) reject
-* instead of hanging forever. Override per client via
-* `defaultCallTimeout`, or per call via `timeout` (0 disables).
-*/
-const DEFAULT_CALL_TIMEOUT_MS = 3e4;
-/**
-* Creates a proxy that wraps RPC method calls.
-* Internal JS methods (toJSON, then, etc.) return undefined to avoid
-* triggering RPC calls during serialization (e.g., console.log)
-*/
-function createStubProxy(call) {
-	return new Proxy({}, { get: (_target, method) => {
-		if (isInternalJsStubProp(method)) return;
-		return (...args) => call(method, args);
-	} });
-}
-/**
-* WebSocket client for connecting to an Agent
-*/
-var AgentClient = class extends PartySocket {
-	/**
-	* @deprecated Use agentFetch instead
-	*/
-	static fetch(_opts) {
-		throw new Error("AgentClient.fetch is not implemented, use agentFetch instead");
-	}
-	/**
-	* Promise that resolves when identity has been received from the server.
-	* Useful for waiting before making calls that depend on knowing the instance.
-	* Resets on connection close so it can be awaited again after reconnect.
-	*/
-	get ready() {
-		return this._readyPromise;
-	}
-	_resetReady() {
-		this._readyPromise = new Promise((resolve) => {
-			this._resolveReady = resolve;
-		});
-	}
-	constructor(options) {
-		const agentNamespace = camelCaseToKebabCase(options.agent);
-		const shouldReconnectOnClose = options.shouldReconnectOnClose;
-		const classifyReconnect = (event) => (shouldReconnectOnClose?.(event) ?? true) && !isTerminalCloseEvent(event);
-		const socketOptions = options.basePath ? {
-			basePath: options.basePath,
-			path: options.path,
-			...options,
-			shouldReconnectOnClose: classifyReconnect
-		} : {
-			party: agentNamespace,
-			prefix: "agents",
-			room: options.name || "default",
-			path: options.path,
-			...options,
-			shouldReconnectOnClose: classifyReconnect
-		};
-		super(socketOptions);
-		this.state = void 0;
-		this.identified = false;
-		this.connectionError = null;
-		this._pendingCalls = /* @__PURE__ */ new Map();
-		this._previousName = null;
-		this._previousAgent = null;
-		this.agent = agentNamespace;
-		this.name = options.name || "default";
-		this.options = options;
-		this._resetReady();
-		this.addEventListener("message", (event) => {
-			if (typeof event.data === "string") {
-				let parsedMessage;
-				try {
-					parsedMessage = JSON.parse(event.data);
-				} catch (_error) {
-					return;
-				}
-				if (parsedMessage.type === "cf_agent_identity") {
-					const oldName = this._previousName;
-					const oldAgent = this._previousAgent;
-					const newName = parsedMessage.name;
-					const newAgent = parsedMessage.agent;
-					this.identified = true;
-					this._resolveReady();
-					if (oldName !== null && oldAgent !== null && (oldName !== newName || oldAgent !== newAgent)) if (this.options.onIdentityChange) this.options.onIdentityChange(oldName, newName, oldAgent, newAgent);
-					else {
-						const agentChanged = oldAgent !== newAgent;
-						const nameChanged = oldName !== newName;
-						let changeDescription = "";
-						if (agentChanged && nameChanged) changeDescription = `agent "${oldAgent}" → "${newAgent}", instance "${oldName}" → "${newName}"`;
-						else if (agentChanged) changeDescription = `agent "${oldAgent}" → "${newAgent}"`;
-						else changeDescription = `instance "${oldName}" → "${newName}"`;
-						console.warn(`[agents] Identity changed on reconnect: ${changeDescription}. This can happen with server-side routing (e.g., basePath with getAgentByName) where the instance is determined by auth/session. Provide onIdentityChange callback to handle this explicitly, or ignore if this is expected for your routing pattern.`);
-					}
-					this._previousName = newName;
-					this._previousAgent = newAgent;
-					this.name = newName;
-					this.agent = newAgent;
-					this.options.onIdentity?.(newName, newAgent);
-					return;
-				}
-				if (parsedMessage.type === "cf_agent_state") {
-					this.state = parsedMessage.state;
-					this.options.onStateUpdate?.(parsedMessage.state, "server");
-					return;
-				}
-				if (parsedMessage.type === "cf_agent_state_error") {
-					this.options.onStateUpdateError?.(parsedMessage.error);
-					return;
-				}
-				if (parsedMessage.type === "rpc") {
-					const response = parsedMessage;
-					const pending = this._pendingCalls.get(response.id);
-					if (!pending) {
-						console.warn(`[AgentClient] Discarded an RPC response with no matching pending call (id "${response.id}"). The call likely timed out or was rejected when its connection closed before the response arrived.`);
-						return;
-					}
-					if (!response.success) {
-						pending.reject(new Error(response.error));
-						this._pendingCalls.delete(response.id);
-						pending.stream?.onError?.(response.error);
-						return;
-					}
-					if ("done" in response) if (response.done) {
-						pending.resolve(response.result);
-						this._pendingCalls.delete(response.id);
-						pending.stream?.onDone?.(response.result);
-					} else pending.stream?.onChunk?.(response.result);
-					else {
-						pending.resolve(response.result);
-						this._pendingCalls.delete(response.id);
-					}
-				}
-			}
-		});
-		this.addEventListener("open", () => {
-			this.connectionError = null;
-			for (const pending of this._pendingCalls.values()) pending.transmitted = true;
-		});
-		this.addEventListener("close", (event) => {
-			const terminalClose = isTerminalCloseEvent(event);
-			this.identified = false;
-			this._resetReady();
-			if (this.shouldReconnect) this._rejectPendingCalls("Connection closed", { onlyTransmitted: true });
-			else {
-				this._rejectPendingCalls("Connection closed");
-				if (terminalClose) {
-					const error = new AgentConnectionError(event);
-					this.connectionError = error;
-					this.options.onConnectionError?.(error);
-				}
-			}
-		});
-		this.call = this._callImpl.bind(this);
-		this.stub = createStubProxy((method, args) => this._callImpl(method, args));
-	}
-	/**
-	* Reject pending RPC calls with the given reason.
-	* With `onlyTransmitted`, calls still sitting in the send buffer are
-	* kept pending (they'll be flushed on reconnect).
-	*/
-	_rejectPendingCalls(reason, { onlyTransmitted = false } = {}) {
-		const error = new Error(reason);
-		for (const [id, pending] of this._pendingCalls) {
-			if (onlyTransmitted && !pending.transmitted) continue;
-			this._pendingCalls.delete(id);
-			pending.reject(error);
-			pending.stream?.onError?.(reason);
-		}
-	}
-	setState(state) {
-		this.send(JSON.stringify({
-			state,
-			type: "cf_agent_state"
-		}));
-		this.state = state;
-		this.options.onStateUpdate?.(state, "client");
-	}
-	/**
-	* Close the connection and immediately reject all pending RPC calls.
-	* This provides immediate feedback on intentional close rather than
-	* waiting for the WebSocket close handshake to complete.
-	*
-	* Note: Any calls made after `close()` will be rejected when the
-	* underlying WebSocket close event fires.
-	*/
-	close(code, reason) {
-		this._rejectPendingCalls("Connection closed");
-		super.close(code, reason);
-	}
-	/**
-	* Call a method on the Agent.
-	* When AgentT is provided, method names are inferred from the agent's methods.
-	* Falls back to untyped string-based calls when AgentT is not provided.
-	*/
-	async _callImpl(method, args = [], options) {
-		if (this.connectionError && this.readyState === this.CLOSED) throw new Error("Connection closed");
-		return new Promise((resolve, reject) => {
-			const id = crypto.randomUUID();
-			let timeoutId;
-			const isLegacyFormat = options && ("onChunk" in options || "onDone" in options || "onError" in options);
-			const streamOptions = isLegacyFormat ? options : options?.stream;
-			const timeout = isLegacyFormat ? void 0 : options?.timeout;
-			const effectiveTimeout = timeout !== void 0 ? timeout : streamOptions ? void 0 : this.options.defaultCallTimeout ?? 3e4;
-			if (effectiveTimeout) timeoutId = setTimeout(() => {
-				const pending = this._pendingCalls.get(id);
-				this._pendingCalls.delete(id);
-				const errorMessage = `RPC call to ${method} timed out after ${effectiveTimeout}ms`;
-				pending?.stream?.onError?.(errorMessage);
-				reject(new Error(errorMessage));
-			}, effectiveTimeout);
-			this._pendingCalls.set(id, {
-				reject: (e) => {
-					if (timeoutId) clearTimeout(timeoutId);
-					reject(e);
-				},
-				resolve: (value) => {
-					if (timeoutId) clearTimeout(timeoutId);
-					resolve(value);
-				},
-				stream: streamOptions,
-				transmitted: this.readyState === this.OPEN
-			});
-			const request = {
-				args,
-				id,
-				method,
-				type: "rpc"
-			};
-			this.send(JSON.stringify(request));
-		});
-	}
-};
-/**
-* Make an HTTP request to an Agent
-* @param opts Connection options
-* @param init Request initialization options
-* @returns Promise resolving to a Response
-*/
-function agentFetch(opts, init) {
-	const agentNamespace = camelCaseToKebabCase(opts.agent);
-	if (opts.basePath) return PartySocket.fetch({
-		basePath: opts.basePath,
-		...opts
-	}, init);
-	return PartySocket.fetch({
-		party: agentNamespace,
-		prefix: "agents",
-		room: opts.name || "default",
-		...opts
-	}, init);
-}
-//#endregion
-export { AgentClient, AgentConnectionError, DEFAULT_CALL_TIMEOUT_MS, agentFetch, createStubProxy, isTerminalCloseEvent };
-
-//# sourceMappingURL=client.js.map
+import { a as agentFetch, c as nativeCall, i as NativeCallQueue, l as splitCallOptions, n as AgentConnectionError, o as createStubProxy, r as DEFAULT_CALL_TIMEOUT_MS, s as isTerminalCloseEvent, t as AgentClient } from "./client-C9DAjZIY.js";
+export { AgentClient, AgentConnectionError, DEFAULT_CALL_TIMEOUT_MS, NativeCallQueue, agentFetch, createStubProxy, isTerminalCloseEvent, nativeCall, splitCallOptions };