agents 0.0.0-06b2ab0 → 0.0.0-087264c

package/dist/{mcp-BH1fJeiU.d.ts → mcp-CPSfGUgd.d.ts}

@@ -1,3 +1,4 @@
+//#region src/observability/base.d.ts
 /**
  * Base event structure for all observability events
  */
@@ -24,7 +25,8 @@ type BaseEvent<
    */
   timestamp: number;
 };
-
+//#endregion
+//#region src/observability/mcp.d.ts
 /**
  * MCP-specific observability events
  * These track the lifecycle of MCP connections and operations
@@ -54,5 +56,6 @@ type MCPObservabilityEvent =
       }
     >
   | BaseEvent<"mcp:client:discover", {}>;
-
-export type { BaseEvent as B, MCPObservabilityEvent as M };
+//#endregion
+export { BaseEvent as n, MCPObservabilityEvent as t };
+//# sourceMappingURL=mcp-CPSfGUgd.d.ts.map

package/dist/observability/index.d.ts

@@ -1,34 +1,2 @@
-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 };
+import { n as ObservabilityEvent, r as genericObservability, t as Observability } from "../index-DLuxm_9W.js";
+export { Observability, ObservabilityEvent, genericObservability };

package/dist/observability/index.js

@@ -1,12 +1,7 @@
-import {
-  genericObservability
-} from "../chunk-XGMKNUJA.js";
-import "../chunk-ZMMHNOMZ.js";
-import "../chunk-C2OEBJZ2.js";
-import "../chunk-QEVM4BVL.js";
-import "../chunk-BER7KXUJ.js";
-import "../chunk-PR4QN5HX.js";
-export {
-  genericObservability
-};
-//# sourceMappingURL=index.js.map
+import "../context-BkKbAa1R.js";
+import "../client-DjTPRM8-.js";
+import "../client-QZa2Rq0l.js";
+import "../do-oauth-client-provider-B1fVIshX.js";
+import { f as genericObservability } from "../src-BZDh910Z.js";
+
+export { genericObservability };

package/dist/react.d.ts

@@ -1,26 +1,32 @@
+import "./context-DcbQ8o7k.js";
+import "./client-DFotUKH_.js";
+import "./ai-types-0OnT3FHg.js";
+import { p as MCPServersState, t as Agent } from "./index-BaskqQ6f.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";
-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";
 
+//#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
@@ -66,24 +72,24 @@ 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 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 extends keyof OptionalAgentMethods<AgentT>
+  K$1 extends keyof OptionalAgentMethods<AgentT>
 >(
-  method: K,
-  args?: Parameters<OptionalAgentMethods<AgentT>[K]>,
+  method: K$1,
+  args?: Parameters<OptionalAgentMethods<AgentT>[K$1]>,
   streamOptions?: StreamOptions
-) => AgentPromiseReturnType<AgentT, K>;
+) => AgentPromiseReturnType<AgentT, K$1>;
 type RequiredArgsAgentMethodCall<AgentT> = <
-  K extends keyof RequiredAgentMethods<AgentT>
+  K$1 extends keyof RequiredAgentMethods<AgentT>
 >(
-  method: K,
-  args: Parameters<RequiredAgentMethods<AgentT>[K]>,
+  method: K$1,
+  args: Parameters<RequiredAgentMethods<AgentT>[K$1]>,
   streamOptions?: StreamOptions
-) => AgentPromiseReturnType<AgentT, K>;
+) => AgentPromiseReturnType<AgentT, K$1>;
 type AgentMethodCall<AgentT> = OptionalArgsAgentMethodCall<AgentT> &
   RequiredArgsAgentMethodCall<AgentT>;
 type UntypedAgentMethodCall = <T = unknown>(
@@ -123,5 +129,6 @@ declare function useAgent<
   call: AgentMethodCall<AgentT>;
   stub: AgentStub<AgentT>;
 };
-
-export { type UseAgentOptions, useAgent };
+//#endregion
+export { UseAgentOptions, _testUtils, useAgent };
+//# sourceMappingURL=react.d.ts.map

package/dist/react.js

@@ -1,216 +1,189 @@
-import "./chunk-BER7KXUJ.js";
-import "./chunk-PR4QN5HX.js";
-
-// src/react.tsx
+import { t as MessageType } from "./ai-types-DEtF_8Km.js";
+import { use, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { usePartySocket } from "partysocket/react";
-import { useCallback, useRef, use, useMemo, useEffect } 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(/-$/, "");
 }
-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;
+const queryCache = /* @__PURE__ */ new Map();
+function createCacheKey(agentNamespace, name, deps) {
+	return JSON.stringify([
+		agentNamespace,
+		name || "default",
+		...deps
+	]);
 }
-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 getCacheEntry(key) {
+	const entry = queryCache.get(key);
+	if (!entry) return void 0;
+	if (Date.now() >= entry.expiresAt) {
+		queryCache.delete(key);
+		return;
+	}
+	return entry;
 }
-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 setCacheEntry(key, promise, cacheTtl) {
+	const entry = {
+		promise,
+		expiresAt: Date.now() + cacheTtl
+	};
+	queryCache.set(key, entry);
+	return entry;
 }
-function createCacheKey(agentNamespace, name, deps) {
-  return [agentNamespace, name || "default", ...deps];
+function deleteCacheEntry(key) {
+	queryCache.delete(key);
 }
+const _testUtils = {
+	queryCache,
+	setCacheEntry,
+	getCacheEntry,
+	deleteCacheEntry,
+	clearCache: () => queryCache.clear()
+};
 function useAgent(options) {
-  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 === "cf_agent_state" /* CF_AGENT_STATE */) {
-          options.onStateUpdate?.(parsedMessage.state, "server");
-          return;
-        }
-        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;
-          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" /* RPC */
-        };
-        agent.send(JSON.stringify(request));
-      });
-    },
-    [agent]
-  );
-  agent.setState = (state) => {
-    agent.send(JSON.stringify({ state, type: "cf_agent_state" /* 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(() => createCacheKey(agentNamespace, options.name, queryDeps || []), [
+		agentNamespace,
+		options.name,
+		queryDeps
+	]);
+	const ttl = cacheTtl ?? 300 * 1e3;
+	const [cacheInvalidatedAt, setCacheInvalidatedAt] = useState(0);
+	const queryPromise = useMemo(() => {
+		if (!query || typeof query !== "function") return null;
+		const cached = getCacheEntry(cacheKey);
+		if (cached) return cached.promise;
+		const promise = query().catch((error) => {
+			console.error(`[useAgent] Query failed for agent "${options.agent}":`, error);
+			deleteCacheEntry(cacheKey);
+			throw error;
+		});
+		setCacheEntry(cacheKey, promise, ttl);
+		return promise;
+	}, [
+		cacheKey,
+		query,
+		options.agent,
+		ttl,
+		cacheInvalidatedAt
+	]);
+	useEffect(() => {
+		if (!queryPromise || ttl <= 0) return;
+		const entry = getCacheEntry(cacheKey);
+		if (!entry) return;
+		const timeUntilExpiry = entry.expiresAt - Date.now();
+		const timer = setTimeout(() => {
+			deleteCacheEntry(cacheKey);
+			setCacheInvalidatedAt(Date.now());
+		}, Math.max(0, timeUntilExpiry));
+		return () => clearTimeout(timer);
+	}, [
+		cacheKey,
+		queryPromise,
+		ttl
+	]);
+	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;
+	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 { _testUtils, useAgent };
 //# sourceMappingURL=react.js.map