agents 0.0.0-1232c19 → 0.0.0-14616d3

package/dist/{chunk-ZRRXJUAA.js → chunk-O4KIASSE.js}

@@ -1,30 +1,31 @@
 import {
   MCPClientManager
-} from "./chunk-E3LCYPCB.js";
+} from "./chunk-VYENMKFS.js";
 import {
   DurableObjectOAuthClientProvider
-} from "./chunk-767EASBA.js";
+} from "./chunk-LL2AFX7V.js";
 import {
   camelCaseToKebabCase
-} from "./chunk-NKZZ66QY.js";
+} from "./chunk-QEVM4BVL.js";
 
 // src/index.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { parseCronExpression } from "cron-schedule";
 import { nanoid } from "nanoid";
+import { EmailMessage } from "cloudflare:email";
 import {
+  Server,
   getServerByName,
-  routePartykitRequest,
-  Server
+  routePartykitRequest
 } from "partyserver";
 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);
+  return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "rpc" /* RPC */ && "id" in msg && typeof msg.id === "string" && "method" in msg && typeof msg.method === "string" && "args" in msg && Array.isArray(msg.args);
 }
 function isStateUpdateMessage(msg) {
-  return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "cf_agent_state" && "state" in msg;
+  return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "cf_agent_state" /* CF_AGENT_STATE */ && "state" in msg;
 }
 var callableMetadata = /* @__PURE__ */ new Map();
