agents 0.0.0-b30ffda → 0.0.0-b803d5e

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

@@ -1,9 +1,12 @@
 import {
-  __privateAdd,
-  __privateGet,
-  __privateMethod,
-  __privateSet
-} from "./chunk-HMLY7DHA.js";
+  DurableObjectOAuthClientProvider
+} from "./chunk-BZXOAZUX.js";
+import {
+  camelCaseToKebabCase
+} from "./chunk-QSGN3REV.js";
+import {
+  MCPClientManager
+} from "./chunk-Y67CHZBI.js";
 
 // src/index.ts
 import {
@@ -36,18 +39,72 @@ function getNextCronTime(cron) {
 var STATE_ROW_ID = "cf_state_row_id";
 var STATE_WAS_CHANGED = "cf_state_was_changed";
 var DEFAULT_STATE = {};
-var unstable_context = new AsyncLocalStorage();
-var _state, _Agent_instances, setStateInternal_fn, tryCatch_fn, scheduleNextAlarm_fn, isCallable_fn;
+var agentContext = new AsyncLocalStorage();
+function getCurrentAgent() {
+  const store = agentContext.getStore();
+  if (!store) {
+    return {
+      agent: void 0,
+      connection: void 0,
+      request: void 0
+    };
+  }
+  return store;
+}
 var Agent = class extends Server {
   constructor(ctx, env) {
     super(ctx, env);
-    __privateAdd(this, _Agent_instances);
-    __privateAdd(this, _state, DEFAULT_STATE);
+    this._state = DEFAULT_STATE;
+    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;
+    /**
+     * Method called when an alarm fires.
+     * Executes any scheduled tasks that are due.
+     *
+     * @remarks
+     * To schedule a task, please use the `this.schedule` method instead.
+     * See {@link https://developers.cloudflare.com/agents/api-reference/schedule-tasks/}
+     */
+    this.alarm = async () => {
+      const now = Math.floor(Date.now() / 1e3);
+      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 (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`
+          DELETE FROM cf_agents_schedules WHERE id = ${row.id}
+        `;
+        }
+      }
+      await this._scheduleNextAlarm();
+    };
     this.sql`
       CREATE TABLE IF NOT EXISTS cf_agents_state (
         id TEXT PRIMARY KEY NOT NULL,
@@ -55,7 +112,7 @@ var Agent = class extends Server {
       )
     `;
     void this.ctx.blockConcurrencyWhile(async () => {
-      return __privateMethod(this, _Agent_instances, tryCatch_fn).call(this, async () => {
+      return this._tryCatch(async () => {
         this.sql`
         CREATE TABLE IF NOT EXISTS cf_agents_schedules (
           id TEXT PRIMARY KEY NOT NULL DEFAULT (randomblob(9)),
@@ -71,22 +128,55 @@ var Agent = class extends Server {
         await this.alarm();
       });
     });
+    this.sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_mcp_servers (
+        id TEXT PRIMARY KEY NOT NULL,
+        name TEXT NOT NULL,
+        server_url TEXT NOT NULL,
+        callback_url TEXT NOT NULL,
+        client_id TEXT,
+        auth_url TEXT,
+        server_options TEXT
+      )
+    `;
+    const _onRequest = this.onRequest.bind(this);
+    this.onRequest = (request) => {
+      return agentContext.run(
+        { agent: this, connection: void 0, request },
+        async () => {
+          if (this.mcp.isCallbackRequest(request)) {
+            await this.mcp.handleCallbackRequest(request);
+            this.broadcast(
+              JSON.stringify({
+                type: "cf_agent_mcp_servers",
+                mcp: this.getMcpServers()
+              })
+            );
+            return new Response("<script>window.close();</script>", {
+              status: 200,
+              headers: { "content-type": "text/html" }
+            });
+          }
+          return this._tryCatch(() => _onRequest(request));
+        }
+      );
+    };
     const _onMessage = this.onMessage.bind(this);
     this.onMessage = async (connection, message) => {
-      return unstable_context.run(
+      return agentContext.run(
         { agent: this, connection, request: void 0 },
         async () => {
           if (typeof message !== "string") {
-            return __privateMethod(this, _Agent_instances, tryCatch_fn).call(this, () => _onMessage(connection, message));
+            return this._tryCatch(() => _onMessage(connection, message));
           }
           let parsed;
           try {
             parsed = JSON.parse(message);
           } catch (e) {
-            return __privateMethod(this, _Agent_instances, tryCatch_fn).call(this, () => _onMessage(connection, message));
+            return this._tryCatch(() => _onMessage(connection, message));
           }
           if (isStateUpdateMessage(parsed)) {
-            __privateMethod(this, _Agent_instances, setStateInternal_fn).call(this, parsed.state, connection);
+            this._setStateInternal(parsed.state, connection);
             return;
           }
           if (isRPCRequest(parsed)) {
@@ -96,7 +186,7 @@ var Agent = class extends Server {
               if (typeof methodFn !== "function") {
                 throw new Error(`Method ${method} does not exist`);
               }
-              if (!__privateMethod(this, _Agent_instances, isCallable_fn).call(this, method)) {
+              if (!this._isCallable(method)) {
                 throw new Error(`Method ${method} is not callable`);
               }
               const metadata = callableMetadata.get(methodFn);
@@ -126,13 +216,13 @@ var Agent = class extends Server {
             }
             return;
           }
-          return __privateMethod(this, _Agent_instances, tryCatch_fn).call(this, () => _onMessage(connection, message));
+          return this._tryCatch(() => _onMessage(connection, message));
         }
       );
     };
     const _onConnect = this.onConnect.bind(this);
     this.onConnect = (connection, ctx2) => {
-      return unstable_context.run(
+      return agentContext.run(
         { agent: this, connection, request: ctx2.request },
         async () => {
           setTimeout(() => {
@@ -144,18 +234,56 @@ var Agent = class extends Server {
                 })
               );
             }
-            return __privateMethod(this, _Agent_instances, tryCatch_fn).call(this, () => _onConnect(connection, ctx2));
+            connection.send(
+              JSON.stringify({
+                type: "cf_agent_mcp_servers",
+                mcp: this.getMcpServers()
+              })
+            );
+            return this._tryCatch(() => _onConnect(connection, ctx2));
           }, 20);
         }
       );
     };
+    const _onStart = this.onStart.bind(this);
+    this.onStart = async () => {
+      return agentContext.run(
+        { agent: this, connection: void 0, request: void 0 },
+        async () => {
+          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.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({
+              type: "cf_agent_mcp_servers",
+              mcp: this.getMcpServers()
+            })
+          );
+          await this._tryCatch(() => _onStart());
+        }
+      );
+    };
   }
   /**
    * Current state of the Agent
    */
   get state() {
-    if (__privateGet(this, _state) !== DEFAULT_STATE) {
-      return __privateGet(this, _state);
+    if (this._state !== DEFAULT_STATE) {
+      return this._state;
     }
     const wasChanged = this.sql`
         SELECT state FROM cf_agents_state WHERE id = ${STATE_WAS_CHANGED}
@@ -166,8 +294,8 @@ var Agent = class extends Server {
     if (wasChanged[0]?.state === "true" || // we do this check for people who updated their code before we shipped wasChanged
     result[0]?.state) {
       const state = result[0]?.state;
-      __privateSet(this, _state, JSON.parse(state));
-      return __privateGet(this, _state);
+      this._state = JSON.parse(state);
+      return this._state;
     }
     if (this.initialState === DEFAULT_STATE) {
       return void 0;
@@ -195,12 +323,39 @@ var Agent = class extends Server {
       throw this.onError(e);
     }
   }
+  _setStateInternal(state, source = "server") {
+    this._state = state;
+    this.sql`
+    INSERT OR REPLACE INTO cf_agents_state (id, state)
+    VALUES (${STATE_ROW_ID}, ${JSON.stringify(state)})
+  `;
+    this.sql`
+    INSERT OR REPLACE INTO cf_agents_state (id, state)
+    VALUES (${STATE_WAS_CHANGED}, ${JSON.stringify(true)})
+  `;
+    this.broadcast(
+      JSON.stringify({
+        type: "cf_agent_state",
+        state
+      }),
+      source !== "server" ? [source.id] : []
+    );
+    return this._tryCatch(() => {
+      const { connection, request } = agentContext.getStore() || {};
+      return agentContext.run(
+        { agent: this, connection, request },
+        async () => {
+          return this.onStateUpdate(state, source);
+        }
+      );
+    });
+  }
   /**
    * Update the Agent's state
    * @param state New state to set
    */
   setState(state) {
-    __privateMethod(this, _Agent_instances, setStateInternal_fn).call(this, state, "server");
+    this._setStateInternal(state, "server");
   }
   /**
    * Called when the Agent's state is updated
@@ -214,13 +369,20 @@ var Agent = class extends Server {
    * @param email Email message to process
    */
   onEmail(email) {
-    return unstable_context.run(
+    return agentContext.run(
       { agent: this, connection: void 0, request: void 0 },
       async () => {
         console.error("onEmail not implemented");
       }
     );
   }
+  async _tryCatch(fn) {
+    try {
+      return await fn();
+    } catch (e) {
+      throw this.onError(e);
+    }
+  }
   onError(connectionOrError, error) {
     let theError;
     if (connectionOrError && error) {
@@ -270,7 +432,7 @@ var Agent = class extends Server {
         payload
       )}, 'scheduled', ${timestamp})
       `;
-      await __privateMethod(this, _Agent_instances, scheduleNextAlarm_fn).call(this);
+      await this._scheduleNextAlarm();
       return {
         id,
         callback,
@@ -288,7 +450,7 @@ var Agent = class extends Server {
         payload
       )}, 'delayed', ${when}, ${timestamp})
       `;
-      await __privateMethod(this, _Agent_instances, scheduleNextAlarm_fn).call(this);
+      await this._scheduleNextAlarm();
       return {
         id,
         callback,
@@ -307,7 +469,7 @@ var Agent = class extends Server {
         payload
       )}, 'cron', ${when}, ${timestamp})
       `;
-      await __privateMethod(this, _Agent_instances, scheduleNextAlarm_fn).call(this);
+      await this._scheduleNextAlarm();
       return {
         id,
         callback,
@@ -374,47 +536,21 @@ var Agent = class extends Server {
    */
   async cancelSchedule(id) {
     this.sql`DELETE FROM cf_agents_schedules WHERE id = ${id}`;
-    await __privateMethod(this, _Agent_instances, scheduleNextAlarm_fn).call(this);
+    await this._scheduleNextAlarm();
     return true;
   }
-  /**
-   * Method called when an alarm fires
-   * Executes any scheduled tasks that are due
-   */
-  async alarm() {
-    const now = Math.floor(Date.now() / 1e3);
+  async _scheduleNextAlarm() {
     const result = this.sql`
-      SELECT * FROM cf_agents_schedules WHERE time <= ${now}
+      SELECT time FROM cf_agents_schedules 
+      WHERE time > ${Math.floor(Date.now() / 1e3)}
+      ORDER BY time ASC 
+      LIMIT 1
     `;
-    for (const row of result || []) {
-      const callback = this[row.callback];
-      if (!callback) {
-        console.error(`callback ${row.callback} not found`);
-        continue;
-      }
-      await unstable_context.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 (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`
-          DELETE FROM cf_agents_schedules WHERE id = ${row.id}
-        `;
-      }
+    if (!result) return;
+    if (result.length > 0 && "time" in result[0]) {
+      const nextTime = result[0].time * 1e3;
+      await this.ctx.storage.setAlarm(nextTime);
     }
-    await __privateMethod(this, _Agent_instances, scheduleNextAlarm_fn).call(this);
   }
   /**
    * Destroy the Agent, removing all state and scheduled tasks
@@ -422,66 +558,128 @@ var Agent = class extends Server {
   async destroy() {
     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`;
     await this.ctx.storage.deleteAlarm();
     await this.ctx.storage.deleteAll();
   }
-};
-_state = new WeakMap();
-_Agent_instances = new WeakSet();
-setStateInternal_fn = function(state, source = "server") {
-  __privateSet(this, _state, state);
-  this.sql`
-    INSERT OR REPLACE INTO cf_agents_state (id, state)
-    VALUES (${STATE_ROW_ID}, ${JSON.stringify(state)})
-  `;
-  this.sql`
-    INSERT OR REPLACE INTO cf_agents_state (id, state)
-    VALUES (${STATE_WAS_CHANGED}, ${JSON.stringify(true)})
-  `;
-  this.broadcast(
-    JSON.stringify({
-      type: "cf_agent_state",
-      state
-    }),
-    source !== "server" ? [source.id] : []
-  );
-  return __privateMethod(this, _Agent_instances, tryCatch_fn).call(this, () => {
-    const { connection, request } = unstable_context.getStore() || {};
-    return unstable_context.run(
-      { agent: this, connection, request },
-      async () => {
-        return this.onStateUpdate(state, source);
+  /**
+   * 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]);
+  }
+  /**
+   * Connect to a new MCP Server
+   *
+   * @param url MCP Server SSE URL
+   * @param callbackHost Base host for the agent, used for the redirect URI.
+   * @param agentsPrefix agents routing prefix if not using `agents`
+   * @param options MCP client and transport (header) options
+   * @returns authUrl
+   */
+  async addMcpServer(serverName, url, callbackHost, agentsPrefix = "agents", options) {
+    const callbackUrl = `${callbackHost}/${agentsPrefix}/${camelCaseToKebabCase(this._ParentClass.name)}/${this.name}/callback`;
+    const result = await this._connectToMcpServerInternal(
+      serverName,
+      url,
+      callbackUrl,
+      options
+    );
+    this.broadcast(
+      JSON.stringify({
+        type: "cf_agent_mcp_servers",
+        mcp: this.getMcpServers()
+      })
+    );
+    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, {
+      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
+    };
+  }
+  async removeMcpServer(id) {
+    this.mcp.closeConnection(id);
+    this.sql`
+      DELETE FROM cf_agents_mcp_servers WHERE id = ${id};
+    `;
+    this.broadcast(
+      JSON.stringify({
+        type: "cf_agent_mcp_servers",
+        mcp: this.getMcpServers()
+      })
     );
-  });
-};
-tryCatch_fn = async function(fn) {
-  try {
-    return await fn();
-  } catch (e) {
-    throw this.onError(e);
   }
-};
-scheduleNextAlarm_fn = async function() {
-  const result = this.sql`
-      SELECT time FROM cf_agents_schedules 
-      WHERE time > ${Math.floor(Date.now() / 1e3)}
-      ORDER BY time ASC 
-      LIMIT 1
+  getMcpServers() {
+    const mcpState = {
+      servers: {},
+      tools: this.mcp.listTools(),
+      prompts: this.mcp.listPrompts(),
+      resources: this.mcp.listResources()
+    };
+    const servers = this.sql`
+      SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers;
     `;
-  if (!result) return;
-  if (result.length > 0 && "time" in result[0]) {
-    const nextTime = result[0].time * 1e3;
-    await this.ctx.storage.setAlarm(nextTime);
+    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,
+        instructions: this.mcp.mcpConnections[server.id].instructions ?? null,
+        capabilities: this.mcp.mcpConnections[server.id].serverCapabilities ?? null
+      };
+    }
+    return mcpState;
   }
 };
-/**
- * Get all methods marked as callable on this Agent
- * @returns A map of method names to their metadata
- */
-isCallable_fn = function(method) {
-  return callableMetadata.has(this[method]);
-};
 /**
  * Agent configuration options
  */
@@ -527,65 +725,59 @@ async function routeAgentRequest(request, env, options) {
 }
 async function routeAgentEmail(email, env, options) {
 }
-function getAgentByName(namespace, name, options) {
+async function getAgentByName(namespace, name, options) {
   return getServerByName(namespace, name, options);
 }
-var _connection, _id, _closed;
 var StreamingResponse = class {
   constructor(connection, id) {
-    __privateAdd(this, _connection);
-    __privateAdd(this, _id);
-    __privateAdd(this, _closed, false);
-    __privateSet(this, _connection, connection);
-    __privateSet(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 (__privateGet(this, _closed)) {
+    if (this._closed) {
       throw new Error("StreamingResponse is already closed");
     }
     const response = {
       type: "rpc",
-      id: __privateGet(this, _id),
+      id: this._id,
       success: true,
       result: chunk,
       done: false
     };
-    __privateGet(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 (__privateGet(this, _closed)) {
+    if (this._closed) {
       throw new Error("StreamingResponse is already closed");
     }
-    __privateSet(this, _closed, true);
+    this._closed = true;
     const response = {
       type: "rpc",
-      id: __privateGet(this, _id),
+      id: this._id,
       success: true,
       result: finalChunk,
       done: true
     };
-    __privateGet(this, _connection).send(JSON.stringify(response));
+    this._connection.send(JSON.stringify(response));
   }
 };
-_connection = new WeakMap();
-_id = new WeakMap();
-_closed = new WeakMap();
 
 export {
   unstable_callable,
-  unstable_context,
+  getCurrentAgent,
   Agent,
   routeAgentRequest,
   routeAgentEmail,
   getAgentByName,
   StreamingResponse
 };
-//# sourceMappingURL=chunk-XG52S6YY.js.map
+//# sourceMappingURL=chunk-J6T74FUS.js.map