Merge remote-tracking branch 'origin/main' into enhance-instrumentation

Author: flenter

package-lock.json

@@ -1,5 +1,19 @@
 # @cloudflare/agents
 
+## 0.0.82
+
+### Patch Changes
+
+- [`04d925e`](https://github.com/cloudflare/agents/commit/04d925ee6795b907de19bcd40940062fb9e99b1b) Thanks [@threepointone](https://github.com/threepointone)! - convert two missed #methods to a private \_methods
+
+## 0.0.81
+
+### Patch Changes
+
+- [#265](https://github.com/cloudflare/agents/pull/265) [`ac0e999`](https://github.com/cloudflare/agents/commit/ac0e999652919600f087f0314ce61c98d3eaf069) Thanks [@threepointone](https://github.com/threepointone)! - refactor #method/#property to private method/private property
+
+- [#267](https://github.com/cloudflare/agents/pull/267) [`385f0b2`](https://github.com/cloudflare/agents/commit/385f0b29c716f8fa1c9719b0c68e5c830767953e) Thanks [@threepointone](https://github.com/threepointone)! - prefix private methods/properties with \_
+
 ## 0.0.80
 
 ### Patch Changes

packages/agents/CHANGELOG.md

@@ -1,6 +1,6 @@
 {
   "name": "agents",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "main": "src/index.ts",
   "types": "dist/index.d.ts",
   "type": "module",

packages/agents/package.json

@@ -21,7 +21,7 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
    * Map of message `id`s to `AbortController`s
    * useful to propagate request cancellation signals for any external calls made by the agent
    */
-  #chatMessageAbortControllers: Map<string, AbortController>;
+  private _chatMessageAbortControllers: Map<string, AbortController>;
   /** Array of chat messages for the current conversation */
   messages: ChatMessage[];
   constructor(ctx: AgentContext, env: Env) {
@@ -37,10 +37,10 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
       return JSON.parse(row.message as string);
     });
 
-    this.#chatMessageAbortControllers = new Map();
+    this._chatMessageAbortControllers = new Map();
   }
 
-  #broadcastChatMessage(message: OutgoingMessage, exclude?: string[]) {
+  private _broadcastChatMessage(message: OutgoingMessage, exclude?: string[]) {
     this.broadcast(JSON.stringify(message), exclude);
   }
 
@@ -74,7 +74,7 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
           // duplex
         } = data.init;
         const { messages } = JSON.parse(body as string);
-        this.#broadcastChatMessage(
+        this._broadcastChatMessage(
           {
             type: "cf_agent_chat_messages",
             messages,
@@ -84,9 +84,9 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
         await this.persistMessages(messages, [connection.id]);
 
         const chatMessageId = data.id;
-        const abortSignal = this.#getAbortSignal(chatMessageId);
+        const abortSignal = this._getAbortSignal(chatMessageId);
 
-        return this.#tryCatch(async () => {
+        return this._tryCatchChat(async () => {
           const response = await this.onChatMessage(
             async ({ response }) => {
               const finalMessages = appendResponseMessages({
@@ -95,21 +95,21 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
               });
 
               await this.persistMessages(finalMessages, [connection.id]);
-              this.#removeAbortController(chatMessageId);
+              this._removeAbortController(chatMessageId);
             },
             abortSignal ? { abortSignal } : undefined
           );
 
           if (response) {
-            await this.#reply(data.id, response);
+            await this._reply(data.id, response);
           }
         });
       }
       if (data.type === "cf_agent_chat_clear") {
-        this.#destroyAbortControllers();
+        this._destroyAbortControllers();
         this.sql`delete from cf_ai_chat_agent_messages`;
         this.messages = [];
-        this.#broadcastChatMessage(
+        this._broadcastChatMessage(
           {
             type: "cf_agent_chat_clear",
           },
@@ -120,13 +120,13 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
         await this.persistMessages(data.messages, [connection.id]);
       } else if (data.type === "cf_agent_chat_request_cancel") {
         // propagate an abort signal for the associated request
-        this.#cancelChatRequest(data.id);
+        this._cancelChatRequest(data.id);
       }
     }
   }
 
   override async onRequest(request: Request): Promise<Response> {
-    return this.#tryCatch(() => {
+    return this._tryCatchChat(() => {
       const url = new URL(request.url);
       if (url.pathname.endsWith("/get-messages")) {
         const messages = (
@@ -140,7 +140,7 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
     });
   }
 
-  async #tryCatch<T>(fn: () => T | Promise<T>) {
+  private async _tryCatchChat<T>(fn: () => T | Promise<T>) {
     try {
       return await fn();
     } catch (e) {
@@ -198,7 +198,7 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
       },${JSON.stringify(message)})`;
     }
     this.messages = messages;
-    this.#broadcastChatMessage(
+    this._broadcastChatMessage(
       {
         type: "cf_agent_chat_messages",
         messages: messages,
@@ -207,22 +207,22 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
     );
   }
 
-  async #reply(id: string, response: Response) {
+  private async _reply(id: string, response: Response) {
     // now take chunks out from dataStreamResponse and send them to the client
-    return this.#tryCatch(async () => {
+    return this._tryCatchChat(async () => {
       // @ts-expect-error TODO: fix this type error
       for await (const chunk of response.body!) {
         const body = decoder.decode(chunk);
 
-        this.#broadcastChatMessage({
+        this._broadcastChatMessage({
           id,
           type: "cf_agent_use_chat_response",
           body,
           done: false,
         });
       }
 
-      this.#broadcastChatMessage({
+      this._broadcastChatMessage({
         id,
         type: "cf_agent_use_chat_response",
         body: "",
@@ -237,51 +237,51 @@ export class AIChatAgent<Env = unknown, State = unknown> extends Agent<
    *
    * returns the AbortSignal associated with the AbortController
    */
-  #getAbortSignal(id: string): AbortSignal | undefined {
+  private _getAbortSignal(id: string): AbortSignal | undefined {
     // Defensive check, since we're coercing message types at the moment
     if (typeof id !== "string") {
       return undefined;
     }
 
-    if (!this.#chatMessageAbortControllers.has(id)) {
-      this.#chatMessageAbortControllers.set(id, new AbortController());
+    if (!this._chatMessageAbortControllers.has(id)) {
+      this._chatMessageAbortControllers.set(id, new AbortController());
     }
 
-    return this.#chatMessageAbortControllers.get(id)?.signal;
+    return this._chatMessageAbortControllers.get(id)?.signal;
   }
 
   /**
    * Remove an abort controller from the cache of pending message responses
    */
-  #removeAbortController(id: string) {
-    this.#chatMessageAbortControllers.delete(id);
+  private _removeAbortController(id: string) {
+    this._chatMessageAbortControllers.delete(id);
   }
 
   /**
    * Propagate an abort signal for any requests associated with the given message id
    */
-  #cancelChatRequest(id: string) {
-    if (this.#chatMessageAbortControllers.has(id)) {
-      const abortController = this.#chatMessageAbortControllers.get(id);
+  private _cancelChatRequest(id: string) {
+    if (this._chatMessageAbortControllers.has(id)) {
+      const abortController = this._chatMessageAbortControllers.get(id);
       abortController?.abort();
     }
   }
 
   /**
    * Abort all pending requests and clear the cache of AbortControllers
    */
-  #destroyAbortControllers() {
-    for (const controller of this.#chatMessageAbortControllers.values()) {
+  private _destroyAbortControllers() {
+    for (const controller of this._chatMessageAbortControllers.values()) {
       controller?.abort();
     }
-    this.#chatMessageAbortControllers.clear();
+    this._chatMessageAbortControllers.clear();
   }
 
   /**
    * When the DO is destroyed, cancel all pending requests
    */
   async destroy() {
-    this.#destroyAbortControllers();
+    this._destroyAbortControllers();
     await super.destroy();
   }
 }

packages/agents/src/ai-chat-agent.ts

@@ -80,8 +80,8 @@ export class AgentClient<State = unknown> extends PartySocket {
   }
   agent: string;
   name: string;
-  #options: AgentClientOptions<State>;
-  #pendingCalls = new Map<
+  private options: AgentClientOptions<State>;
+  private _pendingCalls = new Map<
     string,
     {
       resolve: (value: unknown) => void;
@@ -101,7 +101,7 @@ export class AgentClient<State = unknown> extends PartySocket {
     });
     this.agent = agentNamespace;
     this.name = options.name || "default";
-    this.#options = options;
+    this.options = options;
 
     this.addEventListener("message", (event) => {
       if (typeof event.data === "string") {
@@ -114,17 +114,17 @@ export class AgentClient<State = unknown> extends PartySocket {
           return;
         }
         if (parsedMessage.type === "cf_agent_state") {
-          this.#options.onStateUpdate?.(parsedMessage.state as State, "server");
+          this.options.onStateUpdate?.(parsedMessage.state as State, "server");
           return;
         }
         if (parsedMessage.type === "rpc") {
           const response = parsedMessage as RPCResponse;
-          const pending = this.#pendingCalls.get(response.id);
+          const pending = this._pendingCalls.get(response.id);
           if (!pending) return;
 
           if (!response.success) {
             pending.reject(new Error(response.error));
-            this.#pendingCalls.delete(response.id);
+            this._pendingCalls.delete(response.id);
             pending.stream?.onError?.(response.error);
             return;
           }
@@ -133,15 +133,15 @@ export class AgentClient<State = unknown> extends PartySocket {
           if ("done" in response) {
             if (response.done) {
               pending.resolve(response.result);
-              this.#pendingCalls.delete(response.id);
+              this._pendingCalls.delete(response.id);
               pending.stream?.onDone?.(response.result);
             } else {
               pending.stream?.onChunk?.(response.result);
             }
           } else {
             // Non-streaming response
             pending.resolve(response.result);
-            this.#pendingCalls.delete(response.id);
+            this._pendingCalls.delete(response.id);
           }
         }
       }
@@ -150,7 +150,7 @@ export class AgentClient<State = unknown> extends PartySocket {
 
   setState(state: State) {
     this.send(JSON.stringify({ type: "cf_agent_state", state }));
-    this.#options.onStateUpdate?.(state, "client");
+    this.options.onStateUpdate?.(state, "client");
   }
 
   /**
@@ -167,7 +167,7 @@ export class AgentClient<State = unknown> extends PartySocket {
   ): Promise<T> {
     return new Promise<T>((resolve, reject) => {
       const id = Math.random().toString(36).slice(2);
-      this.#pendingCalls.set(id, {
+      this._pendingCalls.set(id, {
         resolve: (value: unknown) => resolve(value as T),
         reject,
         stream: streamOptions,