agents 0.0.0-d2e8c0e → 0.0.0-d40512c

package/dist/{chunk-J6T74FUS.js → chunk-LU2RSO54.js}

@@ -1,22 +1,22 @@
+import {
+  MCPClientManager
+} from "./chunk-4RBEYCWK.js";
 import {
   DurableObjectOAuthClientProvider
-} from "./chunk-BZXOAZUX.js";
+} from "./chunk-PVQZBKN7.js";
 import {
   camelCaseToKebabCase
-} from "./chunk-QSGN3REV.js";
-import {
-  MCPClientManager
-} from "./chunk-Y67CHZBI.js";
+} from "./chunk-KUH345EY.js";
 
 // src/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { parseCronExpression } from "cron-schedule";
+import { nanoid } from "nanoid";
 import {
-  Server,
+  getServerByName,
   routePartykitRequest,
-  getServerByName
+  Server
 } from "partyserver";
-import { parseCronExpression } from "cron-schedule";
-import { nanoid } from "nanoid";
-import { AsyncLocalStorage } from "node:async_hooks";
 function isRPCRequest(msg) {
   return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "rpc" && "id" in msg && typeof msg.id === "string" && "method" in msg && typeof msg.method === "string" && "args" in msg && Array.isArray(msg.args);
 }
