agents 0.0.0-d40512c → 0.0.0-d4257c1

package/dist/mcp-BEwaCsxO.d.ts

@@ -0,0 +1,61 @@
+//#region src/observability/base.d.ts
+/**
+ * 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;
+};
+//#endregion
+//#region src/observability/mcp.d.ts
+/**
+ * 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", {}>;
+//#endregion
+export { BaseEvent, MCPObservabilityEvent };
+//# sourceMappingURL=mcp-BEwaCsxO.d.ts.map

package/dist/observability/index.d.ts

@@ -1,12 +1,3 @@
-import 'ai';
-export { b as Observability, O as ObservabilityEvent, g as genericObservability } from '../index-CITGJflw.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'partyserver';
-import '../mcp/client.js';
-import 'zod';
-import '@modelcontextprotocol/sdk/client/sse.js';
-import '@modelcontextprotocol/sdk/shared/protocol.js';
-import '../mcp/do-oauth-client-provider.js';
-import '@modelcontextprotocol/sdk/client/auth.js';
-import '@modelcontextprotocol/sdk/shared/auth.js';
+import "../mcp-BEwaCsxO.js";
+import { Observability, ObservabilityEvent, genericObservability } from "../index-W4JUkafc.js";
+export { Observability, ObservabilityEvent, genericObservability };

package/dist/observability/index.js

@@ -1,10 +1,7 @@
-import {
-  genericObservability
-} from "../chunk-LU2RSO54.js";
-import "../chunk-4RBEYCWK.js";
-import "../chunk-PVQZBKN7.js";
-import "../chunk-KUH345EY.js";
-export {
-  genericObservability
-};
-//# sourceMappingURL=index.js.map
+import "../ai-types-UZlfLOYP.js";
+import "../client-DjR-lC16.js";
+import "../client-CZBVDDoO.js";
+import "../do-oauth-client-provider-B2jr6UNq.js";
+import { genericObservability } from "../src-COfG--3R.js";
+
+export { genericObservability };

package/dist/react-B4e1rDid.d.ts

@@ -0,0 +1,113 @@
+import { Agent, MCPServersState } from "./index-CkQU40oY.js";
+import { Method, RPCMethod } from "./serializable-gtr9YMhp.js";
+import { StreamOptions } from "./client-CmMi85Sj.js";
+import { PartySocket } from "partysocket";
+import { usePartySocket } from "partysocket/react";
+
+//#region src/react.d.ts
+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" | "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
+ */
+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, useAgent };
+//# sourceMappingURL=react-B4e1rDid.d.ts.map

package/dist/react.d.ts

