agents 0.0.0-ac0e999 → 0.0.0-ac74811

package/dist/{chunk-DMJ7L3FI.js → chunk-JFRK72K3.js}

@@ -1,26 +1,22 @@
+import {
+  MCPClientManager
+} from "./chunk-E3LCYPCB.js";
 import {
   DurableObjectOAuthClientProvider
-} from "./chunk-D6UOOELW.js";
+} from "./chunk-767EASBA.js";
 import {
   camelCaseToKebabCase
-} from "./chunk-ZKIVUOTQ.js";
-import {
-  MCPClientManager
-} from "./chunk-25YDMV4H.js";
-import {
-  __privateAdd,
-  __privateMethod
-} from "./chunk-NOUFNU2O.js";
+} from "./chunk-NKZZ66QY.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);
 }
@@ -55,19 +51,21 @@ function getCurrentAgent() {
   }
   return store;
 }
-var _Agent_instances, connectToMcpServerInternal_fn, getMcpServerStateInternal_fn;
 var Agent = class extends Server {
   constructor(ctx, env) {
     super(ctx, env);
-    __privateAdd(this, _Agent_instances);
     this._state = DEFAULT_STATE;
-    this.ParentClass = Object.getPrototypeOf(this).constructor;
-    this.mcp = new MCPClientManager(this.ParentClass.name, "0.0.1");
+    this._ParentClass = Object.getPrototypeOf(this).constructor;
+    this.mcp = new MCPClientManager(this._ParentClass.name, "0.0.1");
     /**
      * Initial state for the Agent
      * 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.
@@ -91,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);
@@ -109,7 +117,7 @@ var Agent = class extends Server {
         `;
         }
       }
-      await this.scheduleNextAlarm();
+      await this._scheduleNextAlarm();
     };
     this.sql`
       CREATE TABLE IF NOT EXISTS cf_agents_state (
@@ -118,7 +126,7 @@ var Agent = class extends Server {
       )
     `;
     void this.ctx.blockConcurrencyWhile(async () => {
-      return this.tryCatch(async () => {
+      return this._tryCatch(async () => {
         this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_schedules (
           id TEXT PRIMARY KEY NOT NULL DEFAULT (randomblob(9)),
@@ -154,16 +162,16 @@ var Agent = class extends Server {
             await this.mcp.handleCallbackRequest(request);
             this.broadcast(
               JSON.stringify({
-                type: "cf_agent_mcp_servers",
-                mcp: __privateMethod(this, _Agent_instances, getMcpServerStateInternal_fn).call(this)
+                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));
+          return this._tryCatch(() => _onRequest(request));
         }
       );
     };
@@ -173,16 +181,16 @@ var Agent = class extends Server {
         { agent: this, connection, request: void 0 },
         async () => {
           if (typeof message !== "string") {
-            return this.tryCatch(() => _onMessage(connection, message));
+            return this._tryCatch(() => _onMessage(connection, message));
           }
           let parsed;
           try {
             parsed = JSON.parse(message);
-          } catch (e) {
-            return this.tryCatch(() => _onMessage(connection, message));
+          } catch (_e) {
+            return this._tryCatch(() => _onMessage(connection, message));
           }
           if (isStateUpdateMessage(parsed)) {
-            this.setStateInternal(parsed.state, connection);
+            this._setStateInternal(parsed.state, connection);
             return;
           }
           if (isRPCRequest(parsed)) {
@@ -192,7 +200,7 @@ var Agent = class extends Server {
               if (typeof methodFn !== "function") {
                 throw new Error(`Method ${method} does not exist`);
               }
-              if (!this.isCallable(method)) {
+              if (!this._isCallable(method)) {
                 throw new Error(`Method ${method} is not callable`);
               }
               const metadata = callableMetadata.get(methodFn);
@@ -202,27 +210,42 @@ 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);
             }
             return;
           }
-          return this.tryCatch(() => _onMessage(connection, message));
+          return this._tryCatch(() => _onMessage(connection, message));
         }
       );
     };
@@ -235,18 +258,30 @@ 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: __privateMethod(this, _Agent_instances, getMcpServerStateInternal_fn).call(this)
+                mcp: this.getMcpServers(),
+                type: "cf_agent_mcp_servers"
               })
             );
-            return this.tryCatch(() => _onConnect(connection, ctx2));
+            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);
         }
       );
@@ -259,21 +294,28 @@ 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 __privateMethod(this, _Agent_instances, connectToMcpServerInternal_fn).call(this, server.name, server.server_url, server.callback_url, server.server_options ? JSON.parse(server.server_options) : void 0, {
-                id: server.id,
-                oauthClientId: server.client_id ?? void 0
-              });
-            })
-          );
-          this.broadcast(
-            JSON.stringify({
-              type: "cf_agent_mcp_servers",
-              mcp: __privateMethod(this, _Agent_instances, getMcpServerStateInternal_fn).call(this)
+              return this._connectToMcpServerInternal(
+                server.name,
+                server.server_url,
+                server.callback_url,
+                server.server_options ? JSON.parse(server.server_options) : void 0,
+                {
+                  id: server.id,
+                  oauthClientId: server.client_id ?? void 0
+                }
+              );
             })
-          );
-          await this.tryCatch(() => _onStart());
+          ).then((_results) => {
+            this.broadcast(
+              JSON.stringify({
+                mcp: this.getMcpServers(),
+                type: "cf_agent_mcp_servers"
+              })
+            );
+          });
+          await this._tryCatch(() => _onStart());
         }
       );
     };
@@ -323,7 +365,8 @@ var Agent = class extends Server {
       throw this.onError(e);
     }
   }
-  setStateInternal(state, source = "server") {
+  _setStateInternal(state, source = "server") {
+    const previousState = this._state;
     this._state = state;
     this.sql`
     INSERT OR REPLACE INTO cf_agents_state (id, state)
@@ -335,16 +378,29 @@ var Agent = class extends Server {
   `;
     this.broadcast(
       JSON.stringify({
-        type: "cf_agent_state",
-        state
+        state,
+        type: "cf_agent_state"
       }),
       source !== "server" ? [source.id] : []
     );
-    return this.tryCatch(() => {
+    return this._tryCatch(() => {
       const { connection, request } = agentContext.getStore() || {};
       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);
         }
       );
@@ -355,19 +411,21 @@ var Agent = class extends Server {
    * @param state New state to set
    */
   setState(state) {
-    this.setStateInternal(state, "server");
+    this._setStateInternal(state, "server");
   }
   /**
    * Called when the Agent's state is updated
    * @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 },
@@ -376,7 +434,7 @@ var Agent = class extends Server {
       }
     );
   }
-  async tryCatch(fn) {
+  async _tryCatch(fn) {
     try {
       return await fn();
     } catch (e) {
@@ -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");
     }
@@ -432,14 +500,16 @@ var Agent = class extends Server {
         payload
       )}, 'scheduled', ${timestamp})
       `;
-      await this.scheduleNextAlarm();
-      return {
-        id,
+      await this._scheduleNextAlarm();
+      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);
@@ -450,15 +520,17 @@ var Agent = class extends Server {
         payload
       )}, 'delayed', ${when}, ${timestamp})
       `;
-      await this.scheduleNextAlarm();
-      return {
-        id,
+      await this._scheduleNextAlarm();
+      const schedule = {
         callback,
-        payload,
         delayInSeconds: when,
+        id,
+        payload,
         time: timestamp,
         type: "delayed"
       };
+      emitScheduleCreate(schedule);
+      return schedule;
     }
     if (typeof when === "string") {
       const nextExecutionTime = getNextCronTime(when);
@@ -469,15 +541,17 @@ var Agent = class extends Server {
         payload
       )}, 'cron', ${when}, ${timestamp})
       `;
-      await this.scheduleNextAlarm();
-      return {
-        id,
+      await this._scheduleNextAlarm();
+      const schedule = {
         callback,
-        payload,
         cron: when,
+        id,
+        payload,
         time: timestamp,
         type: "cron"
       };
+      emitScheduleCreate(schedule);
+      return schedule;
     }
     throw new Error("Invalid schedule type");
   }
@@ -535,11 +609,24 @@ 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();
+    await this._scheduleNextAlarm();
     return true;
   }
-  async scheduleNextAlarm() {
+  async _scheduleNextAlarm() {
     const result = this.sql`
       SELECT time FROM cf_agents_schedules 
       WHERE time > ${Math.floor(Date.now() / 1e3)}
@@ -561,8 +648,23 @@ 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
+    );
   }
-  isCallable(method) {
+  /**
+   * Get all methods marked as callable on this Agent
+   * @returns A map of method names to their metadata
+   */
+  _isCallable(method) {
     return callableMetadata.has(this[method]);
   }
   /**
@@ -575,16 +677,74 @@ var Agent = class extends Server {
    * @returns authUrl
    */
   async addMcpServer(serverName, url, callbackHost, agentsPrefix = "agents", options) {
-    const callbackUrl = `${callbackHost}/${agentsPrefix}/${camelCaseToKebabCase(this.ParentClass.name)}/${this.name}/callback`;
-    const result = await __privateMethod(this, _Agent_instances, connectToMcpServerInternal_fn).call(this, serverName, url, callbackUrl, options);
+    const callbackUrl = `${callbackHost}/${agentsPrefix}/${camelCaseToKebabCase(this._ParentClass.name)}/${this.name}/callback`;
+    const result = await this._connectToMcpServerInternal(
+      serverName,
+      url,
+      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: __privateMethod(this, _Agent_instances, getMcpServerStateInternal_fn).call(this)
+        mcp: this.getMcpServers(),
+        type: "cf_agent_mcp_servers"
       })
     );
     return result;
   }
