agents 0.0.0-d7d2876 → 0.0.0-df716f2

package/README.md

@@ -316,18 +316,14 @@ Create meaningful conversations with intelligence:
 
 ```ts
 import { AIChatAgent } from "agents/ai-chat-agent";
-import { createOpenAI } from "@ai-sdk/openai";
+import { openai } from "@ai-sdk/openai";
 
 export class DialogueAgent extends AIChatAgent {
   async onChatMessage(onFinish) {
     return createDataStreamResponse({
       execute: async (dataStream) => {
-        const ai = createOpenAI({
-          apiKey: this.env.OPENAI_API_KEY,
-        });
-
         const stream = streamText({
-          model: ai("gpt-4o"),
+          model: openai("gpt-4o"),
           messages: this.messages,
           onFinish, // call onFinish so that messages get saved
         });

package/dist/ai-chat-agent.d.ts

@@ -1,35 +1,31 @@
-import { Agent, AgentContext } from "./index.js";
-import { Message, StreamTextOnFinishCallback, ToolSet } from "ai";
-import { Connection, WSMessage } from "partyserver";
-import "cloudflare:workers";
+import { Agent, AgentContext } from './index.js';
+import { Message, StreamTextOnFinishCallback, ToolSet } from 'ai';
+import { Connection, WSMessage } from 'partyserver';
+import 'node:async_hooks';
+import 'cloudflare:workers';
 
 /**
  * Extension of Agent with built-in chat capabilities
  * @template Env Environment type containing bindings
  */
-declare class AIChatAgent<Env = unknown, State = unknown> extends Agent<
-  Env,
-  State
-> {
-  #private;
-  /** Array of chat messages for the current conversation */
-  messages: Message[];
-  constructor(ctx: AgentContext, env: Env);
-  onMessage(connection: Connection, message: WSMessage): Promise<void>;
-  onRequest(request: Request): Promise<Response>;
-  /**
-   * Handle incoming chat messages and generate a response
-   * @param onFinish Callback to be called when the response is finished
-   * @returns Response to send to the client or undefined
-   */
-  onChatMessage(
-    onFinish: StreamTextOnFinishCallback<ToolSet>
-  ): Promise<Response | undefined>;
-  /**
-   * Save messages on the server side and trigger AI response
-   * @param messages Chat messages to save
-   */
-  saveMessages(messages: Message[]): Promise<void>;
+declare class AIChatAgent<Env = unknown, State = unknown> extends Agent<Env, State> {
+    #private;
+    /** Array of chat messages for the current conversation */
+    messages: Message[];
+    constructor(ctx: AgentContext, env: Env);
+    onMessage(connection: Connection, message: WSMessage): Promise<void>;
+    onRequest(request: Request): Promise<Response>;
+    /**
+     * Handle incoming chat messages and generate a response
+     * @param onFinish Callback to be called when the response is finished
+     * @returns Response to send to the client or undefined
+     */
+    onChatMessage(onFinish: StreamTextOnFinishCallback<ToolSet>): Promise<Response | undefined>;
+    /**
+     * Save messages on the server side and trigger AI response
+     * @param messages Chat messages to save
+     */
+    saveMessages(messages: Message[]): Promise<void>;
 }
 
 export { AIChatAgent };

package/dist/ai-react.d.ts

@@ -1,86 +1,60 @@
-import * as ai from "ai";
-import { Message } from "ai";
-import { useChat } from "@ai-sdk/react";
-import { useAgent } from "./react.js";
-import "partysocket";
-import "partysocket/react";
-import "./client.js";
+import * as ai from 'ai';
+import { Message } from 'ai';
+import { useChat } from '@ai-sdk/react';
+import { useAgent } from './react.js';
+import 'partysocket';
+import 'partysocket/react';
+import './client.js';
 
 type GetInitialMessagesOptions = {
-  agent: string;
-  name: string;
-  url: string;
+    agent: string;
+    name: string;
+    url: string;
 };
 /**
  * Options for the useAgentChat hook
  */
-type UseAgentChatOptions = Omit<
-  Parameters<typeof useChat>[0] & {
+type UseAgentChatOptions<State> = Omit<Parameters<typeof useChat>[0] & {
     /** Agent connection from useAgent */
-    agent: ReturnType<typeof useAgent>;
-    getInitialMessages?:
-      | undefined
-      | null
-      | ((options: GetInitialMessagesOptions) => Promise<Message[]>);
-  },
-  "fetch"
->;
+    agent: ReturnType<typeof useAgent<State>>;
+    getInitialMessages?: undefined | null | ((options: GetInitialMessagesOptions) => Promise<Message[]>);
+}, "fetch">;
 /**
  * React hook for building AI chat interfaces using an Agent
  * @param options Chat options including the agent connection
  * @returns Chat interface controls and state with added clearHistory method
  */
-declare function useAgentChat(options: UseAgentChatOptions): {
-  /**
-   * Set the chat messages and synchronize with the Agent
-   * @param messages New messages to set
-   */
-  setMessages: (messages: Message[]) => void;
-  /**
-   * Clear chat history on both client and Agent
-   */
-  clearHistory: () => void;
-  messages: ai.UIMessage[];
-  error: undefined | Error;
-  append: (
-    message: Message | ai.CreateMessage,
-    chatRequestOptions?: ai.ChatRequestOptions
-  ) => Promise<string | null | undefined>;
-  reload: (
-    chatRequestOptions?: ai.ChatRequestOptions
-  ) => Promise<string | null | undefined>;
-  stop: () => void;
-  input: string;
-  setInput: React.Dispatch<React.SetStateAction<string>>;
-  handleInputChange: (
-    e:
-      | React.ChangeEvent<HTMLInputElement>
-      | React.ChangeEvent<HTMLTextAreaElement>
-  ) => void;
-  handleSubmit: (
-    event?: {
-      preventDefault?: () => void;
-    },
-    chatRequestOptions?: ai.ChatRequestOptions
-  ) => void;
-  metadata?: Object;
-  isLoading: boolean;
-  status: "submitted" | "streaming" | "ready" | "error";
-  data?: ai.JSONValue[];
-  setData: (
-    data:
-      | ai.JSONValue[]
-      | undefined
-      | ((data: ai.JSONValue[] | undefined) => ai.JSONValue[] | undefined)
-  ) => void;
-  id: string;
-  addToolResult: ({
-    toolCallId,
-    result,
-  }: {
-    toolCallId: string;
-    result: any;
-  }) => void;
+declare function useAgentChat<State = unknown>(options: UseAgentChatOptions<State>): {
+    /**
+     * Set the chat messages and synchronize with the Agent
+     * @param messages New messages to set
+     */
+    setMessages: (messages: Message[]) => void;
+    /**
+     * Clear chat history on both client and Agent
+     */
+    clearHistory: () => void;
+    messages: ai.UIMessage[];
+    error: undefined | Error;
+    append: (message: Message | ai.CreateMessage, chatRequestOptions?: ai.ChatRequestOptions) => Promise<string | null | undefined>;
+    reload: (chatRequestOptions?: ai.ChatRequestOptions) => Promise<string | null | undefined>;
+    stop: () => void;
+    input: string;
+    setInput: React.Dispatch<React.SetStateAction<string>>;
+    handleInputChange: (e: React.ChangeEvent<HTMLInputElement> | React.ChangeEvent<HTMLTextAreaElement>) => void;
+    handleSubmit: (event?: {
+        preventDefault?: () => void;
+    }, chatRequestOptions?: ai.ChatRequestOptions) => void;
+    metadata?: Object;
+    isLoading: boolean;
+    status: "submitted" | "streaming" | "ready" | "error";
+    data?: ai.JSONValue[];
+    setData: (data: ai.JSONValue[] | undefined | ((data: ai.JSONValue[] | undefined) => ai.JSONValue[] | undefined)) => void;
+    id: string;
+    addToolResult: ({ toolCallId, result, }: {
+        toolCallId: string;
+        result: any;
+    }) => void;
 };
 
 export { useAgentChat };

package/dist/ai-types.d.ts

@@ -1,69 +1,49 @@
-import { Message } from "ai";
+import { Message } from 'ai';
 
 /**
  * Types of messages sent from the Agent to clients
  */
-type OutgoingMessage =
-  | {
-      /** Indicates this message contains updated chat messages */
-      type: "cf_agent_chat_messages";
-      /** Array of chat messages */
-      messages: Message[];
-    }
-  | {
-      /** Indicates this message is a response to a chat request */
-      type: "cf_agent_use_chat_response";
-      /** Unique ID of the request this response corresponds to */
-      id: string;
-      /** Content body of the response */
-      body: string;
-      /** Whether this is the final chunk of the response */
-      done: boolean;
-    }
-  | {
-      /** Indicates this message contains updated chat messages */
-      type: "cf_agent_chat_messages";
-      /** Array of chat messages */
-      messages: Message[];
-    }
-  | {
-      /** Indicates this message is a command to clear chat history */
-      type: "cf_agent_chat_clear";
-    };
+type OutgoingMessage = {
+    /** Indicates this message contains updated chat messages */
+    type: "cf_agent_chat_messages";
+    /** Array of chat messages */
+    messages: Message[];
+} | {
+    /** Indicates this message is a response to a chat request */
+    type: "cf_agent_use_chat_response";
+    /** Unique ID of the request this response corresponds to */
+    id: string;
+    /** Content body of the response */
+    body: string;
+    /** Whether this is the final chunk of the response */
+    done: boolean;
+} | {
+    /** Indicates this message contains updated chat messages */
+    type: "cf_agent_chat_messages";
+    /** Array of chat messages */
+    messages: Message[];
+} | {
+    /** Indicates this message is a command to clear chat history */
+    type: "cf_agent_chat_clear";
+};
 /**
  * Types of messages sent from clients to the Agent
  */
-type IncomingMessage =
-  | {
-      /** Indicates this message is a request to the chat API */
-      type: "cf_agent_use_chat_request";
-      /** Unique ID for this request */
-      id: string;
-      /** Request initialization options */
-      init: Pick<
-        RequestInit,
-        | "method"
-        | "keepalive"
-        | "headers"
-        | "body"
-        | "redirect"
-        | "integrity"
-        | "credentials"
-        | "mode"
-        | "referrer"
-        | "referrerPolicy"
-        | "window"
-      >;
-    }
-  | {
-      /** Indicates this message is a command to clear chat history */
-      type: "cf_agent_chat_clear";
-    }
-  | {
-      /** Indicates this message contains updated chat messages */
-      type: "cf_agent_chat_messages";
-      /** Array of chat messages */
-      messages: Message[];
-    };
+type IncomingMessage = {
+    /** Indicates this message is a request to the chat API */
+    type: "cf_agent_use_chat_request";
+    /** Unique ID for this request */
+    id: string;
+    /** Request initialization options */
+    init: Pick<RequestInit, "method" | "keepalive" | "headers" | "body" | "redirect" | "integrity" | "credentials" | "mode" | "referrer" | "referrerPolicy" | "window">;
+} | {
+    /** Indicates this message is a command to clear chat history */
+    type: "cf_agent_chat_clear";
+} | {
+    /** Indicates this message contains updated chat messages */
+    type: "cf_agent_chat_messages";
+    /** Array of chat messages */
+    messages: Message[];
+};
 
 export type { IncomingMessage, OutgoingMessage };

package/dist/client.d.ts

@@ -1,68 +1,57 @@
-import {
-  PartySocketOptions,
-  PartyFetchOptions,
-  PartySocket,
-} from "partysocket";
+import { PartySocketOptions, PartyFetchOptions, PartySocket } from 'partysocket';
 
 /**
  * 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;
+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;
+    /** 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;
+    /** Name of the agent to connect to */
+    agent: string;
+    /** Name of the specific Agent instance */
+    name?: string;
 };
 /**
  * WebSocket client for connecting to an Agent
  */
 declare class AgentClient<State = unknown> extends PartySocket {
-  #private;
-  /**
-   * @deprecated Use agentFetch instead
-   */
-  static fetch(_opts: PartyFetchOptions): Promise<Response>;
-  agent: string;
-  name: string;
-  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 = unknown>(
-    method: string,
-    args?: unknown[],
-    streamOptions?: StreamOptions
-  ): Promise<T>;
+    #private;
+    /**
+     * @deprecated Use agentFetch instead
+     */
+    static fetch(_opts: PartyFetchOptions): Promise<Response>;
+    agent: string;
+    name: string;
+    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 = unknown>(method: string, args?: unknown[], streamOptions?: StreamOptions): Promise<T>;
 }
 /**
  * Make an HTTP request to an Agent
@@ -70,15 +59,6 @@ declare class AgentClient<State = unknown> extends PartySocket {
  * @param init Request initialization options
  * @returns Promise resolving to a Response
  */
-declare function agentFetch(
-  opts: AgentClientFetchOptions,
-  init?: RequestInit
-): Promise<Response>;
+declare function agentFetch(opts: AgentClientFetchOptions, init?: RequestInit): Promise<Response>;
 
-export {
-  AgentClient,
-  type AgentClientFetchOptions,
-  type AgentClientOptions,
-  type StreamOptions,
-  agentFetch,
-};
+export { AgentClient, type AgentClientFetchOptions, type AgentClientOptions, type StreamOptions, agentFetch };