@@ -1,119 +1,10 @@
-import { PartySocket } from "partysocket";
-import { usePartySocket } from "partysocket/react";
-import { M as MCPServersState, A as Agent } from "./index-CITGJflw.js";
-import { StreamOptions } from "./client.js";
-import { Method, RPCMethod } from "./serializable.js";
-import "@modelcontextprotocol/sdk/client/index.js";
-import "@modelcontextprotocol/sdk/types.js";
-import "partyserver";
-import "./mcp/client.js";
-import "zod";
-import "@modelcontextprotocol/sdk/client/sse.js";
-import "@modelcontextprotocol/sdk/shared/protocol.js";
-import "ai";
-import "./mcp/do-oauth-client-provider.js";
-import "@modelcontextprotocol/sdk/client/auth.js";
-import "@modelcontextprotocol/sdk/shared/auth.js";
-
-/**
- * Options for the useAgent hook
- * @template State Type of the Agent's state
- */
-type UseAgentOptions<State = unknown> = Omit<
-  Parameters<typeof usePartySocket>[0],
-  "party" | "room"
-> & {
-  /** Name of the agent to connect to */
-  agent: string;
-  /** Name of the specific Agent instance */
-  name?: string;
-  /** Called when the Agent's state is updated */
-  onStateUpdate?: (state: State, source: "server" | "client") => void;
-  /** 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
- * @template Agent Type of the Agent
- * @param options Connection options
- * @returns WebSocket connection with setState and call methods
- */
-declare function useAgent<State = unknown>(
-  options: UseAgentOptions<State>
-): PartySocket & {
-  agent: string;
-  name: string;
-  setState: (state: State) => void;
-  call: 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 };
+import "./client-C-nwz-3N.js";
+import "./mcp-BEwaCsxO.js";
+import "./do-oauth-client-provider-CCwGwnrA.js";
+import "./index-W4JUkafc.js";
+import "./ai-types-BWW4umHY.js";
+import "./index-CkQU40oY.js";
+import "./serializable-gtr9YMhp.js";
+import "./client-CmMi85Sj.js";
+import { UseAgentOptions, useAgent } from "./react-B4e1rDid.js";
+export { UseAgentOptions, useAgent };

package/dist/react.js

@@ -1,116 +1,189 @@
-// src/react.tsx
+import { MessageType } from "./ai-types-UZlfLOYP.js";
+import { use, useCallback, useEffect, useMemo, useRef } from "react";
 import { usePartySocket } from "partysocket/react";
-import { useCallback, useRef } from "react";
+
+//#region src/react.tsx
+/**
+* Convert a camelCase string to a kebab-case string
+* @param str The string to convert
+* @returns The kebab-case string
+*/
 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(/-$/, "");
+	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(/-$/, "");
+}
+const 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;
+		}
+		entry.refCount++;
+		return entry.promise;
+	}
+}
+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() + 300 * 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 pendingCallsRef = useRef(
-    /* @__PURE__ */ new Map()
-  );
-  const agent = usePartySocket({
-    party: agentNamespace,
-    prefix: "agents",
-    room: options.name || "default",
-    ...options,
-    onMessage: (message) => {
-      if (typeof message.data === "string") {
-        let parsedMessage;
-        try {
-          parsedMessage = JSON.parse(message.data);
-        } catch (_error) {
-          return options.onMessage?.(message);
-        }
-        if (parsedMessage.type === "cf_agent_state") {
-          options.onStateUpdate?.(parsedMessage.state, "server");
-          return;
-        }
-        if (parsedMessage.type === "cf_agent_mcp_servers") {
-          options.onMcpUpdate?.(parsedMessage.mcp);
-          return;
-        }
-        if (parsedMessage.type === "rpc") {
-          const response = parsedMessage;
-          const pending = pendingCallsRef.current.get(response.id);
-          if (!pending) return;
-          if (!response.success) {
-            pending.reject(new Error(response.error));
-            pendingCallsRef.current.delete(response.id);
-            pending.stream?.onError?.(response.error);
-            return;
-          }
-          if ("done" in response) {
-            if (response.done) {
-              pending.resolve(response.result);
-              pendingCallsRef.current.delete(response.id);
-              pending.stream?.onDone?.(response.result);
-            } else {
-              pending.stream?.onChunk?.(response.result);
-            }
-          } else {
-            pending.resolve(response.result);
-            pendingCallsRef.current.delete(response.id);
-          }
-          return;
-        }
-      }
-      options.onMessage?.(message);
-    }
-  });
-  const call = useCallback(
-    (method, args = [], streamOptions) => {
-      return new Promise((resolve, reject) => {
-        const id = Math.random().toString(36).slice(2);
-        pendingCallsRef.current.set(id, {
-          reject,
-          resolve,
-          stream: streamOptions
-        });
-        const request = {
-          args,
-          id,
-          method,
-          type: "rpc"
-        };
-        agent.send(JSON.stringify(request));
-      });
-    },
-    [agent]
-  );
-  agent.setState = (state) => {
-    agent.send(JSON.stringify({ state, type: "cf_agent_state" }));
-    options.onStateUpdate?.(state, "client");
-  };
-  agent.call = call;
-  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}`
-    );
-  }
-  return agent;
+	const agentNamespace = camelCaseToKebabCase(options.agent);
+	const { query, queryDeps, cacheTtl,...restOptions } = options;
+	const pendingCallsRef = useRef(/* @__PURE__ */ new Map());
+	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",
+		room: options.name || "default",
+		query: resolvedQuery,
+		...restOptions,
+		onMessage: (message) => {
+			if (typeof message.data === "string") {
+				let parsedMessage;
+				try {
+					parsedMessage = JSON.parse(message.data);
+				} catch (_error) {
+					return options.onMessage?.(message);
+				}
+				if (parsedMessage.type === MessageType.CF_AGENT_STATE) {
+					options.onStateUpdate?.(parsedMessage.state, "server");
+					return;
+				}
+				if (parsedMessage.type === MessageType.CF_AGENT_MCP_SERVERS) {
+					options.onMcpUpdate?.(parsedMessage.mcp);
+					return;
+				}
+				if (parsedMessage.type === MessageType.RPC) {
+					const response = parsedMessage;
+					const pending = pendingCallsRef.current.get(response.id);
+					if (!pending) return;
+					if (!response.success) {
+						pending.reject(new Error(response.error));
+						pendingCallsRef.current.delete(response.id);
+						pending.stream?.onError?.(response.error);
+						return;
+					}
+					if ("done" in response) if (response.done) {
+						pending.resolve(response.result);
+						pendingCallsRef.current.delete(response.id);
+						pending.stream?.onDone?.(response.result);
+					} else pending.stream?.onChunk?.(response.result);
+					else {
+						pending.resolve(response.result);
+						pendingCallsRef.current.delete(response.id);
+					}
+					return;
+				}
+			}
+			options.onMessage?.(message);
+		}
+	});
+	const call = useCallback((method, args = [], streamOptions) => {
+		return new Promise((resolve, reject) => {
+			const id = Math.random().toString(36).slice(2);
+			pendingCallsRef.current.set(id, {
+				reject,
+				resolve,
+				stream: streamOptions
+			});
+			const request = {
+				args,
+				id,
+				method,
+				type: MessageType.RPC
+			};
+			agent.send(JSON.stringify(request));
+		});
+	}, [agent]);
+	agent.setState = (state) => {
+		agent.send(JSON.stringify({
+			state,
+			type: MessageType.CF_AGENT_STATE
+		}));
+		options.onStateUpdate?.(state, "client");
+	};
+	agent.call = call;
+	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}`);
+	return agent;
 }
-export {
-  useAgent
-};
+
+//#endregion
+export { useAgent };
 //# sourceMappingURL=react.js.map