+  async _connectToMcpServerInternal(_serverName, url, callbackUrl, options, reconnect) {
+    const authProvider = new DurableObjectOAuthClientProvider(
+      this.ctx.storage,
+      this.name,
+      callbackUrl
+    );
+    if (reconnect) {
+      authProvider.serverId = reconnect.id;
+      if (reconnect.oauthClientId) {
+        authProvider.clientId = reconnect.oauthClientId;
+      }
+    }
+    let headerTransportOpts = {};
+    if (options?.transport?.headers) {
+      headerTransportOpts = {
+        eventSourceInit: {
+          fetch: (url2, init) => fetch(url2, {
+            ...init,
+            headers: options?.transport?.headers
+          })
+        },
+        requestInit: {
+          headers: options?.transport?.headers
+        }
+      };
+    }
+    const { id, authUrl, clientId } = await this.mcp.connect(url, {
+      client: options?.client,
+      reconnect,
+      transport: {
+        ...headerTransportOpts,
+        authProvider
+      }
+    });
+    return {
+      authUrl,
+      clientId,
+      id
+    };
+  }
   async removeMcpServer(id) {
     this.mcp.closeConnection(id);
     this.sql`
@@ -592,83 +752,35 @@ var Agent = class extends Server {
     `;
     this.broadcast(
       JSON.stringify({
-        type: "cf_agent_mcp_servers",
-        mcp: __privateMethod(this, _Agent_instances, getMcpServerStateInternal_fn).call(this)
+        mcp: this.getMcpServers(),
+        type: "cf_agent_mcp_servers"
       })
     );
   }
