agents 0.0.0-415bc49 → 0.0.0-449f1f2

package/dist/client.d.ts

@@ -1,98 +1,17 @@
+import "./serializable-CymX8ovI.js";
 import {
-  PartySocketOptions,
-  PartyFetchOptions,
-  PartySocket
-} from "partysocket";
-import { SerializableReturnValue, SerializableValue } from "./serializable.js";
-
-/**
- * Options for creating an AgentClient
- */
-type AgentClientOptions<State = unknown> = Omit<
-  PartySocketOptions,
-  "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;
-};
-/**
- * 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 the agentFetch function
- */
-type AgentClientFetchOptions = Omit<PartyFetchOptions, "party" | "room"> & {
-  /** Name of the agent to connect to */
-  agent: string;
-  /** Name of the specific Agent instance */
-  name?: string;
-};
-/**
- * Convert a camelCase string to a kebab-case string
- * @param str The string to convert
- * @returns The kebab-case string
- */
-declare function camelCaseToKebabCase(str: string): string;
-/**
- * WebSocket client for connecting to an Agent
- */
-declare class AgentClient<State = unknown> extends PartySocket {
-  /**
-   * @deprecated Use agentFetch instead
-   */
-  static fetch(_opts: PartyFetchOptions): Promise<Response>;
-  agent: string;
-  name: string;
-  private options;
-  private _pendingCalls;
-  constructor(options: AgentClientOptions<State>);
-  setState(state: State): void;
-  /**
-   * Call a method on the Agent
-   * @param method Name of the method to call
-   * @param args Arguments to pass to the method
-   * @param streamOptions Options for handling streaming responses
-   * @returns Promise that resolves with the method's return value
-   */
-  call<T extends SerializableReturnValue>(
-    method: string,
-    args?: SerializableValue[],
-    streamOptions?: StreamOptions
-  ): Promise<T>;
-  call<T = unknown>(
-    method: string,
-    args?: unknown[],
-    streamOptions?: StreamOptions
-  ): Promise<T>;
-}
-/**
- * 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>;
-
+  a as agentFetch,
+  i as StreamOptions,
+  n as AgentClientFetchOptions,
+  o as camelCaseToKebabCase,
+  r as AgentClientOptions,
+  t as AgentClient
+} from "./client-CbWe9FBd.js";
 export {
   AgentClient,
-  type AgentClientFetchOptions,
-  type AgentClientOptions,
-  type StreamOptions,
+  AgentClientFetchOptions,
+  AgentClientOptions,
+  StreamOptions,
   agentFetch,
   camelCaseToKebabCase
 };

package/dist/client.js

@@ -1,13 +1,4 @@
-import {
-  AgentClient,
-  agentFetch,
-  camelCaseToKebabCase
-} from "./chunk-QEVM4BVL.js";
-import "./chunk-BER7KXUJ.js";
-import "./chunk-PR4QN5HX.js";
-export {
-  AgentClient,
-  agentFetch,
-  camelCaseToKebabCase
-};
-//# sourceMappingURL=client.js.map
+import "./ai-types-B3aQaFv3.js";
+import { n as agentFetch, r as camelCaseToKebabCase, t as AgentClient } from "./client-BfiZ3HQd.js";
+
+export { AgentClient, agentFetch, camelCaseToKebabCase };

package/dist/codemode/ai.d.ts

@@ -1,25 +1,27 @@
-import { ToolSet } from 'ai';
-import { WorkerEntrypoint } from 'cloudflare:workers';
+import { ToolSet } from "ai";
+import { WorkerEntrypoint } from "cloudflare:workers";
 
+//#region src/codemode/ai.d.ts
 declare class CodeModeProxy extends WorkerEntrypoint<Cloudflare.Env, {
-    binding: string;
-    name: string;
-    callback: string;
+  binding: string;
+  name: string;
+  callback: string;
 }> {
-    callFunction(options: {
-        functionName: string;
-        args: unknown[];
-    }): Promise<any>;
+  callFunction(options: {
+    functionName: string;
+    args: unknown[];
+  }): Promise<any>;
 }
 declare function experimental_codemode(options: {
-    tools: ToolSet;
-    prompt: string;
-    globalOutbound: Fetcher;
-    loader: WorkerLoader;
-    proxy: Fetcher<CodeModeProxy>;
+  tools: ToolSet;
+  prompt: string;
+  globalOutbound: Fetcher;
+  loader: WorkerLoader;
+  proxy: Fetcher<CodeModeProxy>;
 }): Promise<{
-    prompt: string;
-    tools: ToolSet;
+  prompt: string;
+  tools: ToolSet;
 }>;
-
+//#endregion
 export { CodeModeProxy, experimental_codemode };
+//# sourceMappingURL=ai.d.ts.map