-function unstable_callable(metadata = {}) {
+function callable(metadata = {}) {
   return function callableDecorator(target, context) {
     if (!callableMetadata.has(target)) {
       callableMetadata.set(target, metadata);
@@ -32,6 +33,16 @@ function unstable_callable(metadata = {}) {
     return target;
   };
 }
+var didWarnAboutUnstableCallable = false;
+var unstable_callable = (metadata = {}) => {
+  if (!didWarnAboutUnstableCallable) {
+    didWarnAboutUnstableCallable = true;
+    console.warn(
+      "unstable_callable is deprecated, use callable instead. unstable_callable will be removed in the next major version."
+    );
+  }
+  callable(metadata);
+};
 function getNextCronTime(cron) {
   const interval = parseCronExpression(cron);
   return interval.getNextDate();
@@ -46,12 +57,24 @@ function getCurrentAgent() {
     return {
       agent: void 0,
       connection: void 0,
-      request: void 0
+      request: void 0,
+      email: void 0
     };
   }
   return store;
 }
-var Agent = class extends Server {
+function withAgentContext(method) {
+  return function(...args) {
+    const { connection, request, email, agent } = getCurrentAgent();
+    if (agent === this) {
+      return method.apply(this, args);
+    }
+    return agentContext.run({ agent: this, connection, request, email }, () => {
+      return method.apply(this, args);
+    });
+  };
+}
+var _Agent = class _Agent extends Server {
   constructor(ctx, env) {
     super(ctx, env);
     this._state = DEFAULT_STATE;
@@ -62,6 +85,11 @@ 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;
+    this._flushingQueue = false;
     /**
      * Method called when an alarm fires.
      * Executes any scheduled tasks that are due.
@@ -75,42 +103,71 @@ var Agent = class extends Server {
       const result = this.sql`
       SELECT * FROM cf_agents_schedules WHERE time <= ${now}
     `;
-      for (const row of result || []) {
-        const callback = this[row.callback];
-        if (!callback) {
-          console.error(`callback ${row.callback} not found`);
-          continue;
-        }
-        await agentContext.run(
-          { agent: this, connection: void 0, request: void 0 },
-          async () => {
-            try {
-              await callback.bind(this)(JSON.parse(row.payload), row);
-            } catch (e) {
-              console.error(`error executing callback "${row.callback}"`, e);
-            }
+      if (result && Array.isArray(result)) {
+        for (const row of result) {
+          const callback = this[row.callback];
+          if (!callback) {
+            console.error(`callback ${row.callback} not found`);
+            continue;
           }
-        );
-        if (row.type === "cron") {
-          const nextExecutionTime = getNextCronTime(row.cron);
-          const nextTimestamp = Math.floor(nextExecutionTime.getTime() / 1e3);
-          this.sql`
+          await agentContext.run(
+            {
+              agent: this,
+              connection: void 0,
+              request: void 0,
+              email: void 0
+            },
+            async () => {
+              try {
+                this.observability?.emit(
+                  {
+                    displayMessage: `Schedule ${row.id} executed`,
+                    id: nanoid(),
+                    payload: {
+                      callback: row.callback,
+                      id: row.id
+                    },
+                    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);
+              }
+            }
+          );
+          if (row.type === "cron") {
+            const nextExecutionTime = getNextCronTime(row.cron);
+            const nextTimestamp = Math.floor(nextExecutionTime.getTime() / 1e3);
+            this.sql`
           UPDATE cf_agents_schedules SET time = ${nextTimestamp} WHERE id = ${row.id}
         `;
-        } else {
-          this.sql`
+          } else {
+            this.sql`
           DELETE FROM cf_agents_schedules WHERE id = ${row.id}
         `;
+          }
         }
       }
       await this._scheduleNextAlarm();
     };
+    this._autoWrapCustomMethods();
     this.sql`
       CREATE TABLE IF NOT EXISTS cf_agents_state (
         id TEXT PRIMARY KEY NOT NULL,
         state TEXT
       )
     `;
+    this.sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_queues (
+        id TEXT PRIMARY KEY NOT NULL,
+        payload TEXT,
+        callback TEXT,
+        created_at INTEGER DEFAULT (unixepoch())
+      )
+    `;
     void this.ctx.blockConcurrencyWhile(async () => {
       return this._tryCatch(async () => {
         this.sql`
@@ -142,14 +199,14 @@ var Agent = class extends Server {
     const _onRequest = this.onRequest.bind(this);
     this.onRequest = (request) => {
       return agentContext.run(
-        { agent: this, connection: void 0, request },
+        { agent: this, connection: void 0, request, email: void 0 },
         async () => {
           if (this.mcp.isCallbackRequest(request)) {
             await this.mcp.handleCallbackRequest(request);
             this.broadcast(
               JSON.stringify({
                 mcp: this.getMcpServers(),
-                type: "cf_agent_mcp_servers"
+                type: "cf_agent_mcp_servers" /* CF_AGENT_MCP_SERVERS */
               })
             );
             return new Response("<script>window.close();</script>", {
@@ -164,7 +221,7 @@ var Agent = class extends Server {
     const _onMessage = this.onMessage.bind(this);
     this.onMessage = async (connection, message) => {
       return agentContext.run(
-        { agent: this, connection, request: void 0 },
+        { agent: this, connection, request: void 0, email: void 0 },
         async () => {
           if (typeof message !== "string") {
             return this._tryCatch(() => _onMessage(connection, message));
@@ -196,12 +253,25 @@ var Agent = class extends Server {
                 return;
               }
               const result = await methodFn.apply(this, args);
+              this.observability?.emit(
+                {
+                  displayMessage: `RPC call to ${method}`,
+                  id: nanoid(),
+                  payload: {
+                    method,
+                    streaming: metadata?.streaming
+                  },
+                  timestamp: Date.now(),
+                  type: "rpc"
+                },
+                this.ctx
+              );
               const response = {
                 done: true,
                 id,
                 result,
                 success: true,
-                type: "rpc"
+                type: "rpc" /* RPC */
               };
               connection.send(JSON.stringify(response));
             } catch (e) {
@@ -209,7 +279,7 @@ var Agent = class extends Server {
                 error: e instanceof Error ? e.message : "Unknown error occurred",
                 id: parsed.id,
                 success: false,
-                type: "rpc"
+                type: "rpc" /* RPC */
               };
               connection.send(JSON.stringify(response));
               console.error("RPC error:", e);
@@ -223,57 +293,92 @@ var Agent = class extends Server {
     const _onConnect = this.onConnect.bind(this);
     this.onConnect = (connection, ctx2) => {
       return agentContext.run(
-        { agent: this, connection, request: ctx2.request },
-        async () => {
-          setTimeout(() => {
-            if (this.state) {
-              connection.send(
-                JSON.stringify({
-                  state: this.state,
-                  type: "cf_agent_state"
-                })
-              );
-            }
+        { agent: this, connection, request: ctx2.request, email: void 0 },
+        () => {
+          if (this.state) {
             connection.send(
               JSON.stringify({
-                mcp: this.getMcpServers(),
-                type: "cf_agent_mcp_servers"
+                state: this.state,
+                type: "cf_agent_state" /* CF_AGENT_STATE */
               })
             );
-            return this._tryCatch(() => _onConnect(connection, ctx2));
-          }, 20);
+          }
+          connection.send(
+            JSON.stringify({
+              mcp: this.getMcpServers(),
+              type: "cf_agent_mcp_servers" /* 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));
         }
       );
     };
     const _onStart = this.onStart.bind(this);
     this.onStart = async () => {
       return agentContext.run(
-        { agent: this, connection: void 0, request: void 0 },
+        {
+          agent: this,
+          connection: void 0,
+          request: void 0,
+          email: void 0
+        },
         async () => {
-          const servers = this.sql`
+          await this._tryCatch(() => {
+            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(
-            servers.filter((server) => server.auth_url === null).map((server) => {
-              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
-                }
-              );
-            })
-          );
-          this.broadcast(
-            JSON.stringify({
-              mcp: this.getMcpServers(),
-              type: "cf_agent_mcp_servers"
-            })
-          );
-          await this._tryCatch(() => _onStart());
+            this.broadcast(
+              JSON.stringify({
+                mcp: this.getMcpServers(),
+                type: "cf_agent_mcp_servers" /* CF_AGENT_MCP_SERVERS */
+              })
+            );
+            if (servers && Array.isArray(servers) && servers.length > 0) {
+              servers.forEach((server) => {
+                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
+                  }
+                ).then(() => {
+                  this.broadcast(
+                    JSON.stringify({
+                      mcp: this.getMcpServers(),
+                      type: "cf_agent_mcp_servers" /* CF_AGENT_MCP_SERVERS */
+                    })
+                  );
+                }).catch((error) => {
+                  console.error(
+                    `Error connecting to MCP server: ${server.name} (${server.server_url})`,
+                    error
+                  );
+                  this.broadcast(
+                    JSON.stringify({
+                      mcp: this.getMcpServers(),
+                      type: "cf_agent_mcp_servers" /* CF_AGENT_MCP_SERVERS */
+                    })
+                  );
+                });
+              });
+            }
+            return _onStart();
+          });
         }
       );
     };
@@ -336,15 +441,25 @@ var Agent = class extends Server {
     this.broadcast(
       JSON.stringify({
         state,
-        type: "cf_agent_state"
+        type: "cf_agent_state" /* CF_AGENT_STATE */
       }),
       source !== "server" ? [source.id] : []
     );
     return this._tryCatch(() => {
-      const { connection, request } = agentContext.getStore() || {};
+      const { connection, request, email } = agentContext.getStore() || {};
       return agentContext.run(
-        { agent: this, connection, request },
+        { agent: this, connection, request, email },
         async () => {
+          this.observability?.emit(
+            {
+              displayMessage: "State updated",
+              id: nanoid(),
+              payload: {},
+              timestamp: Date.now(),
+              type: "state:update"
+            },
+            this.ctx
+          );
           return this.onStateUpdate(state, source);
         }
       );
@@ -366,18 +481,67 @@ var Agent = class extends Server {
   onStateUpdate(state, source) {
   }
   /**
-   * Called when the Agent receives an email
+   * Called when the Agent receives an email via routeAgentEmail()
+   * Override this method to handle incoming emails
    * @param email Email message to process
    */
-  // biome-ignore lint/correctness/noUnusedFunctionParameters: overridden later
-  onEmail(email) {
+  async _onEmail(email) {
     return agentContext.run(
-      { agent: this, connection: void 0, request: void 0 },
+      { agent: this, connection: void 0, request: void 0, email },
       async () => {
-        console.error("onEmail not implemented");
+        if ("onEmail" in this && typeof this.onEmail === "function") {
+          return this._tryCatch(
+            () => this.onEmail(email)
+          );
+        } else {
+          console.log("Received email from:", email.from, "to:", email.to);
+          console.log("Subject:", email.headers.get("subject"));
+          console.log(
+            "Implement onEmail(email: AgentEmail): Promise<void> in your agent to process emails"
+          );
+        }
       }
     );
   }
+  /**
+   * Reply to an email
+   * @param email The email to reply to
+   * @param options Options for the reply
+   * @returns void
+   */
+  async replyToEmail(email, options) {
+    return this._tryCatch(async () => {
+      const agentName = camelCaseToKebabCase(this._ParentClass.name);
+      const agentId = this.name;
+      const { createMimeMessage } = await import("mimetext");
+      const msg = createMimeMessage();
+      msg.setSender({ addr: email.to, name: options.fromName });
+      msg.setRecipient(email.from);
+      msg.setSubject(
+        options.subject || `Re: ${email.headers.get("subject")}` || "No subject"
+      );
+      msg.addMessage({
+        contentType: options.contentType || "text/plain",
+        data: options.body
+      });
+      const domain = email.from.split("@")[1];
+      const messageId = `<${agentId}@${domain}>`;
+      msg.setHeader("In-Reply-To", email.headers.get("Message-ID"));
+      msg.setHeader("Message-ID", messageId);
+      msg.setHeader("X-Agent-Name", agentName);
+      msg.setHeader("X-Agent-ID", agentId);
+      if (options.headers) {
+        for (const [key, value] of Object.entries(options.headers)) {
+          msg.setHeader(key, value);
+        }
+      }
+      await email.reply({
+        from: email.to,
+        raw: msg.asRaw(),
+        to: email.from
+      });
+    });
+  }
   async _tryCatch(fn) {
     try {
       return await fn();
@@ -385,6 +549,55 @@ var Agent = class extends Server {
       throw this.onError(e);
     }
   }
+  /**
+   * Automatically wrap custom methods with agent context
+   * This ensures getCurrentAgent() works in all custom methods without decorators
+   */
+  _autoWrapCustomMethods() {
+    const basePrototypes = [_Agent.prototype, Server.prototype];
+    const baseMethods = /* @__PURE__ */ new Set();
+    for (const baseProto of basePrototypes) {
+      let proto2 = baseProto;
+      while (proto2 && proto2 !== Object.prototype) {
+        const methodNames = Object.getOwnPropertyNames(proto2);
+        for (const methodName of methodNames) {
+          baseMethods.add(methodName);
+        }
+        proto2 = Object.getPrototypeOf(proto2);
+      }
+    }
+    let proto = Object.getPrototypeOf(this);
+    let depth = 0;
+    while (proto && proto !== Object.prototype && depth < 10) {
+      const methodNames = Object.getOwnPropertyNames(proto);
+      for (const methodName of methodNames) {
+        if (baseMethods.has(methodName) || methodName.startsWith("_") || typeof this[methodName] !== "function" || !!Object.getOwnPropertyDescriptor(proto, methodName)?.get) {
+          continue;
+        }
+        if (!baseMethods.has(methodName)) {
+          const descriptor = Object.getOwnPropertyDescriptor(proto, methodName);
+          if (descriptor && typeof descriptor.value === "function") {
+            const wrappedFunction = withAgentContext(
+              // biome-ignore lint/suspicious/noExplicitAny: I can't typescript
+              this[methodName]
+              // biome-ignore lint/suspicious/noExplicitAny: I can't typescript
+            );
+            if (this._isCallable(methodName)) {
+              callableMetadata.set(
+                wrappedFunction,
+                callableMetadata.get(
+                  this[methodName]
+                )
+              );
+            }
+            this.constructor.prototype[methodName] = wrappedFunction;
+          }
+        }
+      }
+      proto = Object.getPrototypeOf(proto);
+      depth++;
+    }
+  }
   onError(connectionOrError, error) {
     let theError;
     if (connectionOrError && error) {
@@ -410,6 +623,108 @@ var Agent = class extends Server {
   render() {
     throw new Error("Not implemented");
   }
+  /**
+   * Queue a task to be executed in the future
+   * @param payload Payload to pass to the callback
+   * @param callback Name of the method to call
+   * @returns The ID of the queued task
+   */
+  async queue(callback, payload) {
+    const id = nanoid(9);
+    if (typeof callback !== "string") {
+      throw new Error("Callback must be a string");
+    }
+    if (typeof this[callback] !== "function") {
+      throw new Error(`this.${callback} is not a function`);
+    }
+    this.sql`
+      INSERT OR REPLACE INTO cf_agents_queues (id, payload, callback)
+      VALUES (${id}, ${JSON.stringify(payload)}, ${callback})
+    `;
+    void this._flushQueue().catch((e) => {
+      console.error("Error flushing queue:", e);
+    });
+    return id;
+  }
+  async _flushQueue() {
+    if (this._flushingQueue) {
+      return;
+    }
+    this._flushingQueue = true;
+    while (true) {
+      const result = this.sql`
+      SELECT * FROM cf_agents_queues
+      ORDER BY created_at ASC
+    `;
+      if (!result || result.length === 0) {
+        break;
+      }
+      for (const row of result || []) {
+        const callback = this[row.callback];
+        if (!callback) {
+          console.error(`callback ${row.callback} not found`);
+          continue;
+        }
+        const { connection, request, email } = agentContext.getStore() || {};
+        await agentContext.run(
+          {
+            agent: this,
+            connection,
+            request,
+            email
+          },
+          async () => {
+            await callback.bind(this)(JSON.parse(row.payload), row);
+            await this.dequeue(row.id);
+          }
+        );
+      }
+    }
+    this._flushingQueue = false;
+  }
+  /**
+   * Dequeue a task by ID
+   * @param id ID of the task to dequeue
+   */
+  async dequeue(id) {
+    this.sql`DELETE FROM cf_agents_queues WHERE id = ${id}`;
+  }
+  /**
+   * Dequeue all tasks
+   */
+  async dequeueAll() {
+    this.sql`DELETE FROM cf_agents_queues`;
+  }
+  /**
+   * Dequeue all tasks by callback
+   * @param callback Name of the callback to dequeue
+   */
+  async dequeueAllByCallback(callback) {
+    this.sql`DELETE FROM cf_agents_queues WHERE callback = ${callback}`;
+  }
+  /**
+   * Get a queued task by ID
+   * @param id ID of the task to get
+   * @returns The task or undefined if not found
+   */
+  async getQueue(id) {
+    const result = this.sql`
+      SELECT * FROM cf_agents_queues WHERE id = ${id}
+    `;
+    return result ? { ...result[0], payload: JSON.parse(result[0].payload) } : void 0;
+  }
+  /**
+   * Get all queues by key and value
+   * @param key Key to filter by
+   * @param value Value to filter by
+   * @returns Array of matching QueueItem objects
+   */
+  async getQueues(key, value) {
+    const result = this.sql`
+      SELECT * FROM cf_agents_queues
+    `;
+    return result.filter((row) => JSON.parse(row.payload)[key] === value);
+  }
   /**
    * Schedule a task to be executed in the future
    * @template T Type of the payload data
@@ -420,6 +735,19 @@ 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: {
+          callback,
+          id
+        },
+        timestamp: Date.now(),
+        type: "schedule:create"
+      },
+      this.ctx
+    );
     if (typeof callback !== "string") {
       throw new Error("Callback must be a string");
     }
@@ -435,13 +763,15 @@ var Agent = class extends Server {
       )}, 'scheduled', ${timestamp})
       `;
       await this._scheduleNextAlarm();
-      return {
+      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);
@@ -453,7 +783,7 @@ var Agent = class extends Server {
       )}, 'delayed', ${when}, ${timestamp})
       `;
       await this._scheduleNextAlarm();
-      return {
+      const schedule = {
         callback,
         delayInSeconds: when,
         id,
@@ -461,6 +791,8 @@ var Agent = class extends Server {
         time: timestamp,
         type: "delayed"
       };
+      emitScheduleCreate(schedule);
+      return schedule;
     }
     if (typeof when === "string") {
       const nextExecutionTime = getNextCronTime(when);
@@ -472,7 +804,7 @@ var Agent = class extends Server {
       )}, 'cron', ${when}, ${timestamp})
       `;
       await this._scheduleNextAlarm();
-      return {
+      const schedule = {
         callback,
         cron: when,
         id,
@@ -480,6 +812,8 @@ var Agent = class extends Server {
         time: timestamp,
         type: "cron"
       };
+      emitScheduleCreate(schedule);
+      return schedule;
     }
     throw new Error("Invalid schedule type");
   }
@@ -537,15 +871,31 @@ 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: {
+            callback: schedule.callback,
+            id: schedule.id
+          },
+          timestamp: Date.now(),
+          type: "schedule:cancel"
+        },
+        this.ctx
+      );
+    }
     this.sql`DELETE FROM cf_agents_schedules WHERE id = ${id}`;
     await this._scheduleNextAlarm();
     return true;
   }
   async _scheduleNextAlarm() {
     const result = this.sql`
-      SELECT time FROM cf_agents_schedules 
+      SELECT time FROM cf_agents_schedules
       WHERE time > ${Math.floor(Date.now() / 1e3)}
-      ORDER BY time ASC 
+      ORDER BY time ASC
       LIMIT 1
     `;
     if (!result) return;
@@ -561,9 +911,20 @@ var Agent = class extends Server {
     this.sql`DROP TABLE IF EXISTS cf_agents_state`;
     this.sql`DROP TABLE IF EXISTS cf_agents_schedules`;
     this.sql`DROP TABLE IF EXISTS cf_agents_mcp_servers`;
+    this.sql`DROP TABLE IF EXISTS cf_agents_queues`;
     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
@@ -589,15 +950,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({
         mcp: this.getMcpServers(),
-        type: "cf_agent_mcp_servers"
+        type: "cf_agent_mcp_servers" /* 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,
@@ -631,20 +1005,9 @@ var Agent = class extends Server {
         authProvider
       }
     });
-    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 {
       authUrl,
+      clientId,
       id
     };
   }
@@ -656,7 +1019,7 @@ var Agent = class extends Server {
     this.broadcast(
       JSON.stringify({
         mcp: this.getMcpServers(),
-        type: "cf_agent_mcp_servers"
+        type: "cf_agent_mcp_servers" /* CF_AGENT_MCP_SERVERS */
       })
     );
   }
@@ -670,17 +1033,19 @@ 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;
     `;
-    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"
-      };
+    if (servers && Array.isArray(servers) && servers.length > 0) {
+      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;
   }
@@ -688,11 +1053,12 @@ var Agent = class extends Server {
 /**
  * Agent configuration options
  */
-Agent.options = {
+_Agent.options = {
   /** Whether the Agent should hibernate when inactive */
   hibernate: true
   // default to hibernate
 };
+var Agent = _Agent;
 async function routeAgentRequest(request, env, options) {
   const corsHeaders = options?.cors === true ? {
     "Access-Control-Allow-Credentials": "true",
@@ -728,7 +1094,126 @@ async function routeAgentRequest(request, env, options) {
   }
   return response;
 }
-async function routeAgentEmail(_email, _env, _options) {
+function createHeaderBasedEmailResolver() {
+  return async (email, _env) => {
+    const messageId = email.headers.get("message-id");
+    if (messageId) {
+      const messageIdMatch = messageId.match(/<([^@]+)@([^>]+)>/);
+      if (messageIdMatch) {
+        const [, agentId2, domain] = messageIdMatch;
+        const agentName2 = domain.split(".")[0];
+        return { agentName: agentName2, agentId: agentId2 };
+      }
+    }
+    const references = email.headers.get("references");
+    if (references) {
+      const referencesMatch = references.match(
+        /<([A-Za-z0-9+/]{43}=)@([^>]+)>/
+      );
+      if (referencesMatch) {
+        const [, base64Id, domain] = referencesMatch;
+        const agentId2 = Buffer.from(base64Id, "base64").toString("hex");
+        const agentName2 = domain.split(".")[0];
+        return { agentName: agentName2, agentId: agentId2 };
+      }
+    }
+    const agentName = email.headers.get("x-agent-name");
+    const agentId = email.headers.get("x-agent-id");
+    if (agentName && agentId) {
+      return { agentName, agentId };
+    }
+    return null;
+  };
+}
+function createAddressBasedEmailResolver(defaultAgentName) {
+  return async (email, _env) => {
+    const emailMatch = email.to.match(/^([^+@]+)(?:\+([^@]+))?@(.+)$/);
+    if (!emailMatch) {
+      return null;
+    }
+    const [, localPart, subAddress] = emailMatch;
+    if (subAddress) {
+      return {
+        agentName: localPart,
+        agentId: subAddress
+      };
+    }
+    return {
+      agentName: defaultAgentName,
+      agentId: localPart
+    };
+  };
+}
+function createCatchAllEmailResolver(agentName, agentId) {
+  return async () => ({ agentName, agentId });
+}
+var agentMapCache = /* @__PURE__ */ new WeakMap();
+async function routeAgentEmail(email, env, options) {
+  const routingInfo = await options.resolver(email, env);
+  if (!routingInfo) {
+    console.warn("No routing information found for email, dropping message");
+    return;
+  }
+  if (!agentMapCache.has(env)) {
+    const map = {};
+    for (const [key, value] of Object.entries(env)) {
+      if (value && typeof value === "object" && "idFromName" in value && typeof value.idFromName === "function") {
+        map[key] = value;
+        map[camelCaseToKebabCase(key)] = value;
+      }
+    }
+    agentMapCache.set(env, map);
+  }
+  const agentMap = agentMapCache.get(env);
+  const namespace = agentMap[routingInfo.agentName];
+  if (!namespace) {
+    const availableAgents = Object.keys(agentMap).filter((key) => !key.includes("-")).join(", ");
+    throw new Error(
+      `Agent namespace '${routingInfo.agentName}' not found in environment. Available agents: ${availableAgents}`
+    );
+  }
+  const agent = await getAgentByName(
+    namespace,
+    routingInfo.agentId
+  );
+  const serialisableEmail = {
+    getRaw: async () => {
+      const reader = email.raw.getReader();
+      const chunks = [];
+      let done = false;
+      while (!done) {
+        const { value, done: readerDone } = await reader.read();
+        done = readerDone;
+        if (value) {
+          chunks.push(value);
+        }
+      }
+      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+      const combined = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return combined;
+    },
+    headers: email.headers,
+    rawSize: email.rawSize,
+    setReject: (reason) => {
+      email.setReject(reason);
+    },
+    forward: (rcptTo, headers) => {
+      return email.forward(rcptTo, headers);
+    },
+    reply: (options2) => {
+      return email.reply(
+        new EmailMessage(options2.from, options2.to, options2.raw)
+      );
+    },
+    from: email.from,
+    to: email.to
+  };
+  await agent._onEmail(serialisableEmail);
 }
 async function getAgentByName(namespace, name, options) {
   return getServerByName(namespace, name, options);
@@ -752,7 +1237,7 @@ var StreamingResponse = class {
       id: this._id,
       result: chunk,
       success: true,
-      type: "rpc"
+      type: "rpc" /* RPC */
     };
     this._connection.send(JSON.stringify(response));
   }
@@ -770,19 +1255,48 @@ var StreamingResponse = class {
       id: this._id,
       result: finalChunk,
       success: true,
-      type: "rpc"
+      type: "rpc" /* 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,
+  callable,
   unstable_callable,
   getCurrentAgent,
   Agent,
   routeAgentRequest,
+  createHeaderBasedEmailResolver,
+  createAddressBasedEmailResolver,
+  createCatchAllEmailResolver,
   routeAgentEmail,
   getAgentByName,
   StreamingResponse
 };
-//# sourceMappingURL=chunk-ZRRXJUAA.js.map
+//# sourceMappingURL=chunk-O4KIASSE.js.map