@economic/agents-react 1.0.1 → 1.1.1

package/dist/index.d.mts

@@ -1,30 +1,340 @@
-import { useAgentChat } from "@cloudflare/ai-chat/react";
-import { useAgent } from "agents/react";
+import * as _$agents_client0 from "agents/client";
+import * as _$ai from "ai";
+import * as _$_ai_sdk_react0 from "@ai-sdk/react";
 
+//#region ../../node_modules/partysocket/ws-Cg2f-sDL.d.ts
+//#region src/type-helper.d.ts
+type TypedEventTarget<EventMap extends object> = {
+  new (): IntermediateEventTarget<EventMap>;
+};
+interface IntermediateEventTarget<EventMap> extends EventTarget {
+  addEventListener<K extends keyof EventMap>(type: K, callback: (event: EventMap[K] extends Event ? EventMap[K] : never) => EventMap[K] extends Event ? void : never, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+  removeEventListener<K extends keyof EventMap>(type: K, callback: (event: EventMap[K] extends Event ? EventMap[K] : never) => EventMap[K] extends Event ? void : never, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+} //#endregion
+//#region src/ws.d.ts
+declare class ErrorEvent extends Event {
+  message: string;
+  error: Error;
+  constructor(error: Error, target: any);
+}
+declare class CloseEvent extends Event {
+  code: number;
+  reason: string;
+  wasClean: boolean;
+  constructor(code: number | undefined, reason: string | undefined, target: any);
+}
+interface WebSocketEventMap {
+  close: CloseEvent;
+  error: ErrorEvent;
+  message: MessageEvent;
+  open: Event;
+}
+type Options = {
+  WebSocket?: any;
+  maxReconnectionDelay?: number;
+  minReconnectionDelay?: number;
+  reconnectionDelayGrowFactor?: number;
+  minUptime?: number;
+  connectionTimeout?: number;
+  maxRetries?: number;
+  maxEnqueuedMessages?: number;
+  startClosed?: boolean;
+  debug?: boolean;
+  debugLogger?: (...args: any[]) => void;
+};
+type UrlProvider = string | (() => string) | (() => Promise<string>);
+type ProtocolsProvider = null | string | string[] | (() => string | string[] | null) | (() => Promise<string | string[] | null>);
+type Message = string | ArrayBuffer | Blob | ArrayBufferView<ArrayBuffer>;
+declare const ReconnectingWebSocket_base: TypedEventTarget<WebSocketEventMap>;
+declare class ReconnectingWebSocket extends ReconnectingWebSocket_base {
+  private _ws;
+  private _retryCount;
+  private _uptimeTimeout;
+  private _connectTimeout;
+  private _shouldReconnect;
+  private _connectLock;
+  private _binaryType;
+  private _closeCalled;
+  private _messageQueue;
+  private _debugLogger;
+  protected _url: UrlProvider;
+  protected _protocols?: ProtocolsProvider;
+  protected _options: Options;
+  constructor(url: UrlProvider, protocols?: ProtocolsProvider, options?: Options);
+  static get CONNECTING(): number;
+  static get OPEN(): number;
+  static get CLOSING(): number;
+  static get CLOSED(): number;
+  get CONNECTING(): number;
+  get OPEN(): number;
+  get CLOSING(): number;
+  get CLOSED(): number;
+  get binaryType(): BinaryType;
+  set binaryType(value: BinaryType);
+  /**
+   * Returns the number or connection retries
+   */
+  get retryCount(): number;
+  /**
+   * The number of bytes of data that have been queued using calls to send() but not yet
+   * transmitted to the network. This value resets to zero once all queued data has been sent.
+   * This value does not reset to zero when the connection is closed; if you keep calling send(),
+   * this will continue to climb. Read only
+   */
+  get bufferedAmount(): number;
+  /**
+   * The extensions selected by the server. This is currently only the empty string or a list of
+   * extensions as negotiated by the connection
+   */
+  get extensions(): string;
+  /**
+   * A string indicating the name of the sub-protocol the server selected;
+   * this will be one of the strings specified in the protocols parameter when creating the
+   * WebSocket object
+   */
+  get protocol(): string;
+  /**
+   * The current state of the connection; this is one of the Ready state constants
+   */
+  get readyState(): number;
+  /**
+   * The URL as resolved by the constructor
+   */
+  get url(): string;
+  /**
+   * Whether the websocket object is now in reconnectable state
+   */
+  get shouldReconnect(): boolean;
+  /**
+   * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+   */
+  onclose: ((event: CloseEvent) => void) | null;
+  /**
+   * An event listener to be called when an error occurs
+   */
+  onerror: ((event: ErrorEvent) => void) | null;
+  /**
+   * An event listener to be called when a message is received from the server
+   */
+  onmessage: ((event: MessageEvent) => void) | null;
+  /**
+   * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+   * this indicates that the connection is ready to send and receive data
+   */
+  onopen: ((event: Event) => void) | null;
+  /**
+   * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+   * CLOSED, this method does nothing
+   */
+  close(code?: number, reason?: string): void;
+  /**
+   * Closes the WebSocket connection or connection attempt and connects again.
+   * Resets retry counter;
+   */
+  reconnect(code?: number, reason?: string): void;
+  /**
+   * Enqueue specified data to be transmitted to the server over the WebSocket connection
+   */
+  send(data: Message): void;
+  private _debug;
+  private _getNextDelay;
+  private _wait;
+  private _getNextProtocols;
+  private _getNextUrl;
+  private _connect;
+  private _handleTimeout;
+  private _disconnect;
+  private _acceptOpen;
+  private _handleOpen;
+  private _handleMessage;
+  private _handleError;
+  private _handleClose;
+  private _removeListeners;
+  private _addListeners;
+  private _clearTimeouts;
+} //#endregion
+//#endregion
+//#region ../../node_modules/partysocket/index.d.ts
 //#region src/index.d.ts
-type AgentConnectionStatus = "connecting" | "connected" | "disconnected" | "unauthorized";
-interface UseAIChatAgentOptions {
-  agent: string;
+type Maybe<T> = T | null | undefined;
+type Params = Record<string, Maybe<string>>;
+type PartySocketOptions = Omit<Options, "constructor"> & {
+  id?: string;
   host: string;
+  room?: string;
+  party?: string;
   basePath?: string;
-  chatId: string;
-  /** When set with `subAgentName`, used as the coordinator agent instance name instead of `chatId`. */
-  userId?: string;
+  prefix?: string;
+  protocol?: "ws" | "wss";
+  protocols?: ProtocolsProvider;
+  path?: string;
+  query?: Params | (() => Params | Promise<Params>);
+  disableNameValidation?: boolean;
+};
+type PartyFetchOptions = {
+  host: string;
+  room: string;
+  party?: string;
+  basePath?: string;
+  prefix?: string;
+  path?: string;
+  protocol?: "http" | "https";
+  query?: Params | (() => Params | Promise<Params>);
+  fetch?: typeof fetch;
+};
+declare class PartySocket extends ReconnectingWebSocket {
+  readonly partySocketOptions: PartySocketOptions;
+  _pk: string;
+  _pkurl: string;
+  name: string;
+  room?: string;
+  host: string;
+  path: string;
+  basePath?: string;
+  constructor(partySocketOptions: PartySocketOptions);
+  updateProperties(partySocketOptions: Partial<PartySocketOptions>): void;
+  private setWSProperties;
+  reconnect(code?: number | undefined, reason?: string | undefined): void;
+  get id(): string;
+  /**
+   * Exposes the static PartyKit room URL without applying query parameters.
+   * To access the currently connected WebSocket url, use PartySocket#url.
+   */
+  get roomUrl(): string;
+  static fetch(options: PartyFetchOptions, init?: RequestInit): Promise<Response>;
+} //#endregion
+//#endregion
+//#region src/types.d.ts
+type AgentConnectionStatus = "connecting" | "connected" | "disconnected" | "unauthorized";
+type AgentConnectionType = "agent" | "chat" | "assistant";
+type AgentConnectionState = {
+  status: AgentConnectionStatus;
+  type: AgentConnectionType;
   subAgentName?: string;
+};
+//#endregion
+//#region src/useAgent.d.ts
+interface UseAgentOptions {
+  host: string;
+  agentName: string;
+  id: string;
+  enabled?: boolean;
+  sub?: {
+    agent: string;
+    name: string;
+  }[];
+  authToken?: string;
+}
+declare function useAgent<T extends AgentConnectionState>(options: UseAgentOptions): Omit<PartySocket, "path"> & {
+  agent: string;
+  name: string;
+  path: ReadonlyArray<{
+    agent: string;
+    name: string;
+  }>;
+  identified: boolean;
+  ready: Promise<void>;
+  state: T | undefined;
+  setState: (state: T) => void;
+  call: <T_1 = unknown>(method: string, args?: unknown[], options?: _$agents_client0.CallOptions | _$agents_client0.StreamOptions) => Promise<T_1>;
+  stub: _$agents_client0.UntypedAgentStub;
+  getHttpUrl: () => string;
+};
+//#endregion
+//#region src/useAssistant.d.ts
+/** Conversation summary returned by the assistant's `getConversations` RPC. */
+type Conversation = {
+  durable_object_name: string;
+  title?: string;
+  summary?: string;
+  created_at: number;
+  updated_at: number;
+};
+interface UseAssistantOptions<ToolContext extends Record<string, unknown> = Record<string, unknown>> {
+  host: string;
+  assistantName: string;
+  userId: string;
+  chatId?: string;
+  authToken?: string;
+  toolContext?: ToolContext;
+}
+declare function useAssistant<ToolContext extends Record<string, unknown>>(options: UseAssistantOptions<ToolContext>): {
+  chatId: string | undefined;
+  status: AgentConnectionStatus;
+  getConversations: () => Promise<Conversation[]>;
+  createConversation: () => Promise<string>;
+  openConversation: (chatId: string) => void;
+  deleteConversation: (chatId: string) => Promise<void>;
+  agent: Omit<PartySocket, "path"> & {
+    agent: string;
+    name: string;
+    path: ReadonlyArray<{
+      agent: string;
+      name: string;
+    }>;
+    identified: boolean;
+    ready: Promise<void>;
+    state: AgentConnectionState | undefined;
+    setState: (state: AgentConnectionState) => void;
+    call: <T = unknown>(method: string, args?: unknown[], options?: _$agents_client0.CallOptions | _$agents_client0.StreamOptions) => Promise<T>;
+    stub: _$agents_client0.UntypedAgentStub;
+    getHttpUrl: () => string;
+  };
+  chat: (Omit<_$_ai_sdk_react0.UseChatHelpers<_$ai.UIMessage<unknown, _$ai.UIDataTypes, _$ai.UITools>>, "addToolOutput"> & {
+    clearHistory: () => void;
+    addToolOutput: (opts: {
+      toolCallId: string;
+      toolName?: string;
+      output?: unknown;
+      state?: "output-available" | "output-error";
+      errorText?: string;
+    }) => void;
+    isServerStreaming: boolean;
+    isStreaming: boolean;
+    isToolContinuation: boolean;
+  }) | undefined;
+};
+//#endregion
+//#region src/useChatAgent.d.ts
+interface UseChatOptions<ToolContext extends Record<string, unknown>> {
+  host: string;
+  agentName: string;
+  id: string;
   authToken?: string;
-  toolContext?: Record<string, unknown>;
-  connectionParams?: Record<string, string>;
-  welcomeMessage?: string;
-  onConnectionStatusChange?: (status: AgentConnectionStatus) => void;
-  onOpen?: () => void;
-  onClose?: (event: CloseEvent) => void;
-  onError?: (event: ErrorEvent) => void;
+  toolContext?: ToolContext;
 }
-type UseAIChatAgentResult = {
-  agent: ReturnType<typeof useAgent>;
-  chat: ReturnType<typeof useAgentChat>;
-  connectionStatus: AgentConnectionStatus;
+declare function useChatAgent<ToolContext extends Record<string, unknown>>(options: UseChatOptions<ToolContext>): {
+  status: AgentConnectionStatus;
+  agent: Omit<PartySocket, "path"> & {
+    agent: string;
+    name: string;
+    path: ReadonlyArray<{
+      agent: string;
+      name: string;
+    }>;
+    identified: boolean;
+    ready: Promise<void>;
+    state: AgentConnectionState | undefined;
+    setState: (state: AgentConnectionState) => void;
+    call: <T = unknown>(method: string, args?: unknown[], options?: _$agents_client0.CallOptions | _$agents_client0.StreamOptions) => Promise<T>;
+    stub: _$agents_client0.UntypedAgentStub;
+    getHttpUrl: () => string;
+  };
+  chat: Omit<_$_ai_sdk_react0.UseChatHelpers<_$ai.UIMessage<unknown, _$ai.UIDataTypes, _$ai.UITools>>, "addToolOutput"> & {
+    clearHistory: () => void;
+    addToolOutput: (opts: {
+      toolCallId: string;
+      toolName?: string;
+      output?: unknown;
+      state?: "output-available" | "output-error";
+      errorText?: string;
+    }) => void;
+    isServerStreaming: boolean;
+    isStreaming: boolean;
+    isToolContinuation: boolean;
+  };
 };
-declare function useAIChatAgent(options: UseAIChatAgentOptions): UseAIChatAgentResult;
 //#endregion
-export { AgentConnectionStatus, UseAIChatAgentOptions, useAIChatAgent };
+export { AgentConnectionState, AgentConnectionStatus, AgentConnectionType, Conversation, UseAgentOptions, UseAssistantOptions, UseChatOptions, useAgent, useAssistant, useChatAgent };

package/dist/index.mjs

@@ -1,121 +1,100 @@
+import { useAgent as useAgent$1 } from "agents/react";
 import { useAgentChat } from "@cloudflare/ai-chat/react";
-import { useAgent } from "agents/react";
-import React from "react";
-//#region src/index.ts
-function agentNameToKebab(name) {
-	if (name === name.toUpperCase() && name !== name.toLowerCase()) return name.toLowerCase().replace(/_/g, "-");
-	let result = name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-	result = result.startsWith("-") ? result.slice(1) : result;
-	return result.replace(/_/g, "-").replace(/-$/, "");
-}
-function buildAgentHttpBaseUrl(options) {
-	const hostPart = options.host.replace(/^https?:\/\//, "").replace(/\/$/, "");
-	const protocol = hostPart.startsWith("localhost:") || hostPart.startsWith("127.0.0.1:") || hostPart.startsWith("192.168.") || hostPart.startsWith("10.") ? "http" : "https";
-	let pathname = `/agents/${agentNameToKebab(options.agent)}/${encodeURIComponent(options.name)}`;
-	for (const step of options.sub ?? []) pathname += `/sub/${agentNameToKebab(step.agent)}/${encodeURIComponent(step.name)}`;
-	return `${protocol}://${hostPart}${pathname}`;
+import { useState } from "react";
+//#region src/util.ts
+function getTokenArgs(authToken) {
+	if (!authToken) return {};
+	return {
+		headers: { Authorization: `Bearer ${authToken}` },
+		protocols: ["bearer", authToken]
+	};
 }
-function useAIChatAgent(options) {
-	const { agent: agentName, host, basePath, chatId, userId, subAgentName, authToken, toolContext, connectionParams, welcomeMessage, onConnectionStatusChange, onOpen: onOpenProp, onClose: onCloseProp, onError: onErrorProp } = options;
-	const [connectionStatus, setConnectionStatus] = React.useState("connecting");
-	const updateConnectionStatus = React.useCallback((status) => {
-		setConnectionStatus(status);
-		onConnectionStatusChange?.(status);
-	}, [onConnectionStatusChange]);
-	let headers = {};
-	let protocols = [];
-	if (authToken) {
-		headers["Authorization"] = `Bearer ${authToken}`;
-		protocols.push("bearer", authToken);
-	}
-	const instanceName = userId ?? chatId;
-	const subChain = React.useMemo(() => subAgentName ? [{
-		agent: subAgentName,
-		name: chatId
-	}] : [], [subAgentName, chatId]);
-	const messagesHttpBaseUrl = React.useMemo(() => buildAgentHttpBaseUrl({
+//#endregion
+//#region src/useAgent.ts
+function useAgent(options) {
+	const { host, agentName, id, enabled, sub, authToken } = options;
+	return useAgent$1({
+		enabled,
 		host,
 		agent: agentName,
-		name: instanceName,
-		sub: subChain.length > 0 ? subChain : void 0
-	}), [
+		name: id,
+		sub,
+		...getTokenArgs(authToken)
+	});
+}
+//#endregion
+//#region src/useAssistant.ts
+function useAssistant(options) {
+	const { host, assistantName, userId, chatId: initialChatId, authToken, toolContext } = options;
+	const config = {
 		host,
-		agentName,
-		instanceName,
-		subChain
-	]);
+		agentName: assistantName,
+		id: userId,
+		authToken
+	};
+	const [chatId, setChatId] = useState(initialChatId);
+	const assistant = useAgent(config);
+	const getConversations = async () => {
+		return await assistant.call("getConversations");
+	};
+	const createConversation = async () => {
+		const chatId = await assistant.call("createConversation");
+		setChatId(chatId);
+		await getConversations();
+		return chatId;
+	};
+	const openConversation = (chatId) => {
+		setChatId(chatId);
+	};
+	const deleteConversation = async (chatId) => {
+		await assistant.call("deleteConversation", [chatId]);
+		setChatId(void 0);
+		await getConversations();
+	};
 	const agent = useAgent({
-		agent: agentName,
-		host,
-		basePath,
-		name: instanceName,
-		sub: subChain.length > 0 ? subChain : void 0,
-		query: connectionParams ?? {},
-		queryDeps: Object.keys(connectionParams ?? {}),
-		onStateUpdate(state) {
-			if (state.status === "connected") {
-				updateConnectionStatus("connected");
-				onOpenProp?.();
-			}
-		},
-		onClose: (event) => {
-			if (event.code >= 3e3) {
-				updateConnectionStatus("unauthorized");
-				agent.close();
-				onCloseProp?.(event);
-				return;
-			}
-			updateConnectionStatus("disconnected");
-			onCloseProp?.(event);
-		},
-		onError: onErrorProp,
-		protocols
+		...config,
+		enabled: !!chatId,
+		sub: chatId ? [{
+			agent: assistant.state?.subAgentName ?? "",
+			name: chatId
+		}] : void 0
 	});
-	const fetchInitialMessages = React.useCallback(async (_options) => {
-		const url = `${messagesHttpBaseUrl}/get-messages`;
-		const response = await fetch(url, { headers });
-		if (!response.ok) {
-			console.warn(`[useAIChatAgent] Failed to fetch initial messages: ${response.status} ${response.statusText}`);
-			return [];
-		}
-		const text = await response.text();
-		if (!text.trim()) return [];
-		try {
-			return JSON.parse(text);
-		} catch (error) {
-			console.warn("[useAIChatAgent] Failed to parse initial messages JSON:", error);
-			return [];
-		}
-	}, [headers, messagesHttpBaseUrl]);
+	const isChatReady = !!chatId && agent.state?.status === "connected";
 	const chat = useAgentChat({
 		agent,
 		body: toolContext ?? {},
-		headers,
-		getInitialMessages: fetchInitialMessages
+		getInitialMessages: isChatReady ? void 0 : null
+	});
+	return {
+		chatId,
+		status: (chatId ? agent.state?.status : assistant.state?.status) ?? "connecting",
+		getConversations,
+		createConversation,
+		openConversation,
+		deleteConversation,
+		agent,
+		chat: isChatReady ? chat : void 0
+	};
+}
+//#endregion
+//#region src/useChatAgent.ts
+function useChatAgent(options) {
+	const { host, agentName, id, authToken, toolContext } = options;
+	const agent = useAgent({
+		host,
+		agentName,
+		id,
+		authToken
+	});
+	const chat = useAgentChat({
+		agent,
+		body: toolContext ?? {}
 	});
-	const hasSentWelcome = React.useRef(false);
-	React.useEffect(() => {
-		if (welcomeMessage && connectionStatus === "connected" && chat.messages.length === 0 && !hasSentWelcome.current) {
-			hasSentWelcome.current = true;
-			chat.setMessages([{
-				id: "welcome-message",
-				role: "assistant",
-				parts: [{
-					type: "text",
-					text: welcomeMessage
-				}]
-			}]);
-		}
-	}, [
-		connectionStatus,
-		chat.messages.length,
-		welcomeMessage
-	]);
 	return {
+		status: agent.state?.status ?? "connecting",
 		agent,
-		chat,
-		connectionStatus
+		chat
 	};
 }
 //#endregion
-export { useAIChatAgent };
+export { useAgent, useAssistant, useChatAgent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@economic/agents-react",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "license": "MIT",
   "files": [
     "dist"
@@ -18,8 +18,14 @@
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
+  "dependencies": {
+    "@ai-sdk/react": "^3.0.182",
+    "@cloudflare/ai-chat": ">=0.7.2 <1.0.0",
+    "agents": ">=0.13.3 <1.0.0",
+    "ai": "^6.0.180",
+    "zod": "^4.4.3"
+  },
   "devDependencies": {
-    "@cloudflare/ai-chat": "^0.7.2",
     "@cloudflare/workers-types": "^4.20260527.1",
     "@types/node": "^25.6.0",
     "@typescript/native-preview": "7.0.0-dev.20260412.1",
@@ -28,8 +34,9 @@
     "vitest": "^4.1.4"
   },
   "peerDependencies": {
-    "@cloudflare/ai-chat": ">=0.7.2 <1.0.0",
-    "agents": ">=0.13.3 <1.0.0",
-    "react": "^19.2.5"
+    "react": "^19"
+  },
+  "inlinedDependencies": {
+    "partysocket": "1.1.19"
   }
 }