-};
-_Agent_instances = new WeakSet();
-connectToMcpServerInternal_fn = async function(serverName, url, callbackUrl, options, reconnect) {
-  const authProvider = new DurableObjectOAuthClientProvider(
-    this.ctx.storage,
-    this.name,
-    callbackUrl
-  );
-  if (reconnect) {
-    authProvider.serverId = reconnect.id;
-    if (reconnect.oauthClientId) {
-      authProvider.clientId = reconnect.oauthClientId;
-    }
-  }
-  let headerTransportOpts = {};
-  if (options?.transport?.headers) {
-    headerTransportOpts = {
-      eventSourceInit: {
-        fetch: (url2, init) => fetch(url2, {
-          ...init,
-          headers: options?.transport?.headers
-        })
-      },
-      requestInit: {
-        headers: options?.transport?.headers
-      }
+  getMcpServers() {
+    const mcpState = {
+      prompts: this.mcp.listPrompts(),
+      resources: this.mcp.listResources(),
+      servers: {},
+      tools: this.mcp.listTools()
     };
-  }
-  const { id, authUrl, clientId } = await this.mcp.connect(url, {
-    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
-  };
-};
-getMcpServerStateInternal_fn = function() {
-  const mcpState = {
-    servers: {},
-    tools: this.mcp.listTools(),
-    prompts: this.mcp.listPrompts(),
-    resources: this.mcp.listResources()
-  };
-  const servers = this.sql`
+    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) {
-    mcpState.servers[server.id] = {
-      name: server.name,
-      server_url: server.server_url,
-      auth_url: server.auth_url,
-      state: this.mcp.mcpConnections[server.id].connectionState
-    };
+    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,
+        // mark as "authenticating" because the server isn't automatically connected, so it's pending authenticating
+        state: serverConn?.connectionState ?? "authenticating"
+      };
+    }
+    return mcpState;
   }
-  return mcpState;
 };
 /**
  * Agent configuration options
@@ -680,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") {
@@ -713,55 +825,80 @@ 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);
 }
 var StreamingResponse = class {
   constructor(connection, id) {
-    this.closed = false;
-    this.connection = connection;
-    this.id = id;
+    this._closed = false;
+    this._connection = connection;
+    this._id = id;
   }
   /**
    * Send a chunk of data to the client
    * @param chunk The data to send
    */
   send(chunk) {
-    if (this.closed) {
+    if (this._closed) {
       throw new Error("StreamingResponse is already closed");
     }
     const response = {
-      type: "rpc",
-      id: this.id,
-      success: true,
+      done: false,
+      id: this._id,
       result: chunk,
-      done: false
+      success: true,
+      type: "rpc"
     };
-    this.connection.send(JSON.stringify(response));
+    this._connection.send(JSON.stringify(response));
   }
   /**
    * End the stream and send the final chunk (if any)
    * @param finalChunk Optional final chunk of data to send
    */
   end(finalChunk) {
-    if (this.closed) {
+    if (this._closed) {
       throw new Error("StreamingResponse is already closed");
     }
-    this.closed = true;
+    this._closed = true;
     const response = {
-      type: "rpc",
-      id: this.id,
-      success: true,
+      done: true,
+      id: this._id,
       result: finalChunk,
-      done: true
+      success: true,
+      type: "rpc"
     };
-    this.connection.send(JSON.stringify(response));
+    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,
@@ -770,4 +907,4 @@ export {
   getAgentByName,
   StreamingResponse
 };
-//# sourceMappingURL=chunk-DMJ7L3FI.js.map
+//# sourceMappingURL=chunk-JFRK72K3.js.map