poe-code 3.0.73 → 3.0.74

package/dist/providers/poe-agent.js

@@ -668,17 +668,1433 @@ var init_chat = __esm({
   }
 });
 
+// packages/tiny-mcp-client/src/internal.ts
+import { spawn as spawn2 } from "node:child_process";
+import { PassThrough } from "node:stream";
+function defaultStdioSpawn(command, args, options) {
+  return spawn2(command, args, options);
+}
+function defaultHttpTransportFetch(input, init) {
+  return fetch(input, init);
+}
+function serializeJsonRpcMessage2(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+function chunkToString2(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  return String(chunk);
+}
+function normalizeLine2(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+async function* readLines2(stream) {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunkToString2(chunk);
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      yield normalizeLine2(line);
+    }
+  }
+  if (buffer.length > 0) {
+    yield normalizeLine2(buffer);
+  }
+}
+function isObjectRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn2(value, property) {
+  return Object.prototype.hasOwnProperty.call(value, property);
+}
+function isRequestId2(value) {
+  return typeof value === "string" || typeof value === "number";
+}
+function isLogLevel(value) {
+  return value === "debug" || value === "info" || value === "notice" || value === "warning" || value === "error" || value === "critical" || value === "alert" || value === "emergency";
+}
+function toRequestId2(value) {
+  return isRequestId2(value) ? value : null;
+}
+function parseError2() {
+  return new McpError(ERROR_PARSE, "Parse error");
+}
+function invalidRequest2() {
+  return new McpError(ERROR_INVALID_REQUEST, "Invalid Request");
+}
+function isJsonRpcErrorObject2(value) {
+  if (!isObjectRecord3(value)) {
+    return false;
+  }
+  if (typeof value.code !== "number" || typeof value.message !== "string") {
+    return false;
+  }
+  return value.data === void 0 || hasOwn2(value, "data");
+}
+function parseJsonRpcPayload(parsed) {
+  if (!isObjectRecord3(parsed)) {
+    return {
+      type: "invalid",
+      id: null,
+      error: invalidRequest2()
+    };
+  }
+  const id = toRequestId2(parsed.id);
+  if (parsed.jsonrpc !== "2.0") {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest2()
+    };
+  }
+  const hasMethod = hasOwn2(parsed, "method");
+  const hasId = hasOwn2(parsed, "id");
+  if (hasMethod) {
+    if (typeof parsed.method !== "string") {
+      return {
+        type: "invalid",
+        id,
+        error: invalidRequest2()
+      };
+    }
+    if (hasId) {
+      if (!isRequestId2(parsed.id)) {
+        return {
+          type: "invalid",
+          id: null,
+          error: invalidRequest2()
+        };
+      }
+      const request = {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        method: parsed.method
+      };
+      if (hasOwn2(parsed, "params")) {
+        request.params = parsed.params;
+      }
+      return {
+        type: "request",
+        message: request
+      };
+    }
+    const notification = {
+      jsonrpc: "2.0",
+      method: parsed.method
+    };
+    if (hasOwn2(parsed, "params")) {
+      notification.params = parsed.params;
+    }
+    return {
+      type: "notification",
+      message: notification
+    };
+  }
+  if (!hasId || !isRequestId2(parsed.id)) {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest2()
+    };
+  }
+  const hasResult = hasOwn2(parsed, "result");
+  const hasError = hasOwn2(parsed, "error");
+  if (hasResult === hasError) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest2()
+    };
+  }
+  if (hasResult) {
+    return {
+      type: "response",
+      message: {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        result: parsed.result
+      }
+    };
+  }
+  if (!isJsonRpcErrorObject2(parsed.error)) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest2()
+    };
+  }
+  return {
+    type: "response",
+    message: {
+      jsonrpc: "2.0",
+      id: parsed.id,
+      error: parsed.error
+    }
+  };
+}
+var MCP_PROTOCOL_VERSION, McpClient, ERROR_PARSE, ERROR_INVALID_REQUEST, ERROR_METHOD_NOT_FOUND, ERROR_INTERNAL, StdioTransport, HttpTransport, HttpTransportGetSseNotSupportedError, McpError, SseParser, JsonRpcMessageLayer2;
+var init_internal = __esm({
+  "packages/tiny-mcp-client/src/internal.ts"() {
+    "use strict";
+    MCP_PROTOCOL_VERSION = "2025-03-26";
+    McpClient = class {
+      currentState = "disconnected";
+      currentServerCapabilities = null;
+      currentServerInfo = null;
+      currentInstructions;
+      options;
+      transport = null;
+      messageLayer = null;
+      constructor(options) {
+        this.options = options;
+      }
+      get state() {
+        return this.currentState;
+      }
+      get serverCapabilities() {
+        return this.currentServerCapabilities;
+      }
+      get serverInfo() {
+        return this.currentServerInfo;
+      }
+      get instructions() {
+        return this.currentInstructions;
+      }
+      getMessageLayerOrThrow() {
+        if (this.currentState === "disconnected") {
+          throw new Error("MCP client is disconnected");
+        }
+        if (this.currentState === "closed") {
+          throw new Error("MCP client is closed");
+        }
+        if (this.messageLayer === null) {
+          throw new Error("MCP client is disconnected");
+        }
+        return this.messageLayer;
+      }
+      async connect(transport) {
+        if (this.currentState !== "disconnected" && this.currentState !== "closed") {
+          throw new Error("MCP client is already connected");
+        }
+        const transportClosedReason = transport.closed.then((closedEvent) => closedEvent.reason).catch(
+          (error) => error instanceof Error ? error : new Error(String(error))
+        );
+        const messageLayer = new JsonRpcMessageLayer2(
+          transport.readable,
+          transport.writable,
+          3e4,
+          transportClosedReason
+        );
+        const {
+          onSamplingRequest,
+          onRootsList,
+          onToolsChanged,
+          onResourcesChanged,
+          onResourceUpdated,
+          onPromptsChanged,
+          onLog,
+          onProgress
+        } = this.options;
+        messageLayer.onRequest("ping", () => ({}));
+        if (onSamplingRequest !== void 0) {
+          messageLayer.onRequest(
+            "sampling/createMessage",
+            (params) => onSamplingRequest(params)
+          );
+        }
+        if (onRootsList !== void 0) {
+          messageLayer.onRequest("roots/list", async () => ({
+            roots: await onRootsList()
+          }));
+        }
+        messageLayer.onNotification("notifications/tools/list_changed", async () => {
+          if (onToolsChanged === void 0) {
+            return;
+          }
+          await onToolsChanged();
+        });
+        messageLayer.onNotification("notifications/resources/list_changed", async () => {
+          if (onResourcesChanged === void 0) {
+            return;
+          }
+          await onResourcesChanged();
+        });
+        messageLayer.onNotification("notifications/resources/updated", async (params) => {
+          if (onResourceUpdated === void 0) {
+            return;
+          }
+          if (typeof params !== "object" || params === null || Array.isArray(params)) {
+            return;
+          }
+          const { uri } = params;
+          if (typeof uri !== "string") {
+            return;
+          }
+          await onResourceUpdated(uri);
+        });
+        messageLayer.onNotification("notifications/prompts/list_changed", async () => {
+          if (onPromptsChanged === void 0) {
+            return;
+          }
+          await onPromptsChanged();
+        });
+        messageLayer.onNotification("notifications/message", async (params) => {
+          if (onLog === void 0 || !isObjectRecord3(params) || !isLogLevel(params.level)) {
+            return;
+          }
+          if (!hasOwn2(params, "data")) {
+            return;
+          }
+          const message = {
+            level: params.level,
+            data: params.data
+          };
+          if (params.logger !== void 0) {
+            if (typeof params.logger !== "string") {
+              return;
+            }
+            message.logger = params.logger;
+          }
+          await onLog(message);
+        });
+        messageLayer.onNotification("notifications/progress", async (params) => {
+          if (onProgress === void 0 || !isObjectRecord3(params)) {
+            return;
+          }
+          const { progressToken, progress } = params;
+          if (!isRequestId2(progressToken) || typeof progress !== "number") {
+            return;
+          }
+          const progressParams = {
+            progressToken,
+            progress
+          };
+          if (params.total !== void 0) {
+            if (typeof params.total !== "number") {
+              return;
+            }
+            progressParams.total = params.total;
+          }
+          if (params.message !== void 0) {
+            if (typeof params.message !== "string") {
+              return;
+            }
+            progressParams.message = params.message;
+          }
+          await onProgress(progressParams);
+        });
+        messageLayer.onNotification("notifications/cancelled", () => void 0);
+        this.transport = transport;
+        this.messageLayer = messageLayer;
+        this.currentState = "initializing";
+        transport.closed.then((closedEvent) => {
+          if (this.transport !== transport) {
+            return;
+          }
+          this.messageLayer?.dispose(closedEvent.reason);
+          this.messageLayer = null;
+          this.transport = null;
+          this.currentState = "closed";
+        }).catch((error) => {
+          if (this.transport !== transport) {
+            return;
+          }
+          const reason = error instanceof Error ? error : new Error(String(error));
+          this.messageLayer?.dispose(reason);
+          this.messageLayer = null;
+          this.transport = null;
+          this.currentState = "closed";
+        });
+        const capabilities = {
+          ...this.options.capabilities ?? {}
+        };
+        if (onSamplingRequest !== void 0 && capabilities.sampling === void 0) {
+          capabilities.sampling = {};
+        }
+        if (onRootsList !== void 0) {
+          capabilities.roots = {
+            ...capabilities.roots ?? {}
+          };
+        }
+        const initializeResult = await messageLayer.sendRequest("initialize", {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          clientInfo: this.options.clientInfo,
+          capabilities
+        });
+        if (initializeResult.protocolVersion !== MCP_PROTOCOL_VERSION) {
+          throw new McpError(
+            ERROR_INVALID_REQUEST,
+            `Unsupported protocol version: ${initializeResult.protocolVersion}`
+          );
+        }
+        this.currentServerCapabilities = initializeResult.capabilities;
+        this.currentServerInfo = initializeResult.serverInfo;
+        this.currentInstructions = initializeResult.instructions;
+        messageLayer.sendNotification("notifications/initialized");
+        this.currentState = "ready";
+        return initializeResult;
+      }
+      getServerCapabilitiesOrThrow() {
+        if (this.currentServerCapabilities === null) {
+          throw new Error("MCP client has not completed initialization");
+        }
+        return this.currentServerCapabilities;
+      }
+      async listTools(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.tools === void 0) {
+          throw new Error("Server does not support tools");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("tools/list", requestParams);
+      }
+      async callTool(params, options = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.tools === void 0) {
+          throw new Error("Server does not support tools");
+        }
+        const requestParams = options.progressToken === void 0 ? params : {
+          ...params,
+          _meta: {
+            progressToken: options.progressToken
+          }
+        };
+        let requestId;
+        const requestPromise = messageLayer.sendRequest("tools/call", requestParams, {
+          onRequestId: (nextRequestId) => {
+            requestId = nextRequestId;
+          }
+        });
+        if (options.signal === void 0) {
+          return await requestPromise;
+        }
+        const signal = options.signal;
+        let abortListener;
+        const abortPromise = new Promise((_, reject) => {
+          const rejectWithAbortReason = () => {
+            if (requestId !== void 0) {
+              messageLayer.sendNotification("notifications/cancelled", { requestId });
+            }
+            reject(signal.reason);
+          };
+          abortListener = rejectWithAbortReason;
+          signal.addEventListener("abort", abortListener, { once: true });
+          if (signal.aborted) {
+            signal.removeEventListener("abort", abortListener);
+            rejectWithAbortReason();
+          }
+        });
+        try {
+          return await Promise.race([requestPromise, abortPromise]);
+        } finally {
+          if (abortListener !== void 0) {
+            signal.removeEventListener("abort", abortListener);
+          }
+        }
+      }
+      async listResources(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources === void 0) {
+          throw new Error("Server does not support resources");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("resources/list", requestParams);
+      }
+      async listResourceTemplates(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources === void 0) {
+          throw new Error("Server does not support resources");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("resources/templates/list", requestParams);
+      }
+      async readResource(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources === void 0) {
+          throw new Error("Server does not support resources");
+        }
+        return await messageLayer.sendRequest("resources/read", params);
+      }
+      async subscribe(uri) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources?.subscribe !== true) {
+          throw new Error("Server does not support resource subscriptions");
+        }
+        await messageLayer.sendRequest("resources/subscribe", { uri });
+      }
+      async unsubscribe(uri) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources?.subscribe !== true) {
+          throw new Error("Server does not support resource subscriptions");
+        }
+        await messageLayer.sendRequest("resources/unsubscribe", { uri });
+      }
+      async listPrompts(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.prompts === void 0) {
+          throw new Error("Server does not support prompts");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("prompts/list", requestParams);
+      }
+      async getPrompt(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.prompts === void 0) {
+          throw new Error("Server does not support prompts");
+        }
+        return await messageLayer.sendRequest("prompts/get", params);
+      }
+      async complete(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.completions === void 0) {
+          throw new Error("Server does not support completions");
+        }
+        return await messageLayer.sendRequest("completion/complete", params);
+      }
+      async setLogLevel(level) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.logging === void 0) {
+          throw new Error("Server does not support logging");
+        }
+        await messageLayer.sendRequest("logging/setLevel", { level });
+      }
+      async cancel(requestId, reason) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const params = { requestId };
+        if (reason !== void 0) {
+          params.reason = reason;
+        }
+        messageLayer.sendNotification("notifications/cancelled", params);
+      }
+      async sendRootsChanged() {
+        const messageLayer = this.getMessageLayerOrThrow();
+        messageLayer.sendNotification("notifications/roots/list_changed");
+      }
+      async ping() {
+        const messageLayer = this.getMessageLayerOrThrow();
+        await messageLayer.sendRequest("ping");
+      }
+      async close() {
+        if (this.currentState === "closed") {
+          return;
+        }
+        const closeError = new Error("MCP client closed");
+        this.messageLayer?.dispose(closeError);
+        this.transport?.dispose(closeError);
+        this.messageLayer = null;
+        this.transport = null;
+        this.currentState = "closed";
+      }
+    };
+    ERROR_PARSE = -32700;
+    ERROR_INVALID_REQUEST = -32600;
+    ERROR_METHOD_NOT_FOUND = -32601;
+    ERROR_INTERNAL = -32603;
+    StdioTransport = class _StdioTransport {
+      readable;
+      writable;
+      closed;
+      child;
+      disposed = false;
+      stderrOutput = "";
+      static STDERR_MAX_LENGTH = 65536;
+      constructor({
+        command,
+        args = [],
+        cwd,
+        env,
+        spawn: spawnProcess = defaultStdioSpawn
+      }) {
+        this.child = spawnProcess(command, args, {
+          cwd,
+          env,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const child = this.child;
+        this.readable = child.stdout;
+        this.writable = child.stdin;
+        child.stderr.on("data", (chunk) => {
+          this.stderrOutput += chunkToString2(chunk);
+          if (this.stderrOutput.length > _StdioTransport.STDERR_MAX_LENGTH) {
+            this.stderrOutput = this.stderrOutput.slice(-_StdioTransport.STDERR_MAX_LENGTH);
+          }
+        });
+        this.closed = new Promise((resolve) => {
+          let settled = false;
+          const resolveClosed = (event) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            resolve(event);
+          };
+          child.once("exit", (code, signal) => {
+            const closedEvent = {
+              reason: new Error("Stdio transport process exited")
+            };
+            if (code !== null) {
+              closedEvent.code = code;
+            }
+            if (signal !== null) {
+              closedEvent.signal = signal;
+            }
+            resolveClosed(closedEvent);
+          });
+          child.once("error", (error) => {
+            const closedEvent = {
+              reason: error instanceof Error ? error : new Error(String(error))
+            };
+            if (child.exitCode !== null) {
+              closedEvent.code = child.exitCode;
+            }
+            if (child.signalCode !== null) {
+              closedEvent.signal = child.signalCode;
+            }
+            resolveClosed(closedEvent);
+          });
+        });
+      }
+      getStderrOutput() {
+        return this.stderrOutput;
+      }
+      dispose(reason = new Error("Stdio transport disposed")) {
+        void reason;
+        if (this.disposed) {
+          return;
+        }
+        this.disposed = true;
+        if (!this.child.stdin.destroyed && !this.child.stdin.writableEnded) {
+          this.child.stdin.end();
+        }
+        if (this.child.exitCode === null && this.child.signalCode === null && !this.child.killed) {
+          this.child.kill("SIGTERM");
+        }
+      }
+    };
+    HttpTransport = class {
+      readable;
+      writable;
+      closed;
+      url;
+      headers;
+      fetchImpl;
+      readStream = new PassThrough();
+      writeStream = new PassThrough();
+      resolveClosed;
+      sessionId;
+      lastEventId;
+      getSseStreamStarted = false;
+      disposed = false;
+      inFlightFetchAbortControllers = /* @__PURE__ */ new Set();
+      openSseReaders = /* @__PURE__ */ new Set();
+      constructor({
+        url,
+        headers = {},
+        fetch: fetchImpl = defaultHttpTransportFetch
+      }) {
+        this.url = url;
+        this.headers = headers;
+        this.fetchImpl = fetchImpl;
+        this.readable = this.readStream;
+        this.writable = this.writeStream;
+        this.closed = new Promise((resolve) => {
+          this.resolveClosed = resolve;
+        });
+        this.readStream.once("error", (error) => {
+          this.dispose(error instanceof Error ? error : new Error(String(error)));
+        });
+        this.writeStream.once("error", (error) => {
+          this.dispose(error instanceof Error ? error : new Error(String(error)));
+        });
+        this.consumeWrittenLines().catch((error) => {
+          this.dispose(error instanceof Error ? error : new Error(String(error)));
+        });
+      }
+      dispose(reason = new Error("HTTP transport disposed")) {
+        if (this.disposed) {
+          return;
+        }
+        this.disposed = true;
+        this.abortInFlightFetches();
+        this.cancelOpenSseReaders();
+        this.terminateSession();
+        if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
+          this.writeStream.end();
+        }
+        if (!this.readStream.destroyed && !this.readStream.writableEnded) {
+          this.readStream.end();
+        }
+        const resolveClosed = this.resolveClosed;
+        this.resolveClosed = void 0;
+        resolveClosed?.({ reason });
+      }
+      abortInFlightFetches() {
+        for (const abortController of this.inFlightFetchAbortControllers) {
+          abortController.abort();
+        }
+        this.inFlightFetchAbortControllers.clear();
+      }
+      cancelOpenSseReaders() {
+        for (const reader of this.openSseReaders) {
+          void reader.cancel().catch(() => void 0);
+        }
+        this.openSseReaders.clear();
+      }
+      async fetchWithAbort(input, init) {
+        const abortController = new AbortController();
+        this.inFlightFetchAbortControllers.add(abortController);
+        try {
+          return await this.fetchImpl(input, {
+            ...init,
+            signal: abortController.signal
+          });
+        } finally {
+          this.inFlightFetchAbortControllers.delete(abortController);
+        }
+      }
+      async consumeWrittenLines() {
+        for await (const line of readLines2(this.writeStream)) {
+          if (this.disposed || line.length === 0) {
+            continue;
+          }
+          const hasSessionId = this.sessionId !== void 0;
+          const response = await this.fetchWithAbort(this.url, {
+            method: "POST",
+            headers: this.createPostHeaders(),
+            body: line
+          });
+          if (hasSessionId && response.status === 404) {
+            this.sessionId = void 0;
+            this.dispose(new Error("HTTP transport session expired (404 response)"));
+            return;
+          }
+          await this.throwForPostHttpError(response);
+          this.captureSessionId(response);
+          this.maybeOpenGetSseStream();
+          await this.forwardResponseMessages(response);
+        }
+      }
+      createPostHeaders() {
+        const headers = new Headers(this.headers);
+        headers.set("Accept", "application/json, text/event-stream");
+        headers.set("Content-Type", "application/json");
+        if (this.sessionId !== void 0) {
+          headers.set("Mcp-Session-Id", this.sessionId);
+        }
+        return headers;
+      }
+      createGetHeaders() {
+        const headers = new Headers(this.headers);
+        headers.set("Accept", "text/event-stream");
+        if (this.sessionId !== void 0) {
+          headers.set("Mcp-Session-Id", this.sessionId);
+        }
+        if (this.lastEventId !== void 0) {
+          headers.set("Last-Event-ID", this.lastEventId);
+        }
+        return headers;
+      }
+      createDeleteHeaders(sessionId) {
+        const headers = new Headers(this.headers);
+        headers.set("Mcp-Session-Id", sessionId);
+        return headers;
+      }
+      captureSessionId(response) {
+        const sessionId = response.headers.get("Mcp-Session-Id");
+        if (sessionId === null || sessionId.length === 0) {
+          return;
+        }
+        this.sessionId = sessionId;
+      }
+      maybeOpenGetSseStream() {
+        if (this.disposed || this.sessionId === void 0 || this.getSseStreamStarted) {
+          return;
+        }
+        this.getSseStreamStarted = true;
+        this.consumeGetSseStream().catch((error) => {
+          if (error instanceof HttpTransportGetSseNotSupportedError || this.disposed) {
+            return;
+          }
+          this.dispose(error instanceof Error ? error : new Error(String(error)));
+        });
+      }
+      terminateSession() {
+        if (this.sessionId === void 0) {
+          return;
+        }
+        const sessionId = this.sessionId;
+        this.sessionId = void 0;
+        this.sendSessionTerminationRequest(sessionId).catch(() => void 0);
+      }
+      async sendSessionTerminationRequest(sessionId) {
+        const response = await this.fetchImpl(this.url, {
+          method: "DELETE",
+          headers: this.createDeleteHeaders(sessionId)
+        });
+        if (response.status === 405) {
+          return;
+        }
+      }
+      async consumeGetSseStream() {
+        const response = await this.fetchWithAbort(this.url, {
+          method: "GET",
+          headers: this.createGetHeaders()
+        });
+        if (response.status === 405) {
+          throw new HttpTransportGetSseNotSupportedError();
+        }
+        const contentType = response.headers.get("Content-Type");
+        if (contentType === null) {
+          return;
+        }
+        if (contentType.toLowerCase().includes("text/event-stream")) {
+          await this.forwardSseResponseMessages(response);
+          this.getSseStreamStarted = false;
+          if (!this.disposed && this.sessionId !== void 0 && this.lastEventId !== void 0) {
+            this.maybeOpenGetSseStream();
+          }
+        }
+      }
+      async throwForPostHttpError(response) {
+        if (response.status < 400) {
+          return;
+        }
+        const responseBody = (await response.text()).trim();
+        const statusDescriptor = `${response.status} ${response.statusText}`.trim();
+        const message = responseBody.length === 0 ? `HTTP transport POST failed (${statusDescriptor})` : `HTTP transport POST failed (${statusDescriptor}): ${responseBody}`;
+        throw new Error(message);
+      }
+      async forwardResponseMessages(response) {
+        if (response.status === 202) {
+          return;
+        }
+        const contentType = response.headers.get("Content-Type");
+        if (contentType === null) {
+          return;
+        }
+        const normalizedContentType = contentType.toLowerCase();
+        if (normalizedContentType.includes("text/event-stream")) {
+          await this.forwardSseResponseMessages(response);
+          return;
+        }
+        if (normalizedContentType.includes("application/json")) {
+          await this.forwardJsonResponseMessage(response);
+        }
+      }
+      async forwardSseResponseMessages(response) {
+        if (response.body === null) {
+          return;
+        }
+        const parser = new SseParser();
+        const decoder = new TextDecoder();
+        const reader = response.body.getReader();
+        this.openSseReaders.add(reader);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            if (value === void 0) {
+              continue;
+            }
+            const messages = parser.push(decoder.decode(value, { stream: true }));
+            this.writeSseMessages(messages);
+            this.lastEventId = parser.lastEventId;
+          }
+          const trailingChunk = decoder.decode();
+          if (trailingChunk.length > 0) {
+            this.writeSseMessages(parser.push(trailingChunk));
+            this.lastEventId = parser.lastEventId;
+          }
+          this.writeSseMessages(parser.flush());
+          this.lastEventId = parser.lastEventId;
+        } finally {
+          this.openSseReaders.delete(reader);
+          reader.releaseLock();
+        }
+      }
+      async forwardJsonResponseMessage(response) {
+        const payload = await response.text();
+        if (payload.length === 0) {
+          return;
+        }
+        const parsedPayload = JSON.parse(payload);
+        this.writeReadableLine(JSON.stringify(parsedPayload));
+      }
+      writeSseMessages(messages) {
+        for (const message of messages) {
+          this.writeReadableLine(message.data);
+        }
+      }
+      writeReadableLine(line) {
+        if (this.disposed || this.readStream.destroyed || this.readStream.writableEnded) {
+          return;
+        }
+        this.readStream.write(`${line}
+`);
+      }
+    };
+    HttpTransportGetSseNotSupportedError = class extends Error {
+      constructor() {
+        super("HTTP transport server does not support GET SSE streams");
+      }
+    };
+    McpError = class extends Error {
+      code;
+      constructor(code, message, data) {
+        super(message);
+        this.name = "McpError";
+        this.code = code;
+        if (data !== void 0) {
+          this.data = data;
+        }
+      }
+    };
+    SseParser = class {
+      buffer = "";
+      eventType;
+      dataLines = [];
+      eventId = "";
+      hasEventId = false;
+      _lastEventId;
+      get lastEventId() {
+        return this._lastEventId;
+      }
+      push(chunk) {
+        if (chunk.length === 0) {
+          return [];
+        }
+        this.buffer += chunk;
+        const messages = [];
+        while (true) {
+          const newlineIndex = this.buffer.indexOf("\n");
+          if (newlineIndex === -1) {
+            break;
+          }
+          const line = normalizeLine2(this.buffer.slice(0, newlineIndex));
+          this.buffer = this.buffer.slice(newlineIndex + 1);
+          this.consumeLine(line, messages);
+        }
+        return messages;
+      }
+      flush() {
+        const messages = [];
+        if (this.buffer.length > 0) {
+          this.consumeLine(normalizeLine2(this.buffer), messages);
+          this.buffer = "";
+        }
+        this.emitEvent(messages);
+        return messages;
+      }
+      consumeLine(line, messages) {
+        if (line.length === 0) {
+          this.emitEvent(messages);
+          return;
+        }
+        if (line.startsWith(":")) {
+          return;
+        }
+        const separatorIndex = line.indexOf(":");
+        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+        const rawValue = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1);
+        const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+        if (field === "event") {
+          this.eventType = value;
+          return;
+        }
+        if (field === "data") {
+          this.dataLines.push(value);
+          return;
+        }
+        if (field === "id") {
+          if (value.includes("\0")) {
+            return;
+          }
+          this.eventId = value;
+          this.hasEventId = true;
+        }
+      }
+      emitEvent(messages) {
+        const eventType = this.eventType ?? "message";
+        if (this.hasEventId) {
+          this._lastEventId = this.eventId;
+        }
+        if (this.dataLines.length === 0 || eventType !== "message") {
+          this.resetEvent();
+          return;
+        }
+        const message = {
+          data: this.dataLines.join("\n")
+        };
+        if (this.hasEventId) {
+          message.id = this.eventId;
+        }
+        messages.push(message);
+        this.resetEvent();
+      }
+      resetEvent() {
+        this.eventType = void 0;
+        this.dataLines = [];
+        this.eventId = "";
+        this.hasEventId = false;
+      }
+    };
+    JsonRpcMessageLayer2 = class {
+      requestTimeoutMs;
+      input;
+      output;
+      inputClosedReason;
+      nextRequestId = 1;
+      disposedError;
+      pendingRequests = /* @__PURE__ */ new Map();
+      activeIncomingRequests = /* @__PURE__ */ new Map();
+      requestHandlers = /* @__PURE__ */ new Map();
+      notificationHandlers = /* @__PURE__ */ new Map();
+      constructor(input, output, requestTimeoutMs = 3e4, inputClosedReason) {
+        if (!Number.isFinite(requestTimeoutMs) || requestTimeoutMs < 0) {
+          throw new Error("requestTimeoutMs must be a non-negative finite number");
+        }
+        this.input = input;
+        this.output = output;
+        this.inputClosedReason = inputClosedReason;
+        this.requestTimeoutMs = requestTimeoutMs;
+        this.consumeInput().catch(() => void 0);
+      }
+      sendNotification(method, params) {
+        if (this.disposedError !== void 0) {
+          throw this.disposedError;
+        }
+        const message = {
+          jsonrpc: "2.0",
+          method
+        };
+        if (params !== void 0) {
+          message.params = params;
+        }
+        this.output.write(serializeJsonRpcMessage2(message));
+      }
+      onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+      }
+      onNotification(method, handler) {
+        this.notificationHandlers.set(method, handler);
+      }
+      sendRequest(method, params, options = {}) {
+        if (this.disposedError !== void 0) {
+          throw this.disposedError;
+        }
+        const id = this.nextRequestId;
+        this.nextRequestId += 1;
+        const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+          throw new Error("timeoutMs must be a non-negative finite number");
+        }
+        if (options.onRequestId !== void 0) {
+          options.onRequestId(id);
+        }
+        const message = {
+          jsonrpc: "2.0",
+          id,
+          method
+        };
+        if (params !== void 0) {
+          message.params = params;
+        }
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            this.pendingRequests.delete(id);
+            reject(new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          this.pendingRequests.set(id, { resolve, reject, timeout });
+          try {
+            this.output.write(serializeJsonRpcMessage2(message));
+          } catch (error) {
+            clearTimeout(timeout);
+            this.pendingRequests.delete(id);
+            reject(error);
+          }
+        });
+      }
+      dispose(reason = new Error("JSON-RPC message layer disposed")) {
+        if (this.disposedError !== void 0) {
+          return;
+        }
+        this.disposedError = reason;
+        for (const pending of this.pendingRequests.values()) {
+          clearTimeout(pending.timeout);
+          pending.reject(reason);
+        }
+        this.pendingRequests.clear();
+        this.activeIncomingRequests.clear();
+      }
+      async consumeInput() {
+        try {
+          for await (const line of readLines2(this.input)) {
+            if (this.disposedError !== void 0) {
+              break;
+            }
+            if (line.length === 0) {
+              continue;
+            }
+            let parsedLine;
+            try {
+              parsedLine = JSON.parse(line);
+            } catch {
+              await this.processParsedMessage({
+                type: "invalid",
+                id: null,
+                error: parseError2()
+              });
+              continue;
+            }
+            if (Array.isArray(parsedLine)) {
+              for (const message of parsedLine) {
+                if (this.disposedError !== void 0) {
+                  break;
+                }
+                await this.processParsedMessage(parseJsonRpcPayload(message));
+              }
+              continue;
+            }
+            await this.processParsedMessage(parseJsonRpcPayload(parsedLine));
+          }
+        } catch (error) {
+          if (this.disposedError === void 0) {
+            this.dispose(
+              error instanceof Error ? error : new Error(`JSON-RPC input stream failed: ${String(error)}`)
+            );
+          }
+          return;
+        }
+        if (this.disposedError === void 0) {
+          const streamClosedReason = await this.resolveInputStreamClosedReason();
+          if (this.disposedError === void 0) {
+            this.dispose(streamClosedReason);
+          }
+        }
+      }
+      async resolveInputStreamClosedReason() {
+        const streamClosedError = new Error("JSON-RPC input stream closed");
+        if (this.inputClosedReason === void 0) {
+          return streamClosedError;
+        }
+        try {
+          return await Promise.race([
+            this.inputClosedReason,
+            new Promise((resolve) => {
+              setTimeout(() => {
+                resolve(streamClosedError);
+              }, 50);
+            })
+          ]);
+        } catch {
+          return streamClosedError;
+        }
+      }
+      async processParsedMessage(parsed) {
+        if (parsed.type === "request") {
+          const handler = this.requestHandlers.get(parsed.message.method);
+          if (handler === void 0) {
+            this.output.write(
+              serializeJsonRpcMessage2({
+                jsonrpc: "2.0",
+                id: parsed.message.id,
+                error: {
+                  code: ERROR_METHOD_NOT_FOUND,
+                  message: `Method not found: ${parsed.message.method}`
+                }
+              })
+            );
+            return;
+          }
+          this.handleIncomingRequest(parsed.message, handler);
+          return;
+        }
+        if (parsed.type === "notification") {
+          if (parsed.message.method === "notifications/cancelled") {
+            this.handleCancellationNotification(parsed.message.params);
+          }
+          const handler = this.notificationHandlers.get(parsed.message.method);
+          if (handler === void 0) {
+            return;
+          }
+          try {
+            await handler(parsed.message.params, {
+              method: parsed.message.method
+            });
+          } catch {
+            return;
+          }
+          return;
+        }
+        if (parsed.type === "invalid") {
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: parsed.id,
+            error: {
+              code: parsed.error.code,
+              message: parsed.error.message
+            }
+          };
+          if (parsed.error.data !== void 0) {
+            errorResponse.error.data = parsed.error.data;
+          }
+          this.output.write(`${JSON.stringify(errorResponse)}
+`);
+          return;
+        }
+        if (parsed.type !== "response") {
+          return;
+        }
+        const pending = this.pendingRequests.get(parsed.message.id);
+        if (pending === void 0) {
+          return;
+        }
+        this.pendingRequests.delete(parsed.message.id);
+        clearTimeout(pending.timeout);
+        if ("result" in parsed.message) {
+          pending.resolve(parsed.message.result);
+          return;
+        }
+        pending.reject(
+          new McpError(
+            parsed.message.error.code,
+            parsed.message.error.message,
+            parsed.message.error.data
+          )
+        );
+      }
+      handleIncomingRequest(message, handler) {
+        const activeRequest = {
+          cancelled: false
+        };
+        this.activeIncomingRequests.set(message.id, activeRequest);
+        void (async () => {
+          try {
+            const result = await handler(message.params, {
+              id: message.id,
+              method: message.method
+            });
+            if (this.disposedError !== void 0 || activeRequest.cancelled) {
+              return;
+            }
+            this.output.write(
+              serializeJsonRpcMessage2({
+                jsonrpc: "2.0",
+                id: message.id,
+                result
+              })
+            );
+          } catch (error) {
+            if (this.disposedError !== void 0 || activeRequest.cancelled) {
+              return;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.output.write(
+              serializeJsonRpcMessage2({
+                jsonrpc: "2.0",
+                id: message.id,
+                error: {
+                  code: ERROR_INTERNAL,
+                  message: errorMessage
+                }
+              })
+            );
+          } finally {
+            const inFlightRequest = this.activeIncomingRequests.get(message.id);
+            if (inFlightRequest === activeRequest) {
+              this.activeIncomingRequests.delete(message.id);
+            }
+          }
+        })();
+      }
+      handleCancellationNotification(params) {
+        if (!isObjectRecord3(params)) {
+          return;
+        }
+        const requestId = params.requestId;
+        if (!isRequestId2(requestId)) {
+          return;
+        }
+        const activeRequest = this.activeIncomingRequests.get(requestId);
+        if (activeRequest === void 0) {
+          return;
+        }
+        activeRequest.cancelled = true;
+        this.activeIncomingRequests.delete(requestId);
+      }
+    };
+  }
+});
+
+// packages/tiny-mcp-client/src/index.ts
+var init_src2 = __esm({
+  "packages/tiny-mcp-client/src/index.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+
+// packages/poe-agent/src/mcp-tool-executor.ts
+function namespaceMcpToolName(serverName, toolName) {
+  return `mcp__${serverName}__${toolName}`;
+}
+function mcpToolToOpenAiTool(serverName, mcpTool) {
+  const parameters = {
+    type: "object",
+    properties: getInputSchemaProperties(mcpTool.inputSchema)
+  };
+  const required = getInputSchemaRequired(mcpTool.inputSchema);
+  if (required) {
+    parameters.required = required;
+  }
+  return {
+    type: "function",
+    function: {
+      name: namespaceMcpToolName(serverName, mcpTool.name),
+      description: mcpTool.description ?? "",
+      parameters
+    }
+  };
+}
+function callToolResultToString(result) {
+  const content = result.content.map(contentItemToString).join("\n");
+  if (result.isError) {
+    throw new Error(content);
+  }
+  return content;
+}
+function getInputSchemaProperties(inputSchema) {
+  const properties = inputSchema.properties;
+  return isObjectRecord4(properties) ? properties : {};
+}
+function getInputSchemaRequired(inputSchema) {
+  const required = inputSchema.required;
+  if (!Array.isArray(required) || required.some((value) => typeof value !== "string")) {
+    return void 0;
+  }
+  return required;
+}
+function contentItemToString(item) {
+  switch (item.type) {
+    case "text":
+      return item.text;
+    case "image":
+      return `[image: ${item.mimeType}]`;
+    case "audio":
+      return `[audio: ${item.mimeType}]`;
+    case "resource":
+      return resourceContentsToString(item.resource);
+  }
+}
+function resourceContentsToString(resource) {
+  if ("text" in resource) {
+    return resource.text;
+  }
+  return `[blob: ${resource.uri}]`;
+}
+function isObjectRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var McpToolExecutor;
+var init_mcp_tool_executor = __esm({
+  "packages/poe-agent/src/mcp-tool-executor.ts"() {
+    "use strict";
+    McpToolExecutor = class {
+      discoveredTools = [];
+      toolToClient = /* @__PURE__ */ new Map();
+      clients = /* @__PURE__ */ new Set();
+      disposed = false;
+      async addServer(serverName, client) {
+        this.clients.add(client);
+        let nextCursor;
+        while (true) {
+          const page = nextCursor === void 0 ? await client.listTools() : await client.listTools({ cursor: nextCursor });
+          for (const mcpTool of page.tools) {
+            const openAiTool = mcpToolToOpenAiTool(serverName, mcpTool);
+            this.discoveredTools.push(openAiTool);
+            this.toolToClient.set(openAiTool.function.name, {
+              client,
+              originalName: mcpTool.name
+            });
+          }
+          if (page.nextCursor === void 0) {
+            return;
+          }
+          nextCursor = page.nextCursor;
+        }
+      }
+      getAvailableTools() {
+        return [...this.discoveredTools];
+      }
+      async executeTool(name, args) {
+        if (this.disposed) {
+          throw new Error("MCP tool executor is disposed");
+        }
+        const registration = this.toolToClient.get(name);
+        if (!registration) {
+          throw new Error(`MCP tool not found: ${name}`);
+        }
+        const result = await registration.client.callTool({
+          name: registration.originalName,
+          arguments: args
+        });
+        return callToolResultToString(result);
+      }
+      async dispose() {
+        this.disposed = true;
+        const closeOperations = [];
+        for (const client of this.clients) {
+          if (client.close === void 0) {
+            continue;
+          }
+          closeOperations.push(client.close());
+        }
+        await Promise.allSettled(closeOperations);
+        this.clients.clear();
+      }
+    };
+  }
+});
+
+// packages/poe-agent/src/SYSTEM_PROMPT.md
+var SYSTEM_PROMPT_default;
+var init_SYSTEM_PROMPT = __esm({
+  "packages/poe-agent/src/SYSTEM_PROMPT.md"() {
+    SYSTEM_PROMPT_default = "You are a Poe agent, built by Poe \u2014 an interactive CLI tool that helps users with software engineering tasks.\n\n## Security\n\nAssist with defensive security only. Refuse malicious code, credential harvesting, or bulk crawling for secrets. Allow security analysis, detection rules, vulnerability explanations, and defensive tools.\n\nNever generate or guess URLs unless they help with programming. You may use URLs from user messages or local files.\n\n## Behavior\n\n- Be concise and direct. Minimize output tokens. Skip preamble and postamble.\n- Do what was asked \u2014 nothing more, nothing less.\n- Prefer editing existing files over creating new ones. Never create docs/READMEs unless asked.\n- Prioritize technical accuracy over validating beliefs. Disagree when necessary.\n- Read before you write.\n";
+  }
+});
+
 // packages/poe-agent/src/system-prompt.ts
-import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 async function loadSystemPrompt() {
-  return readFile(systemPromptUrl, "utf8");
+  return SYSTEM_PROMPT_default;
 }
-var systemPromptUrl;
 var init_system_prompt = __esm({
   "packages/poe-agent/src/system-prompt.ts"() {
     "use strict";
-    systemPromptUrl = new URL("./SYSTEM_PROMPT.md", import.meta.url);
+    init_SYSTEM_PROMPT();
   }
 });
 
@@ -1006,7 +2422,41 @@ async function createAgentSession(options = {}) {
     cwd: options.cwd,
     allowedPaths: options.allowedPaths
   });
-  const tools = toolExecutor.getAvailableTools();
+  const builtInTools = toolExecutor.getAvailableTools();
+  const builtInToolNames = new Set(builtInTools.map((tool) => tool.function.name));
+  let tools = builtInTools;
+  let chatToolExecutor = toolExecutor;
+  let mcpToolExecutor;
+  if (options.mcpServers !== void 0) {
+    const createdMcpToolExecutor = new McpToolExecutor();
+    mcpToolExecutor = createdMcpToolExecutor;
+    try {
+      for (const [serverName, serverDefinition] of Object.entries(options.mcpServers)) {
+        const mcpClient = new McpClient({
+          clientInfo: {
+            name: "poe-agent",
+            version: "0.0.1"
+          }
+        });
+        const transport = createMcpTransport(serverDefinition);
+        await mcpClient.connect(transport);
+        await createdMcpToolExecutor.addServer(serverName, mcpClient);
+      }
+    } catch (error) {
+      await createdMcpToolExecutor.dispose();
+      throw error;
+    }
+    const mcpTools = createdMcpToolExecutor.getAvailableTools();
+    tools = [...builtInTools, ...mcpTools];
+    chatToolExecutor = {
+      executeTool(name, args) {
+        if (builtInToolNames.has(name)) {
+          return toolExecutor.executeTool(name, args);
+        }
+        return createdMcpToolExecutor.executeTool(name, args);
+      }
+    };
+  }
   let currentOnSessionUpdate;
   const chatService = new PoeChatService({
     apiKey,
@@ -1014,7 +2464,7 @@ async function createAgentSession(options = {}) {
     baseUrl: options.baseUrl,
     fetch: options.fetch,
     systemPrompt,
-    toolExecutor,
+    toolExecutor: chatToolExecutor,
     maxToolCallIterations: options.maxToolCallIterations,
     onToolCall: (event) => {
       if (!currentOnSessionUpdate) return;
@@ -1052,12 +2502,32 @@ async function createAgentSession(options = {}) {
       disposed = true;
       chatService.clearConversationHistory();
       const disposableToolExecutor = toolExecutor;
+      const disposePromises = [];
       if (typeof disposableToolExecutor.dispose === "function") {
-        await disposableToolExecutor.dispose();
+        disposePromises.push(Promise.resolve(disposableToolExecutor.dispose()));
+      }
+      if (mcpToolExecutor) {
+        disposePromises.push(mcpToolExecutor.dispose());
+      }
+      if (disposePromises.length > 0) {
+        await Promise.all(disposePromises);
       }
     }
   };
 }
+function createMcpTransport(server) {
+  if (server.transport === "stdio") {
+    return new StdioTransport({
+      command: server.command,
+      args: server.args,
+      env: server.env
+    });
+  }
+  return new HttpTransport({
+    url: server.url,
+    headers: server.headers
+  });
+}
 async function resolveApiKey(explicitApiKey) {
   const normalizedExplicitApiKey = normalizeNonEmptyString(explicitApiKey);
   if (normalizedExplicitApiKey) {
@@ -1121,6 +2591,8 @@ var init_agent_session = __esm({
     "use strict";
     init_src();
     init_chat();
+    init_src2();
+    init_mcp_tool_executor();
     init_system_prompt();
     init_tool_executor();
   }
@@ -1131,7 +2603,7 @@ var src_exports = {};
 __export(src_exports, {
   createAgentSession: () => createAgentSession
 });
-var init_src2 = __esm({
+var init_src3 = __esm({
   "packages/poe-agent/src/index.ts"() {
     "use strict";
     init_agent_session();
@@ -1629,13 +3101,13 @@ var AcpTransport = class {
       env,
       requestTimeoutMs,
       firstRequestId,
-      spawn: spawn2 = spawnChildProcess
+      spawn: spawn3 = spawnChildProcess
     } = options;
     this.command = command;
     this.closed = new Promise((resolve) => {
       this.resolveClosed = resolve;
     });
-    this.child = spawn2(command, [...args], {
+    this.child = spawn3(command, [...args], {
       cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -3399,6 +4871,7 @@ function createProvider(opts) {
     branding: opts.branding,
     disabled: opts.disabled,
     supportsStdinPrompt: opts.supportsStdinPrompt,
+    supportsMcpSpawn: opts.supportsMcpSpawn,
     configurePrompts: opts.configurePrompts,
     postConfigureMessages: opts.postConfigureMessages,
     isolatedEnv: opts.isolatedEnv,
@@ -3501,6 +4974,18 @@ function createToolRenderState() {
     toolCallTitles: /* @__PURE__ */ new Map()
   };
 }
+function toAgentSessionMcpServers(servers) {
+  const mappedServers = {};
+  for (const [name, server] of Object.entries(servers)) {
+    mappedServers[name] = {
+      transport: "stdio",
+      command: server.command,
+      ...server.args && server.args.length > 0 ? { args: [...server.args] } : {},
+      ...server.env && Object.keys(server.env).length > 0 ? { env: { ...server.env } } : {}
+    };
+  }
+  return Object.keys(mappedServers).length > 0 ? mappedServers : void 0;
+}
 function toErrorMessage2(value) {
   if (value instanceof Error) {
     return value.message;
@@ -3725,6 +5210,7 @@ function createInMemoryAcpTransport(options) {
   const closedPromise = new Promise((resolve) => {
     resolveClosed = resolve;
   });
+  const sessionMcpServers = options.mcpServers ? toAgentSessionMcpServers(options.mcpServers) : void 0;
   const closeTransport = (reason) => {
     if (closed) {
       return;
@@ -3760,10 +5246,12 @@ function createInMemoryAcpTransport(options) {
       }
       if (method === "session/new") {
         const request = params;
-        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src3(), src_exports));
         const session = await createAgentSession2({
           model: options.model,
-          cwd: request.cwd || options.cwd
+          cwd: request.cwd || options.cwd,
+          ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+          ...sessionMcpServers ? { mcpServers: sessionMcpServers } : {}
         });
         const sessionId = `poe-agent-session-${sessionCounter + 1}`;
         sessionCounter += 1;
@@ -3834,7 +5322,9 @@ async function runPoeAgentAcpLifecycle(options) {
   let assistantText = "";
   const transport = createInMemoryAcpTransport({
     model: options.model,
-    cwd: options.cwd
+    cwd: options.cwd,
+    baseUrl: options.baseUrl,
+    mcpServers: options.mcpServers
   });
   const client = new AcpClient({ transport });
   try {
@@ -3888,6 +5378,8 @@ function spawnPoeAgentWithAcp(options) {
     prompt: options.prompt,
     model,
     cwd,
+    baseUrl: options.baseUrl,
+    mcpServers: options.mcpServers,
     onEvent: (event) => {
       queue.push(event);
     }
@@ -3905,6 +5397,7 @@ var poeAgentService = createProvider({
   label: "Poe Agent",
   summary: "Run one-shot prompts with the built-in Poe agent runtime.",
   supportsStdinPrompt: true,
+  supportsMcpSpawn: true,
   manifest: {
     configure: []
   },
@@ -3912,7 +5405,9 @@ var poeAgentService = createProvider({
     const result = await runPoeAgentAcpLifecycle({
       prompt: options.prompt,
       model: options.model ?? DEFAULT_FRONTIER_MODEL,
-      cwd: options.cwd ?? context.env.cwd
+      cwd: options.cwd ?? context.env.cwd,
+      baseUrl: context.env.poeApiBaseUrl,
+      mcpServers: options.mcpServers
     });
     return {
       stdout: result.stdout,