agents 0.0.0-f6b2319 → 0.0.0-f75507d

package/dist/{mcp-BH1fJeiU.d.ts → mcp-Dw5vDrY8.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-Dw5vDrY8.d.ts.map

package/dist/observability/index.d.ts

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

package/dist/observability/index.js

@@ -1,12 +1,7 @@
-import {
-  genericObservability
-} from "../chunk-254F4GDT.js";
-import "../chunk-3OT2NNEW.js";
-import "../chunk-Z44WASMA.js";
-import "../chunk-QEVM4BVL.js";
-import "../chunk-BER7KXUJ.js";
-import "../chunk-PR4QN5HX.js";
-export {
-  genericObservability
-};
-//# sourceMappingURL=index.js.map
+import "../ai-types-B3aQaFv3.js";
+import "../client-BfiZ3HQd.js";
+import "../client-JMskg2fw.js";
+import "../do-oauth-client-provider-CswoD5Lu.js";
+import { f as genericObservability } from "../src-nFNV3Ttx.js";
+
+export { genericObservability };

package/dist/react-BIh615qN.d.ts

@@ -0,0 +1,115 @@
+import { m as MCPServersState, t as Agent } from "./index-DxXJbYBM.js";
+import { n as RPCMethod, t as Method } from "./serializable-CymX8ovI.js";
+import { i as StreamOptions } from "./client-CbWe9FBd.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$1> = T$1 extends [infer A, ...infer R]
+  ? undefined extends A
+    ? AllOptional<R>
+    : false
+  : true;
+type RPCMethods<T$1> = {
+  [K in keyof T$1 as T$1[K] extends RPCMethod<T$1[K]> ? K : never]: RPCMethod<
+    T$1[K]
+  >;
+};
+type OptionalParametersMethod<T$1 extends RPCMethod> =
+  AllOptional<Parameters<T$1>> extends true ? T$1 : never;
+type AgentMethods<T$1> = Omit<RPCMethods<T$1>, keyof Agent<any, any>>;
+type OptionalAgentMethods<T$1> = {
+  [K in keyof AgentMethods<T$1> as AgentMethods<T$1>[K] extends OptionalParametersMethod<
+    AgentMethods<T$1>[K]
+  >
+    ? K
+    : never]: OptionalParametersMethod<AgentMethods<T$1>[K]>;
+};
+type RequiredAgentMethods<T$1> = Omit<
+  AgentMethods<T$1>,
+  keyof OptionalAgentMethods<T$1>
+>;
+type AgentPromiseReturnType<T$1, K$1 extends keyof AgentMethods<T$1>> =
+  ReturnType<AgentMethods<T$1>[K$1]> extends Promise<any>
+    ? ReturnType<AgentMethods<T$1>[K$1]>
+    : Promise<ReturnType<AgentMethods<T$1>[K$1]>>;
+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$1> = {
+  [K in keyof AgentMethods<T$1>]: (
+    ...args: Parameters<AgentMethods<T$1>[K]>
+  ) => AgentPromiseReturnType<AgentMethods<T$1>, 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 { useAgent as n, UseAgentOptions as t };
+//# sourceMappingURL=react-BIh615qN.d.ts.map

package/dist/react.d.ts

@@ -1,127 +1,10 @@
-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";
-
-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>;
-};
-
-export { type UseAgentOptions, useAgent };
+import "./client-DbS2uI6p.js";
+import "./mcp-Dw5vDrY8.js";
+import "./do-oauth-client-provider-DGc5pP0l.js";
+import "./index-DhJCaDWd.js";
+import "./ai-types-D5YoPrBZ.js";
+import "./index-DxXJbYBM.js";
+import "./serializable-CymX8ovI.js";
+import "./client-CbWe9FBd.js";
+import { n as useAgent, t as UseAgentOptions } from "./react-BIh615qN.js";
+export { UseAgentOptions, useAgent };