@@ -62,6 +62,10 @@ var Agent = class extends Server {
      * Override to provide default state values
      */
     this.initialState = DEFAULT_STATE;
+    /**
+     * The observability implementation to use for the Agent
+     */
+    this.observability = genericObservability;
     /**
      * Method called when an alarm fires.
      * Executes any scheduled tasks that are due.
@@ -85,6 +89,16 @@ var Agent = class extends Server {
           { agent: this, connection: void 0, request: void 0 },
           async () => {
             try {
+              this.observability?.emit(
+                {
+                  displayMessage: `Schedule ${row.id} executed`,
+                  id: nanoid(),
+                  payload: row,
+                  timestamp: Date.now(),
+                  type: "schedule:execute"
+                },
+                this.ctx
+              );
               await callback.bind(this)(JSON.parse(row.payload), row);
             } catch (e) {
               console.error(`error executing callback "${row.callback}"`, e);
@@ -148,13 +162,13 @@ var Agent = class extends Server {
             await this.mcp.handleCallbackRequest(request);
             this.broadcast(
               JSON.stringify({
-                type: "cf_agent_mcp_servers",
-                mcp: this.getMcpServers()
+                mcp: this.getMcpServers(),
+                type: "cf_agent_mcp_servers"
               })
             );
             return new Response("<script>window.close();</script>", {
-              status: 200,
-              headers: { "content-type": "text/html" }
+              headers: { "content-type": "text/html" },
+              status: 200
             });
           }
           return this._tryCatch(() => _onRequest(request));
@@ -172,7 +186,7 @@ var Agent = class extends Server {
           let parsed;
           try {
             parsed = JSON.parse(message);
-          } catch (e) {
+          } catch (_e) {
             return this._tryCatch(() => _onMessage(connection, message));
           }
           if (isStateUpdateMessage(parsed)) {
@@ -196,20 +210,35 @@ var Agent = class extends Server {
                 return;
               }
               const result = await methodFn.apply(this, args);
+              this.observability?.emit(
+                {
+                  displayMessage: `RPC call to ${method}`,
+                  id: nanoid(),
+                  payload: {
+                    args,
+                    method,
+                    streaming: metadata?.streaming,
+                    success: true
+                  },
+                  timestamp: Date.now(),
+                  type: "rpc"
+                },
+                this.ctx
+              );
               const response = {
-                type: "rpc",
+                done: true,
                 id,
-                success: true,
                 result,
-                done: true
+                success: true,
+                type: "rpc"
               };
               connection.send(JSON.stringify(response));
             } catch (e) {
               const response = {
-                type: "rpc",
+                error: e instanceof Error ? e.message : "Unknown error occurred",
                 id: parsed.id,
                 success: false,
-                error: e instanceof Error ? e.message : "Unknown error occurred"
+                type: "rpc"
               };
               connection.send(JSON.stringify(response));
               console.error("RPC error:", e);
@@ -229,17 +258,29 @@ var Agent = class extends Server {
             if (this.state) {
               connection.send(
                 JSON.stringify({
-                  type: "cf_agent_state",
-                  state: this.state
+                  state: this.state,
+                  type: "cf_agent_state"
                 })
               );
             }
             connection.send(
               JSON.stringify({
-                type: "cf_agent_mcp_servers",
-                mcp: this.getMcpServers()
+                mcp: this.getMcpServers(),
+                type: "cf_agent_mcp_servers"
               })
             );
+            this.observability?.emit(
+              {
+                displayMessage: "Connection established",
+                id: nanoid(),
+                payload: {
+                  connectionId: connection.id
+                },
+                timestamp: Date.now(),
+                type: "connect"
+              },
+              this.ctx
+            );
             return this._tryCatch(() => _onConnect(connection, ctx2));
           }, 20);
         }
@@ -253,7 +294,7 @@ var Agent = class extends Server {
           const servers = this.sql`
             SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers;
           `;
-          await Promise.allSettled(
+          Promise.allSettled(
             servers.map((server) => {
               return this._connectToMcpServerInternal(
                 server.name,
@@ -266,13 +307,14 @@ var Agent = class extends Server {
                 }
               );
             })
-          );
-          this.broadcast(
-            JSON.stringify({
-              type: "cf_agent_mcp_servers",
-              mcp: this.getMcpServers()
-            })
-          );
+          ).then((_results) => {
+            this.broadcast(
+              JSON.stringify({
+                mcp: this.getMcpServers(),
+                type: "cf_agent_mcp_servers"
+              })
+            );
+          });
           await this._tryCatch(() => _onStart());
         }
       );
@@ -324,6 +366,7 @@ var Agent = class extends Server {
     }
   }
   _setStateInternal(state, source = "server") {
+    const previousState = this._state;
     this._state = state;
     this.sql`
     INSERT OR REPLACE INTO cf_agents_state (id, state)
@@ -335,8 +378,8 @@ var Agent = class extends Server {
   `;
     this.broadcast(
       JSON.stringify({
-        type: "cf_agent_state",
-        state
+        state,
+        type: "cf_agent_state"
       }),
       source !== "server" ? [source.id] : []
     );
@@ -345,6 +388,19 @@ var Agent = class extends Server {
       return agentContext.run(
         { agent: this, connection, request },
         async () => {
+          this.observability?.emit(
+            {
+              displayMessage: "State updated",
+              id: nanoid(),
+              payload: {
+                previousState,
+                state
+              },
+              timestamp: Date.now(),
+              type: "state:update"
+            },
+            this.ctx
+          );
           return this.onStateUpdate(state, source);
         }
       );
@@ -362,12 +418,14 @@ var Agent = class extends Server {
    * @param state Updated state
    * @param source Source of the state update ("server" or a client connection)
    */
+  // biome-ignore lint/correctness/noUnusedFunctionParameters: overridden later
   onStateUpdate(state, source) {
   }
   /**
    * Called when the Agent receives an email
    * @param email Email message to process
    */
+  // biome-ignore lint/correctness/noUnusedFunctionParameters: overridden later
   onEmail(email) {
     return agentContext.run(
       { agent: this, connection: void 0, request: void 0 },
@@ -418,6 +476,16 @@ var Agent = class extends Server {
    */
   async schedule(when, callback, payload) {
     const id = nanoid(9);
+    const emitScheduleCreate = (schedule) => this.observability?.emit(
+      {
+        displayMessage: `Schedule ${schedule.id} created`,
+        id: nanoid(),
+        payload: schedule,
+        timestamp: Date.now(),
+        type: "schedule:create"
+      },
+      this.ctx
+    );
     if (typeof callback !== "string") {
       throw new Error("Callback must be a string");
     }
@@ -433,13 +501,15 @@ var Agent = class extends Server {
       )}, 'scheduled', ${timestamp})
       `;
       await this._scheduleNextAlarm();
-      return {
-        id,
+      const schedule = {
         callback,
+        id,
         payload,
         time: timestamp,
         type: "scheduled"
       };
+      emitScheduleCreate(schedule);
+      return schedule;
     }
     if (typeof when === "number") {
       const time = new Date(Date.now() + when * 1e3);
@@ -451,14 +521,16 @@ var Agent = class extends Server {
       )}, 'delayed', ${when}, ${timestamp})
       `;
       await this._scheduleNextAlarm();
-      return {
-        id,
+      const schedule = {
         callback,
-        payload,
         delayInSeconds: when,
+        id,
+        payload,
         time: timestamp,
         type: "delayed"
       };
+      emitScheduleCreate(schedule);
+      return schedule;
     }
     if (typeof when === "string") {
       const nextExecutionTime = getNextCronTime(when);
@@ -470,14 +542,16 @@ var Agent = class extends Server {
       )}, 'cron', ${when}, ${timestamp})
       `;
       await this._scheduleNextAlarm();
-      return {
-        id,
+      const schedule = {
         callback,
-        payload,
         cron: when,
+        id,
+        payload,
         time: timestamp,
         type: "cron"
       };
+      emitScheduleCreate(schedule);
+      return schedule;
     }
     throw new Error("Invalid schedule type");
   }
@@ -535,6 +609,19 @@ var Agent = class extends Server {
    * @returns true if the task was cancelled, false otherwise
    */
   async cancelSchedule(id) {
+    const schedule = await this.getSchedule(id);
+    if (schedule) {
+      this.observability?.emit(
+        {
+          displayMessage: `Schedule ${id} cancelled`,
+          id: nanoid(),
+          payload: schedule,
+          timestamp: Date.now(),
+          type: "schedule:cancel"
+        },
+        this.ctx
+      );
+    }
     this.sql`DELETE FROM cf_agents_schedules WHERE id = ${id}`;
     await this._scheduleNextAlarm();
     return true;
@@ -561,6 +648,17 @@ var Agent = class extends Server {
     this.sql`DROP TABLE IF EXISTS cf_agents_mcp_servers`;
     await this.ctx.storage.deleteAlarm();
     await this.ctx.storage.deleteAll();
+    this.ctx.abort("destroyed");
+    this.observability?.emit(
+      {
+        displayMessage: "Agent destroyed",
+        id: nanoid(),
+        payload: {},
+        timestamp: Date.now(),
+        type: "destroy"
+      },
+      this.ctx
+    );
   }
   /**
    * Get all methods marked as callable on this Agent
@@ -586,15 +684,28 @@ var Agent = class extends Server {
       callbackUrl,
       options
     );
+    this.sql`
+        INSERT
+        OR REPLACE INTO cf_agents_mcp_servers (id, name, server_url, client_id, auth_url, callback_url, server_options)
+      VALUES (
+        ${result.id},
+        ${serverName},
+        ${url},
+        ${result.clientId ?? null},
+        ${result.authUrl ?? null},
+        ${callbackUrl},
+        ${options ? JSON.stringify(options) : null}
+        );
+    `;
     this.broadcast(
       JSON.stringify({
-        type: "cf_agent_mcp_servers",
-        mcp: this.getMcpServers()
+        mcp: this.getMcpServers(),
+        type: "cf_agent_mcp_servers"
       })
     );
     return result;
   }
-  async _connectToMcpServerInternal(serverName, url, callbackUrl, options, reconnect) {
+  async _connectToMcpServerInternal(_serverName, url, callbackUrl, options, reconnect) {
     const authProvider = new DurableObjectOAuthClientProvider(
       this.ctx.storage,
       this.name,
@@ -621,28 +732,17 @@ var Agent = class extends Server {
       };
     }
     const { id, authUrl, clientId } = await this.mcp.connect(url, {
+      client: options?.client,
       reconnect,
       transport: {
         ...headerTransportOpts,
         authProvider
-      },
-      client: options?.client
+      }
     });
-    this.sql`
-      INSERT OR REPLACE INTO cf_agents_mcp_servers (id, name, server_url, client_id, auth_url, callback_url, server_options)
-      VALUES (
-        ${id},
-        ${serverName},
-        ${url},
-        ${clientId ?? null},
-        ${authUrl ?? null},
-        ${callbackUrl},
-        ${options ? JSON.stringify(options) : null}
-      );
-    `;
     return {
-      id,
-      authUrl
+      authUrl,
+      clientId,
+      id
     };
   }
   async removeMcpServer(id) {
@@ -652,29 +752,31 @@ var Agent = class extends Server {
     `;
     this.broadcast(
       JSON.stringify({
-        type: "cf_agent_mcp_servers",
-        mcp: this.getMcpServers()
+        mcp: this.getMcpServers(),
+        type: "cf_agent_mcp_servers"
       })
     );
   }
   getMcpServers() {
     const mcpState = {
-      servers: {},
-      tools: this.mcp.listTools(),
       prompts: this.mcp.listPrompts(),
-      resources: this.mcp.listResources()
+      resources: this.mcp.listResources(),
+      servers: {},
+      tools: this.mcp.listTools()
     };
     const servers = this.sql`
       SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers;
     `;
     for (const server of servers) {
+      const serverConn = this.mcp.mcpConnections[server.id];
       mcpState.servers[server.id] = {
+        auth_url: server.auth_url,
+        capabilities: serverConn?.serverCapabilities ?? null,
+        instructions: serverConn?.instructions ?? null,
         name: server.name,
         server_url: server.server_url,
-        auth_url: server.auth_url,
-        state: this.mcp.mcpConnections[server.id].connectionState,
-        instructions: this.mcp.mcpConnections[server.id].instructions ?? null,
-        capabilities: this.mcp.mcpConnections[server.id].serverCapabilities ?? null
+        // mark as "authenticating" because the server isn't automatically connected, so it's pending authenticating
+        state: serverConn?.connectionState ?? "authenticating"
       };
     }
     return mcpState;
@@ -690,9 +792,9 @@ Agent.options = {
 };
 async function routeAgentRequest(request, env, options) {
   const corsHeaders = options?.cors === true ? {
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "GET, POST, HEAD, OPTIONS",
     "Access-Control-Allow-Credentials": "true",
+    "Access-Control-Allow-Methods": "GET, POST, HEAD, OPTIONS",
+    "Access-Control-Allow-Origin": "*",
     "Access-Control-Max-Age": "86400"
   } : options?.cors;
   if (request.method === "OPTIONS") {
@@ -723,7 +825,7 @@ async function routeAgentRequest(request, env, options) {
   }
   return response;
 }
-async function routeAgentEmail(email, env, options) {
+async function routeAgentEmail(_email, _env, _options) {
 }
 async function getAgentByName(namespace, name, options) {
   return getServerByName(namespace, name, options);
@@ -743,11 +845,11 @@ var StreamingResponse = class {
       throw new Error("StreamingResponse is already closed");
     }
     const response = {
-      type: "rpc",
+      done: false,
       id: this._id,
-      success: true,
       result: chunk,
-      done: false
+      success: true,
+      type: "rpc"
     };
     this._connection.send(JSON.stringify(response));
   }
@@ -761,17 +863,42 @@ var StreamingResponse = class {
     }
     this._closed = true;
     const response = {
-      type: "rpc",
+      done: true,
       id: this._id,
-      success: true,
       result: finalChunk,
-      done: true
+      success: true,
+      type: "rpc"
     };
     this._connection.send(JSON.stringify(response));
   }
 };
 
+// src/observability/index.ts
+var genericObservability = {
+  emit(event) {
+    if (isLocalMode()) {
+      console.log(event.displayMessage);
+      return;
+    }
+    console.log(event);
+  }
+};
+var localMode = false;
+function isLocalMode() {
+  if (localMode) {
+    return true;
+  }
+  const { request } = getCurrentAgent();
+  if (!request) {
+    return false;
+  }
+  const url = new URL(request.url);
+  localMode = url.hostname === "localhost";
+  return localMode;
+}
+
 export {
+  genericObservability,
   unstable_callable,
   getCurrentAgent,
   Agent,
@@ -780,4 +907,4 @@ export {
   getAgentByName,
   StreamingResponse
 };
-//# sourceMappingURL=chunk-J6T74FUS.js.map
+//# sourceMappingURL=chunk-LU2RSO54.js.map