poe-code 3.0.72-beta.2 → 3.0.73

package/dist/providers/poe-agent.js

@@ -0,0 +1,3930 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/templates/python/env.hbs
+var require_env = __commonJS({
+  "src/templates/python/env.hbs"(exports, module) {
+    module.exports = "POE_API_KEY={{apiKey}}\nPOE_BASE_URL=https://api.poe.com/v1\nMODEL={{model}}\n";
+  }
+});
+
+// src/templates/python/main.py.hbs
+var require_main_py = __commonJS({
+  "src/templates/python/main.py.hbs"(exports, module) {
+    module.exports = 'import os\nfrom openai import OpenAI\nfrom dotenv import load_dotenv\n\nload_dotenv()\n\nclient = OpenAI(\n    api_key=os.getenv("POE_API_KEY"),\n    base_url=os.getenv("POE_BASE_URL")\n)\n\nresponse = client.chat.completions.create(\n    model=os.getenv("MODEL", "{{model}}"),\n    messages=[{"role": "user", "content": "Tell me a joke"}]\n)\n\nprint(response.choices[0].message.content)\n';
+  }
+});
+
+// src/templates/python/requirements.txt.hbs
+var require_requirements_txt = __commonJS({
+  "src/templates/python/requirements.txt.hbs"(exports, module) {
+    module.exports = "openai>=1.0.0\npython-dotenv>=1.0.0\n";
+  }
+});
+
+// src/templates/codex/config.toml.hbs
+var require_config_toml = __commonJS({
+  "src/templates/codex/config.toml.hbs"(exports, module) {
+    module.exports = 'model_provider = "poe"\nmodel = "{{{model}}}"\nmodel_reasoning_effort = "{{reasoningEffort}}"\nmodel_verbosity = "medium"\n\n[model_providers.poe]\nname = "poe"\nbase_url = "{{{baseUrl}}}"\nwire_api = "responses"\nexperimental_bearer_token = "{{apiKey}}"\n';
+  }
+});
+
+// packages/auth/src/encrypted-file-auth-store.ts
+import { createCipheriv, createDecipheriv, randomBytes, scrypt } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { homedir as homedir2, hostname, userInfo } from "node:os";
+import path2 from "node:path";
+function defaultMachineIdentity() {
+  return {
+    hostname: hostname(),
+    username: userInfo().username
+  };
+}
+async function deriveEncryptionKey(getMachineIdentity) {
+  const machineIdentity = await getMachineIdentity();
+  const secret = `${machineIdentity.hostname}:${machineIdentity.username}`;
+  return await new Promise((resolve, reject) => {
+    scrypt(secret, ENCRYPTION_SALT, ENCRYPTION_KEY_BYTES, (error, derivedKey) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(Buffer.from(derivedKey));
+    });
+  });
+}
+function parseEncryptedDocument(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) {
+      return null;
+    }
+    if (parsed.version !== ENCRYPTION_VERSION) {
+      return null;
+    }
+    if (typeof parsed.iv !== "string" || typeof parsed.authTag !== "string" || typeof parsed.ciphertext !== "string") {
+      return null;
+    }
+    return {
+      version: parsed.version,
+      iv: parsed.iv,
+      authTag: parsed.authTag,
+      ciphertext: parsed.ciphertext
+    };
+  } catch {
+    return null;
+  }
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isNotFoundError(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+var ENCRYPTION_ALGORITHM, ENCRYPTION_VERSION, ENCRYPTION_KEY_BYTES, ENCRYPTION_IV_BYTES, ENCRYPTION_AUTH_TAG_BYTES, ENCRYPTION_SALT, ENCRYPTION_FILE_MODE, EncryptedFileAuthStore;
+var init_encrypted_file_auth_store = __esm({
+  "packages/auth/src/encrypted-file-auth-store.ts"() {
+    "use strict";
+    ENCRYPTION_ALGORITHM = "aes-256-gcm";
+    ENCRYPTION_VERSION = 1;
+    ENCRYPTION_KEY_BYTES = 32;
+    ENCRYPTION_IV_BYTES = 12;
+    ENCRYPTION_AUTH_TAG_BYTES = 16;
+    ENCRYPTION_SALT = "poe-code:encrypted-file-auth-store:v1";
+    ENCRYPTION_FILE_MODE = 384;
+    EncryptedFileAuthStore = class {
+      fs;
+      filePath;
+      getMachineIdentity;
+      getRandomBytes;
+      keyPromise = null;
+      constructor(input = {}) {
+        this.fs = input.fs ?? fs;
+        this.filePath = input.filePath ?? path2.join(
+          (input.getHomeDirectory ?? homedir2)(),
+          ".poe-code",
+          "credentials.enc"
+        );
+        this.getMachineIdentity = input.getMachineIdentity ?? defaultMachineIdentity;
+        this.getRandomBytes = input.getRandomBytes ?? randomBytes;
+      }
+      async getApiKey() {
+        let rawDocument;
+        try {
+          rawDocument = await this.fs.readFile(this.filePath, "utf8");
+        } catch (error) {
+          if (isNotFoundError(error)) {
+            return null;
+          }
+          throw error;
+        }
+        const document = parseEncryptedDocument(rawDocument);
+        if (!document) {
+          return null;
+        }
+        const key = await this.getEncryptionKey();
+        try {
+          const iv = Buffer.from(document.iv, "base64");
+          const authTag = Buffer.from(document.authTag, "base64");
+          const ciphertext = Buffer.from(document.ciphertext, "base64");
+          if (iv.byteLength !== ENCRYPTION_IV_BYTES || authTag.byteLength !== ENCRYPTION_AUTH_TAG_BYTES) {
+            return null;
+          }
+          const decipher = createDecipheriv(ENCRYPTION_ALGORITHM, key, iv);
+          decipher.setAuthTag(authTag);
+          const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+          return plaintext.toString("utf8");
+        } catch {
+          return null;
+        }
+      }
+      async setApiKey(apiKey) {
+        const key = await this.getEncryptionKey();
+        const iv = this.getRandomBytes(ENCRYPTION_IV_BYTES);
+        const cipher = createCipheriv(ENCRYPTION_ALGORITHM, key, iv);
+        const ciphertext = Buffer.concat([
+          cipher.update(apiKey, "utf8"),
+          cipher.final()
+        ]);
+        const authTag = cipher.getAuthTag();
+        const document = {
+          version: ENCRYPTION_VERSION,
+          iv: iv.toString("base64"),
+          authTag: authTag.toString("base64"),
+          ciphertext: ciphertext.toString("base64")
+        };
+        await this.fs.mkdir(path2.dirname(this.filePath), { recursive: true });
+        await this.fs.writeFile(this.filePath, JSON.stringify(document), {
+          encoding: "utf8"
+        });
+        await this.fs.chmod(this.filePath, ENCRYPTION_FILE_MODE);
+      }
+      async deleteApiKey() {
+        try {
+          await this.fs.unlink(this.filePath);
+        } catch (error) {
+          if (!isNotFoundError(error)) {
+            throw error;
+          }
+        }
+      }
+      getEncryptionKey() {
+        if (!this.keyPromise) {
+          this.keyPromise = deriveEncryptionKey(this.getMachineIdentity);
+        }
+        return this.keyPromise;
+      }
+    };
+  }
+});
+
+// packages/auth/src/keychain-auth-store.ts
+import { spawn } from "node:child_process";
+function runSecurityCommand(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+      resolve({
+        stdout,
+        stderr: stderr ? `${stderr}${message}` : message,
+        exitCode: 127
+      });
+    });
+    child.on("close", (code) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 0
+      });
+    });
+  });
+}
+function stripTrailingLineBreak(value) {
+  if (value.endsWith("\r\n")) {
+    return value.slice(0, -2);
+  }
+  if (value.endsWith("\n") || value.endsWith("\r")) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function isKeychainEntryNotFound(result) {
+  if (result.exitCode === KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE) {
+    return true;
+  }
+  const output = `${result.stderr}
+${result.stdout}`.toLowerCase();
+  return output.includes("could not be found") || output.includes("item not found") || output.includes("errsecitemnotfound");
+}
+function createSecurityCliFailure(operation, result) {
+  const details = result.stderr.trim() || result.stdout.trim();
+  if (details) {
+    return new Error(
+      `Failed to ${operation}: security exited with code ${result.exitCode}: ${details}`
+    );
+  }
+  return new Error(`Failed to ${operation}: security exited with code ${result.exitCode}`);
+}
+var SECURITY_CLI, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE, KeychainAuthStore;
+var init_keychain_auth_store = __esm({
+  "packages/auth/src/keychain-auth-store.ts"() {
+    "use strict";
+    SECURITY_CLI = "security";
+    KEYCHAIN_SERVICE = "poe-code";
+    KEYCHAIN_ACCOUNT = "api-key";
+    KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE = 44;
+    KeychainAuthStore = class {
+      runCommand;
+      service;
+      account;
+      constructor(input = {}) {
+        this.runCommand = input.runCommand ?? runSecurityCommand;
+        this.service = input.service ?? KEYCHAIN_SERVICE;
+        this.account = input.account ?? KEYCHAIN_ACCOUNT;
+      }
+      async getApiKey() {
+        const result = await this.executeSecurityCommand(
+          ["find-generic-password", "-s", this.service, "-a", this.account, "-w"],
+          "read API key from macOS Keychain"
+        );
+        if (result.exitCode === 0) {
+          return stripTrailingLineBreak(result.stdout);
+        }
+        if (isKeychainEntryNotFound(result)) {
+          return null;
+        }
+        throw createSecurityCliFailure("read API key from macOS Keychain", result);
+      }
+      async setApiKey(apiKey) {
+        const result = await this.executeSecurityCommand(
+          [
+            "add-generic-password",
+            "-s",
+            this.service,
+            "-a",
+            this.account,
+            "-w",
+            apiKey,
+            "-U"
+          ],
+          "store API key in macOS Keychain"
+        );
+        if (result.exitCode !== 0) {
+          throw createSecurityCliFailure("store API key in macOS Keychain", result);
+        }
+      }
+      async deleteApiKey() {
+        const result = await this.executeSecurityCommand(
+          ["delete-generic-password", "-s", this.service, "-a", this.account],
+          "delete API key from macOS Keychain"
+        );
+        if (result.exitCode === 0 || isKeychainEntryNotFound(result)) {
+          return;
+        }
+        throw createSecurityCliFailure("delete API key from macOS Keychain", result);
+      }
+      async executeSecurityCommand(args, operation) {
+        try {
+          return await this.runCommand(SECURITY_CLI, args);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new Error(`Failed to ${operation}: ${message}`);
+        }
+      }
+    };
+  }
+});
+
+// packages/auth/src/create-auth-store.ts
+import { promises as nodeFs } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import path3 from "node:path";
+function createAuthStore(input = {}) {
+  const backend = resolveBackend(input);
+  const platform = input.platform ?? process.platform;
+  if (backend === "keychain" && platform !== MACOS_PLATFORM) {
+    throw new Error(
+      `POE_AUTH_BACKEND=keychain is only supported on macOS. Current platform: ${platform}`
+    );
+  }
+  const store = authStoreFactories[backend](input);
+  return {
+    backend,
+    store: enableLegacyCredentialsMigration(store, input)
+  };
+}
+function resolveBackend(input) {
+  const configuredBackend = input.backend ?? input.env?.[AUTH_BACKEND_ENV_VAR] ?? process.env[AUTH_BACKEND_ENV_VAR];
+  if (configuredBackend === "keychain") {
+    return "keychain";
+  }
+  return "file";
+}
+function enableLegacyCredentialsMigration(store, input) {
+  const migrationContext = createLegacyMigrationContext(input);
+  const readApiKeyFromStore = store.getApiKey.bind(store);
+  let hasCheckedLegacyCredentials = false;
+  let legacyMigrationPromise = null;
+  store.getApiKey = async () => {
+    const storedApiKey = await readApiKeyFromStore();
+    if (isNonEmptyString(storedApiKey)) {
+      return storedApiKey;
+    }
+    if (hasCheckedLegacyCredentials) {
+      return null;
+    }
+    if (!legacyMigrationPromise) {
+      legacyMigrationPromise = migrateLegacyApiKey(store, migrationContext).finally(() => {
+        hasCheckedLegacyCredentials = true;
+        legacyMigrationPromise = null;
+      });
+    }
+    return legacyMigrationPromise;
+  };
+  return store;
+}
+async function migrateLegacyApiKey(store, migrationContext) {
+  const legacyCredentials = await loadLegacyCredentials(
+    migrationContext.fs,
+    migrationContext.filePath
+  );
+  if (!legacyCredentials || !isNonEmptyString(legacyCredentials.apiKey)) {
+    return null;
+  }
+  const plaintextApiKey = legacyCredentials.apiKey;
+  try {
+    await store.setApiKey(plaintextApiKey);
+    delete legacyCredentials.apiKey;
+    await saveLegacyCredentials(
+      migrationContext.fs,
+      migrationContext.filePath,
+      legacyCredentials
+    );
+  } catch (error) {
+    migrationContext.logWarning(
+      `Failed to migrate plaintext API key from ${migrationContext.filePath}.`,
+      error
+    );
+  }
+  return plaintextApiKey;
+}
+function createLegacyMigrationContext(input) {
+  const legacyCredentialsInput = input.legacyCredentials;
+  const getHomeDirectory = legacyCredentialsInput?.getHomeDirectory ?? homedir3;
+  return {
+    fs: legacyCredentialsInput?.fs ?? input.fileStore?.fs ?? nodeFs,
+    filePath: legacyCredentialsInput?.filePath ?? path3.join(
+      getHomeDirectory(),
+      LEGACY_CREDENTIALS_RELATIVE_PATH
+    ),
+    logWarning: legacyCredentialsInput?.logWarning ?? defaultMigrationWarning
+  };
+}
+async function loadLegacyCredentials(fs2, filePath) {
+  let raw;
+  try {
+    raw = await fs2.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      return null;
+    }
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveLegacyCredentials(fs2, filePath, document) {
+  await fs2.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs2.writeFile(filePath, `${JSON.stringify(document, null, 2)}
+`, {
+    encoding: "utf8"
+  });
+}
+function defaultMigrationWarning(message, error) {
+  const details = toErrorDetails(error);
+  if (details.length > 0) {
+    console.warn(`${message} ${details}`);
+    return;
+  }
+  console.warn(message);
+}
+function toErrorDetails(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return typeof error === "string" ? error : "";
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isNotFoundError2(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+var AUTH_BACKEND_ENV_VAR, MACOS_PLATFORM, LEGACY_CREDENTIALS_RELATIVE_PATH, authStoreFactories;
+var init_create_auth_store = __esm({
+  "packages/auth/src/create-auth-store.ts"() {
+    "use strict";
+    init_encrypted_file_auth_store();
+    init_keychain_auth_store();
+    AUTH_BACKEND_ENV_VAR = "POE_AUTH_BACKEND";
+    MACOS_PLATFORM = "darwin";
+    LEGACY_CREDENTIALS_RELATIVE_PATH = ".poe-code/credentials.json";
+    authStoreFactories = {
+      file: (input) => new EncryptedFileAuthStore(input.fileStore),
+      keychain: (input) => new KeychainAuthStore(input.keychainStore)
+    };
+  }
+});
+
+// packages/auth/src/index.ts
+var init_src = __esm({
+  "packages/auth/src/index.ts"() {
+    "use strict";
+    init_create_auth_store();
+    init_encrypted_file_auth_store();
+    init_keychain_auth_store();
+  }
+});
+
+// packages/poe-agent/src/chat.ts
+function toChatCompletionsUrl(baseUrl) {
+  const trimmedBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  if (trimmedBaseUrl.endsWith("/v1")) {
+    return `${trimmedBaseUrl}/chat/completions`;
+  }
+  return `${trimmedBaseUrl}/v1/chat/completions`;
+}
+function parseToolArguments(rawArguments) {
+  const parsed = JSON.parse(rawArguments);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Tool call arguments must be a JSON object");
+  }
+  return parsed;
+}
+async function readResponseText(response) {
+  try {
+    const text = await response.text();
+    return text.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var PoeChatService;
+var init_chat = __esm({
+  "packages/poe-agent/src/chat.ts"() {
+    "use strict";
+    PoeChatService = class {
+      apiKey;
+      model;
+      fetchFn;
+      chatCompletionsUrl;
+      toolExecutor;
+      maxToolCallIterations;
+      conversationHistory = [];
+      toolCallCallback;
+      constructor(options) {
+        this.apiKey = options.apiKey;
+        this.model = options.model;
+        this.fetchFn = options.fetch ?? globalThis.fetch;
+        this.chatCompletionsUrl = toChatCompletionsUrl(options.baseUrl ?? "https://api.poe.com");
+        this.toolExecutor = options.toolExecutor;
+        this.toolCallCallback = options.onToolCall;
+        this.maxToolCallIterations = options.maxToolCallIterations ?? 100;
+        if (options.systemPrompt) {
+          this.conversationHistory.push({
+            role: "system",
+            content: options.systemPrompt
+          });
+        }
+      }
+      clearConversationHistory() {
+        this.conversationHistory = [];
+      }
+      async sendMessage(userMessage, options) {
+        this.conversationHistory.push({
+          role: "user",
+          content: userMessage
+        });
+        let iterationCount = 0;
+        while (iterationCount < this.maxToolCallIterations) {
+          const response = await this.requestCompletion(options?.tools, options?.signal);
+          const assistantMessage = response.choices[0]?.message;
+          if (!assistantMessage) {
+            throw new Error("Poe API response did not include an assistant message");
+          }
+          this.conversationHistory.push(assistantMessage);
+          const hasToolCalls = assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0 && this.toolExecutor;
+          if (!hasToolCalls) {
+            return assistantMessage;
+          }
+          await this.executeToolCalls(assistantMessage.tool_calls);
+          iterationCount += 1;
+        }
+        throw new Error("Maximum tool call iterations reached");
+      }
+      async requestCompletion(tools, signal) {
+        const requestBody = {
+          model: this.model,
+          messages: this.conversationHistory
+        };
+        if (tools && tools.length > 0) {
+          requestBody.tools = tools;
+        }
+        const response = await this.fetchFn(this.chatCompletionsUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(requestBody),
+          signal
+        });
+        if (!response.ok) {
+          const errorBody = await readResponseText(response);
+          const details = errorBody || response.statusText || "Unknown error";
+          throw new Error(`Poe API request failed (${response.status}): ${details}`);
+        }
+        const payload = await response.json();
+        if (!Array.isArray(payload.choices)) {
+          throw new Error("Poe API response had invalid choices payload");
+        }
+        return payload;
+      }
+      async executeToolCalls(toolCalls) {
+        if (!this.toolExecutor) {
+          return;
+        }
+        for (const toolCall of toolCalls) {
+          let args = {};
+          try {
+            args = parseToolArguments(toolCall.function.arguments);
+            this.emitToolCallEvent({
+              phase: "started",
+              toolCallId: toolCall.id,
+              toolName: toolCall.function.name,
+              args
+            });
+            const result = await this.toolExecutor.executeTool(toolCall.function.name, args);
+            this.emitToolCallEvent({
+              phase: "completed",
+              toolCallId: toolCall.id,
+              toolName: toolCall.function.name,
+              args,
+              result
+            });
+            this.conversationHistory.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
+              content: result
+            });
+          } catch (error) {
+            const message = getErrorMessage(error);
+            this.emitToolCallEvent({
+              phase: "failed",
+              toolCallId: toolCall.id,
+              toolName: toolCall.function.name,
+              args,
+              error: message
+            });
+            this.conversationHistory.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
+              content: `Error: ${message}`
+            });
+          }
+        }
+      }
+      emitToolCallEvent(event) {
+        if (this.toolCallCallback) {
+          this.toolCallCallback(event);
+        }
+      }
+    };
+  }
+});
+
+// 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");
+}
+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);
+  }
+});
+
+// packages/poe-agent/src/tool-executor.ts
+import { exec as execCallback } from "node:child_process";
+import fsPromises2 from "node:fs/promises";
+import path4 from "node:path";
+import { promisify } from "node:util";
+function getRequiredString(args, key, allowEmptyString = false) {
+  const value = args[key];
+  if (typeof value !== "string") {
+    throw new Error(`Tool argument "${key}" must be a string`);
+  }
+  if (!allowEmptyString && value.trim().length === 0) {
+    throw new Error(`Tool argument "${key}" must not be empty`);
+  }
+  return value;
+}
+function getOptionalString(args, key) {
+  const value = args[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Tool argument "${key}" must be a string`);
+  }
+  return value;
+}
+function countOccurrences(text, search) {
+  let count = 0;
+  let index = 0;
+  while ((index = text.indexOf(search, index)) !== -1) {
+    count++;
+    index += search.length;
+  }
+  return count;
+}
+async function defaultRunCommand(command, cwd) {
+  try {
+    const result = await exec(command, {
+      cwd,
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024
+    });
+    const combinedOutput = [result.stdout, result.stderr].map((output) => output.trim()).filter((output) => output.length > 0).join("\n");
+    return combinedOutput || "Command completed with no output";
+  } catch (error) {
+    if (error instanceof Error) {
+      const stderr = Reflect.get(error, "stderr");
+      if (typeof stderr === "string" && stderr.trim().length > 0) {
+        throw new Error(`Command failed: ${stderr.trim()}`);
+      }
+      const stdout = Reflect.get(error, "stdout");
+      if (typeof stdout === "string" && stdout.trim().length > 0) {
+        throw new Error(`Command failed: ${stdout.trim()}`);
+      }
+      throw new Error(`Command failed: ${error.message}`);
+    }
+    throw new Error(`Command failed: ${String(error)}`);
+  }
+}
+async function defaultSearchWeb(query, fetchFn) {
+  const url = new URL("https://api.duckduckgo.com/");
+  url.searchParams.set("q", query);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("no_redirect", "1");
+  url.searchParams.set("no_html", "1");
+  url.searchParams.set("skip_disambig", "1");
+  const response = await fetchFn(url.toString());
+  if (!response.ok) {
+    throw new Error(`Web search failed (${response.status})`);
+  }
+  const body = await response.json();
+  const lines = [];
+  if (typeof body.AbstractText === "string" && body.AbstractText.trim().length > 0) {
+    lines.push(body.AbstractText.trim());
+  }
+  if (body.RelatedTopics) {
+    const queue = [...body.RelatedTopics];
+    while (queue.length > 0 && lines.length < 5) {
+      const current = queue.shift();
+      if (!current) continue;
+      if (typeof current.Text === "string" && current.Text.trim().length > 0) {
+        lines.push(current.Text.trim());
+      }
+      if (current.Topics) {
+        queue.push(...current.Topics);
+      }
+    }
+  }
+  if (lines.length === 0) {
+    return "No search results found.";
+  }
+  return lines.join("\n");
+}
+var exec, DefaultToolExecutor;
+var init_tool_executor = __esm({
+  "packages/poe-agent/src/tool-executor.ts"() {
+    "use strict";
+    exec = promisify(execCallback);
+    DefaultToolExecutor = class {
+      cwd;
+      allowedPaths;
+      fs;
+      runCommandFn;
+      searchWebFn;
+      constructor(options = {}) {
+        this.cwd = path4.resolve(options.cwd ?? process.cwd());
+        this.allowedPaths = (options.allowedPaths ?? [this.cwd]).map(
+          (allowedPath) => path4.resolve(this.cwd, allowedPath)
+        );
+        this.fs = options.fs ?? fsPromises2;
+        this.runCommandFn = options.runCommand ?? defaultRunCommand;
+        const fetchFn = options.fetch ?? globalThis.fetch;
+        this.searchWebFn = options.searchWeb ?? ((query) => defaultSearchWeb(query, fetchFn));
+      }
+      async executeTool(name, args) {
+        switch (name) {
+          case "read_file":
+            return this.executeReadFile(args);
+          case "edit_file":
+            return this.executeEditFile(args);
+          case "list_files":
+            return this.executeListFiles(args);
+          case "run_command":
+            return this.executeRunCommand(args);
+          case "search_web":
+            return this.executeSearchWeb(args);
+          default:
+            throw new Error(`Unsupported tool: ${name}`);
+        }
+      }
+      getAvailableTools() {
+        return [
+          {
+            type: "function",
+            function: {
+              name: "read_file",
+              description: "Read UTF-8 content from a file.",
+              parameters: {
+                type: "object",
+                properties: {
+                  path: {
+                    type: "string",
+                    description: "Path to the file to read."
+                  }
+                },
+                required: ["path"]
+              }
+            }
+          },
+          {
+            type: "function",
+            function: {
+              name: "edit_file",
+              description: "Edit or create files. Use 'str_replace' to replace exact text in an existing file (old_str must appear exactly once). Use 'create' to create a new file (fails if file already exists).",
+              parameters: {
+                type: "object",
+                properties: {
+                  command: {
+                    type: "string",
+                    enum: ["str_replace", "create"],
+                    description: "Operation to perform."
+                  },
+                  path: {
+                    type: "string",
+                    description: "File path."
+                  },
+                  old_str: {
+                    type: "string",
+                    description: "Exact string to find and replace (str_replace only). Must match exactly once."
+                  },
+                  new_str: {
+                    type: "string",
+                    description: "Replacement string (str_replace only)."
+                  },
+                  file_text: {
+                    type: "string",
+                    description: "Full file content (create only)."
+                  }
+                },
+                required: ["command", "path"]
+              }
+            }
+          },
+          {
+            type: "function",
+            function: {
+              name: "list_files",
+              description: "List files in a directory.",
+              parameters: {
+                type: "object",
+                properties: {
+                  path: {
+                    type: "string",
+                    description: "Directory path to list. Defaults to current working directory."
+                  }
+                }
+              }
+            }
+          },
+          {
+            type: "function",
+            function: {
+              name: "run_command",
+              description: "Run a shell command.",
+              parameters: {
+                type: "object",
+                properties: {
+                  command: {
+                    type: "string",
+                    description: "Command to execute."
+                  },
+                  cwd: {
+                    type: "string",
+                    description: "Working directory for command execution."
+                  }
+                },
+                required: ["command"]
+              }
+            }
+          },
+          {
+            type: "function",
+            function: {
+              name: "search_web",
+              description: "Search the web for a query.",
+              parameters: {
+                type: "object",
+                properties: {
+                  query: {
+                    type: "string",
+                    description: "Search query."
+                  }
+                },
+                required: ["query"]
+              }
+            }
+          }
+        ];
+      }
+      async executeReadFile(args) {
+        const filePath = this.resolveAllowedPath(getRequiredString(args, "path"));
+        return this.fs.readFile(filePath, "utf8");
+      }
+      async executeEditFile(args) {
+        const command = getRequiredString(args, "command");
+        const filePath = this.resolveAllowedPath(getRequiredString(args, "path"));
+        const displayedPath = path4.relative(this.cwd, filePath) || path4.basename(filePath);
+        if (command === "str_replace") {
+          const oldStr = getRequiredString(args, "old_str", true);
+          const newStr = getRequiredString(args, "new_str", true);
+          const content = await this.fs.readFile(filePath, "utf8");
+          const count = countOccurrences(content, oldStr);
+          if (count === 0) {
+            throw new Error("old_str not found in file");
+          }
+          if (count > 1) {
+            throw new Error(`old_str appears ${count} times \u2014 must be unique`);
+          }
+          await this.fs.writeFile(filePath, content.replace(oldStr, newStr), "utf8");
+          return `Edited file: ${displayedPath}`;
+        }
+        if (command === "create") {
+          const fileText = getRequiredString(args, "file_text", true);
+          if (await this.fileExists(filePath)) {
+            throw new Error("File already exists \u2014 use str_replace to edit");
+          }
+          await this.fs.mkdir(path4.dirname(filePath), { recursive: true });
+          await this.fs.writeFile(filePath, fileText, "utf8");
+          return `Created file: ${displayedPath}`;
+        }
+        throw new Error(`Unknown edit_file command: ${command}`);
+      }
+      async executeListFiles(args) {
+        const rawPath = getOptionalString(args, "path") ?? ".";
+        const directoryPath = this.resolveAllowedPath(rawPath);
+        const entries = await this.fs.readdir(directoryPath);
+        const names = entries.sort((left, right) => left.localeCompare(right));
+        if (names.length === 0) {
+          return "(empty directory)";
+        }
+        return names.join("\n");
+      }
+      async executeRunCommand(args) {
+        const command = getRequiredString(args, "command");
+        const commandCwdArg = getOptionalString(args, "cwd");
+        const commandCwd = commandCwdArg ? this.resolveAllowedPath(commandCwdArg) : this.cwd;
+        return this.runCommandFn(command, commandCwd);
+      }
+      async executeSearchWeb(args) {
+        const query = getRequiredString(args, "query");
+        return this.searchWebFn(query);
+      }
+      resolveAllowedPath(inputPath) {
+        const resolvedPath = path4.resolve(this.cwd, inputPath);
+        const isAllowed = this.allowedPaths.some((allowedPath) => {
+          if (allowedPath === resolvedPath) return true;
+          const rel = path4.relative(allowedPath, resolvedPath);
+          return rel.length > 0 && !rel.startsWith("..") && !path4.isAbsolute(rel);
+        });
+        if (!isAllowed) {
+          throw new Error(`Path is outside allowed paths: ${inputPath}`);
+        }
+        return resolvedPath;
+      }
+      async fileExists(filePath) {
+        try {
+          await this.fs.readFile(filePath, "utf8");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// packages/poe-agent/src/agent-session.ts
+async function createAgentSession(options = {}) {
+  const model = resolveRequiredModel(options.model);
+  const apiKey = await resolveApiKey(options.apiKey);
+  const systemPrompt = await loadSystemPrompt();
+  const toolExecutor = new DefaultToolExecutor({
+    cwd: options.cwd,
+    allowedPaths: options.allowedPaths
+  });
+  const tools = toolExecutor.getAvailableTools();
+  let currentOnSessionUpdate;
+  const chatService = new PoeChatService({
+    apiKey,
+    model,
+    baseUrl: options.baseUrl,
+    fetch: options.fetch,
+    systemPrompt,
+    toolExecutor,
+    maxToolCallIterations: options.maxToolCallIterations,
+    onToolCall: (event) => {
+      if (!currentOnSessionUpdate) return;
+      for (const update of mapToolLifecycleEventToSessionUpdates(event)) {
+        currentOnSessionUpdate(update);
+      }
+    }
+  });
+  let disposed = false;
+  return {
+    async sendMessage(prompt, sendOptions) {
+      if (disposed) {
+        throw new Error("Agent session is already disposed.");
+      }
+      currentOnSessionUpdate = sendOptions?.onSessionUpdate;
+      const response = await chatService.sendMessage(prompt, {
+        tools,
+        signal: sendOptions?.signal
+      });
+      if (currentOnSessionUpdate && response.role === "assistant" && response.content.length > 0) {
+        currentOnSessionUpdate({
+          sessionUpdate: "agent_message_chunk",
+          content: {
+            type: "text",
+            text: response.content
+          }
+        });
+      }
+      return response;
+    },
+    async dispose() {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      chatService.clearConversationHistory();
+      const disposableToolExecutor = toolExecutor;
+      if (typeof disposableToolExecutor.dispose === "function") {
+        await disposableToolExecutor.dispose();
+      }
+    }
+  };
+}
+async function resolveApiKey(explicitApiKey) {
+  const normalizedExplicitApiKey = normalizeNonEmptyString(explicitApiKey);
+  if (normalizedExplicitApiKey) {
+    return normalizedExplicitApiKey;
+  }
+  const { store } = createAuthStore();
+  const storedApiKey = normalizeNonEmptyString(await store.getApiKey());
+  if (storedApiKey) {
+    return storedApiKey;
+  }
+  throw new Error("Missing Poe API key. Provide apiKey or run 'poe-code login'.");
+}
+function resolveRequiredModel(model) {
+  const normalizedModel = normalizeNonEmptyString(model);
+  if (normalizedModel) {
+    return normalizedModel;
+  }
+  throw new Error("Missing model. Provide a non-empty model to createAgentSession.");
+}
+function normalizeNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function mapToolLifecycleEventToSessionUpdates(event) {
+  if (event.phase === "started") {
+    const toolCall = {
+      sessionUpdate: "tool_call",
+      toolCallId: event.toolCallId,
+      title: event.toolName,
+      kind: "execute",
+      status: "pending",
+      rawInput: event.args
+    };
+    const inProgressUpdate = {
+      sessionUpdate: "tool_call_update",
+      toolCallId: event.toolCallId,
+      kind: "execute",
+      status: "in_progress"
+    };
+    return [toolCall, inProgressUpdate];
+  }
+  const terminalUpdate = {
+    sessionUpdate: "tool_call_update",
+    toolCallId: event.toolCallId,
+    kind: "execute",
+    status: event.phase === "completed" ? "completed" : "failed"
+  };
+  if (event.phase === "completed" && event.result !== void 0) {
+    terminalUpdate.rawOutput = event.result;
+  }
+  if (event.phase === "failed" && event.error !== void 0) {
+    terminalUpdate.rawOutput = event.error;
+  }
+  return [terminalUpdate];
+}
+var init_agent_session = __esm({
+  "packages/poe-agent/src/agent-session.ts"() {
+    "use strict";
+    init_src();
+    init_chat();
+    init_system_prompt();
+    init_tool_executor();
+  }
+});
+
+// packages/poe-agent/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createAgentSession: () => createAgentSession
+});
+var init_src2 = __esm({
+  "packages/poe-agent/src/index.ts"() {
+    "use strict";
+    init_agent_session();
+  }
+});
+
+// src/cli/constants.ts
+var DEFAULT_FRONTIER_MODEL = "anthropic/claude-sonnet-4.6";
+var CLAUDE_CODE_VARIANTS = {
+  haiku: "anthropic/claude-haiku-4.5",
+  sonnet: "anthropic/claude-sonnet-4.6",
+  opus: "anthropic/claude-opus-4.6"
+};
+var DEFAULT_CLAUDE_CODE_MODEL = CLAUDE_CODE_VARIANTS.sonnet;
+var CODEX_MODELS = [
+  "openai/gpt-5.3-codex",
+  "openai/gpt-5.2-codex",
+  "openai/gpt-5.2",
+  "openai/gpt-5.2-chat",
+  "openai/gpt-5.2-pro",
+  "openai/gpt-5.1",
+  "openai/gpt-5.1-codex-mini"
+];
+var DEFAULT_CODEX_MODEL = CODEX_MODELS[0];
+var KIMI_MODELS = [
+  "novitaai/kimi-k2.5",
+  "novitaai/kimi-k2-thinking"
+];
+var DEFAULT_KIMI_MODEL = KIMI_MODELS[0];
+
+// packages/poe-acp-client/src/acp-client.ts
+import { isAbsolute } from "node:path";
+
+// packages/poe-acp-client/src/acp-transport.ts
+import {
+  spawn as spawnChildProcess
+} from "node:child_process";
+
+// packages/poe-acp-client/src/types.ts
+var ACP_ERROR_CODE_PARSE = -32700;
+var ACP_ERROR_CODE_INVALID_REQUEST = -32600;
+var ACP_ERROR_CODE_METHOD_NOT_FOUND = -32601;
+var ACP_ERROR_CODE_INVALID_PARAMS = -32602;
+var ACP_ERROR_CODE_INTERNAL = -32603;
+var ACP_ERROR_CODE_RESOURCE_NOT_FOUND = -32002;
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAcpErrorCode(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+}
+var AcpError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "AcpError";
+    this.code = code;
+    if (data !== void 0) {
+      this.data = data;
+    }
+  }
+};
+function isAcpError(value) {
+  if (value instanceof AcpError) {
+    return true;
+  }
+  if (!isObjectRecord(value)) {
+    return false;
+  }
+  if (!isAcpErrorCode(value.code) || typeof value.message !== "string") {
+    return false;
+  }
+  return value.data === void 0 || Object.prototype.hasOwnProperty.call(value, "data");
+}
+
+// packages/poe-acp-client/src/jsonrpc-message-layer.ts
+function isObjectRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, property) {
+  return Object.prototype.hasOwnProperty.call(value, property);
+}
+function isRequestId(value) {
+  return value === null || typeof value === "string" || typeof value === "number";
+}
+function toRequestId(value) {
+  return isRequestId(value) ? value : null;
+}
+function parseError() {
+  return new AcpError(ACP_ERROR_CODE_PARSE, "Parse error");
+}
+function invalidRequest() {
+  return new AcpError(ACP_ERROR_CODE_INVALID_REQUEST, "Invalid Request");
+}
+function methodNotFound(method) {
+  return new AcpError(
+    ACP_ERROR_CODE_METHOD_NOT_FOUND,
+    `Method not found: "${method}"`
+  );
+}
+function internalError(message) {
+  return new AcpError(ACP_ERROR_CODE_INTERNAL, message);
+}
+function isJsonRpcErrorObject(value) {
+  if (!isObjectRecord2(value)) {
+    return false;
+  }
+  if (!isAcpErrorCode(value.code) || typeof value.message !== "string") {
+    return false;
+  }
+  return value.data === void 0 || hasOwn(value, "data");
+}
+function toResponseError(error) {
+  return new AcpError(error.code, error.message, error.data);
+}
+function toDispatchError(error) {
+  if (error instanceof AcpError) {
+    return error;
+  }
+  if (isAcpError(error)) {
+    return new AcpError(error.code, error.message, error.data);
+  }
+  if (error instanceof Error && error.message.length > 0) {
+    return internalError(error.message);
+  }
+  return internalError("Internal error");
+}
+function chunkToString(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  return String(chunk);
+}
+function normalizeLine(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+async function* readLines(stream) {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunkToString(chunk);
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      yield normalizeLine(line);
+    }
+  }
+  if (buffer.length > 0) {
+    yield normalizeLine(buffer);
+  }
+}
+function createResponseMessage(id, result) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result: result === void 0 ? null : result
+  };
+}
+function createJsonRpcErrorResponse(id, error) {
+  const response = {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: error.code,
+      message: error.message
+    }
+  };
+  if (error.data !== void 0) {
+    response.error.data = error.data;
+  }
+  return response;
+}
+function serializeJsonRpcMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+function parseJsonRpcMessage(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return {
+      type: "invalid",
+      id: null,
+      error: parseError()
+    };
+  }
+  if (!isObjectRecord2(parsed)) {
+    return {
+      type: "invalid",
+      id: null,
+      error: invalidRequest()
+    };
+  }
+  const id = toRequestId(parsed.id);
+  if (parsed.jsonrpc !== "2.0") {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest()
+    };
+  }
+  const hasMethod = hasOwn(parsed, "method");
+  const hasId = hasOwn(parsed, "id");
+  if (hasMethod) {
+    if (typeof parsed.method !== "string") {
+      return {
+        type: "invalid",
+        id,
+        error: invalidRequest()
+      };
+    }
+    if (hasId) {
+      if (!isRequestId(parsed.id)) {
+        return {
+          type: "invalid",
+          id: null,
+          error: invalidRequest()
+        };
+      }
+      const request = {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        method: parsed.method
+      };
+      if (hasOwn(parsed, "params")) {
+        request.params = parsed.params;
+      }
+      return { type: "request", message: request };
+    }
+    const notification = {
+      jsonrpc: "2.0",
+      method: parsed.method
+    };
+    if (hasOwn(parsed, "params")) {
+      notification.params = parsed.params;
+    }
+    return {
+      type: "notification",
+      message: notification
+    };
+  }
+  if (!hasId || !isRequestId(parsed.id)) {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest()
+    };
+  }
+  const hasResult = hasOwn(parsed, "result");
+  const hasError = hasOwn(parsed, "error");
+  if (hasResult === hasError) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest()
+    };
+  }
+  if (hasResult) {
+    return {
+      type: "response",
+      message: {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        result: parsed.result
+      }
+    };
+  }
+  if (!isJsonRpcErrorObject(parsed.error)) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest()
+    };
+  }
+  return {
+    type: "response",
+    message: {
+      jsonrpc: "2.0",
+      id: parsed.id,
+      error: parsed.error
+    }
+  };
+}
+var JsonRpcMessageLayer = class {
+  input;
+  output;
+  requestHandlers = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  defaultTimeoutMs;
+  nextRequestId;
+  disposed = false;
+  constructor(options) {
+    this.input = options.input;
+    this.output = options.output;
+    this.defaultTimeoutMs = options.requestTimeoutMs ?? 3e4;
+    this.nextRequestId = options.firstRequestId ?? 1;
+    if (!Number.isFinite(this.defaultTimeoutMs) || this.defaultTimeoutMs < 0) {
+      throw new Error("requestTimeoutMs must be a non-negative finite number");
+    }
+    if (!Number.isFinite(this.nextRequestId)) {
+      throw new Error("firstRequestId must be a finite number");
+    }
+    void this.consumeInput();
+  }
+  onRequest(method, handler) {
+    this.requestHandlers.set(method, handler);
+  }
+  onNotification(method, handler) {
+    this.notificationHandlers.set(method, handler);
+  }
+  pendingRequestCount() {
+    return this.pending.size;
+  }
+  sendNotification(method, params) {
+    const notification = {
+      jsonrpc: "2.0",
+      method
+    };
+    if (params !== void 0) {
+      notification.params = params;
+    }
+    this.sendMessage(notification);
+  }
+  sendRequest(method, params, options = {}) {
+    if (this.disposed) {
+      throw new Error("JSON-RPC message layer is disposed");
+    }
+    const id = options.id === void 0 ? this.nextRequestId++ : options.id;
+    if (this.pending.has(id)) {
+      throw new Error(`A request with id ${JSON.stringify(id)} is already pending`);
+    }
+    const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new Error("timeoutMs must be a non-negative finite number");
+    }
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method
+    };
+    if (params !== void 0) {
+      request.params = params;
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`)
+        );
+      }, timeoutMs);
+      this.pending.set(id, {
+        method,
+        resolve,
+        reject,
+        timeout
+      });
+      try {
+        this.sendMessage(request);
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pending.delete(id);
+        reject(error);
+      }
+    });
+  }
+  dispose(reason = new Error("JSON-RPC message layer disposed")) {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.rejectAllPending(reason);
+  }
+  async consumeInput() {
+    try {
+      for await (const line of readLines(this.input)) {
+        if (this.disposed || line.length === 0) {
+          continue;
+        }
+        await this.handleIncomingLine(line);
+      }
+      if (!this.disposed) {
+        this.dispose(new Error("JSON-RPC input stream closed"));
+      }
+    } catch (error) {
+      if (!this.disposed) {
+        this.dispose(
+          error instanceof Error ? error : new Error(`JSON-RPC input stream failed: ${String(error)}`)
+        );
+      }
+    }
+  }
+  async handleIncomingLine(line) {
+    const parsed = parseJsonRpcMessage(line);
+    if (parsed.type === "invalid") {
+      this.sendMessage(createJsonRpcErrorResponse(parsed.id, parsed.error));
+      return;
+    }
+    if (parsed.type === "response") {
+      this.handleResponse(parsed.message);
+      return;
+    }
+    if (parsed.type === "notification") {
+      await this.handleNotification(parsed.message);
+      return;
+    }
+    await this.handleRequest(parsed.message);
+  }
+  handleResponse(message) {
+    const pending = this.pending.get(message.id);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(message.id);
+    if (pending.timeout !== null) {
+      clearTimeout(pending.timeout);
+    }
+    if ("error" in message) {
+      pending.reject(toResponseError(message.error));
+      return;
+    }
+    pending.resolve(message.result);
+  }
+  async handleRequest(message) {
+    const handler = this.requestHandlers.get(message.method);
+    if (!handler) {
+      this.sendMessage(createJsonRpcErrorResponse(message.id, methodNotFound(message.method)));
+      return;
+    }
+    try {
+      const result = await handler(message.params, {
+        id: message.id,
+        method: message.method
+      });
+      this.sendMessage(createResponseMessage(message.id, result));
+    } catch (error) {
+      this.sendMessage(createJsonRpcErrorResponse(message.id, toDispatchError(error)));
+    }
+  }
+  async handleNotification(message) {
+    const handler = this.notificationHandlers.get(message.method);
+    if (!handler) {
+      return;
+    }
+    try {
+      await handler(message.params, { method: message.method });
+    } catch {
+    }
+  }
+  sendMessage(message) {
+    if (this.disposed) {
+      throw new Error("JSON-RPC message layer is disposed");
+    }
+    this.output.write(serializeJsonRpcMessage(message));
+  }
+  rejectAllPending(error) {
+    for (const pending of this.pending.values()) {
+      if (pending.timeout !== null) {
+        clearTimeout(pending.timeout);
+      }
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+};
+
+// packages/poe-acp-client/src/acp-transport.ts
+function assertExtensionMethod(method) {
+  if (!method.startsWith("_")) {
+    throw new Error('Extension method must start with "_"');
+  }
+}
+var AcpTransport = class {
+  closed;
+  command;
+  child;
+  layer;
+  stderrChunks = [];
+  resolveClosed = null;
+  closeEvent = null;
+  closeReason = null;
+  constructor(options) {
+    const {
+      command,
+      args = [],
+      cwd,
+      env,
+      requestTimeoutMs,
+      firstRequestId,
+      spawn: spawn2 = spawnChildProcess
+    } = options;
+    this.command = command;
+    this.closed = new Promise((resolve) => {
+      this.resolveClosed = resolve;
+    });
+    this.child = spawn2(command, [...args], {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (chunk) => {
+      this.stderrChunks.push(String(chunk));
+    });
+    this.layer = new JsonRpcMessageLayer({
+      input: this.child.stdout,
+      output: this.child.stdin,
+      requestTimeoutMs,
+      firstRequestId
+    });
+    this.child.once("error", (error) => {
+      const reason = error instanceof Error ? error : new Error(String(error));
+      this.close(reason, this.child.exitCode ?? null, this.child.signalCode ?? null);
+    });
+    this.child.once("close", (code, signal) => {
+      const reason = this.closeReason ?? new Error(
+        `ACP transport closed (command "${this.command}", code: ${code ?? "null"}${signal ? `, signal: ${signal}` : ""})`
+      );
+      this.close(reason, code ?? null, signal ?? null);
+    });
+  }
+  sendRequest(method, params, options = {}) {
+    return this.layer.sendRequest(method, params, options);
+  }
+  sendExtRequest(method, params, options = {}) {
+    assertExtensionMethod(method);
+    return this.layer.sendRequest(method, params, options);
+  }
+  sendNotification(method, params) {
+    this.layer.sendNotification(method, params);
+  }
+  sendExtNotification(method, params) {
+    assertExtensionMethod(method);
+    this.layer.sendNotification(method, params);
+  }
+  onRequest(method, handler) {
+    this.layer.onRequest(method, handler);
+  }
+  onExtRequest(method, handler) {
+    assertExtensionMethod(method);
+    this.layer.onRequest(method, handler);
+  }
+  onNotification(method, handler) {
+    this.layer.onNotification(method, handler);
+  }
+  onExtNotification(method, handler) {
+    assertExtensionMethod(method);
+    this.layer.onNotification(method, handler);
+  }
+  getStderrOutput() {
+    return this.stderrChunks.join("");
+  }
+  pendingRequestCount() {
+    return this.layer.pendingRequestCount();
+  }
+  dispose(reason = new Error("ACP transport disposed")) {
+    if (this.closeEvent !== null) {
+      return;
+    }
+    this.closeReason = reason;
+    this.layer.dispose(reason);
+    if (!this.child.stdin.destroyed && !this.child.stdin.writableEnded) {
+      this.child.stdin.end();
+    }
+    if (this.child.exitCode !== null || this.child.signalCode !== null) {
+      this.close(reason, this.child.exitCode, this.child.signalCode);
+      return;
+    }
+    const killed = this.child.kill();
+    if (!killed) {
+      this.close(reason, this.child.exitCode, this.child.signalCode);
+    }
+  }
+  close(reason, code, signal) {
+    if (this.closeEvent !== null) {
+      return;
+    }
+    this.layer.dispose(reason);
+    this.closeEvent = {
+      code,
+      signal,
+      reason,
+      stderr: this.getStderrOutput()
+    };
+    this.resolveClosed?.(this.closeEvent);
+    this.resolveClosed = null;
+  }
+};
+
+// packages/poe-acp-client/src/acp-client.ts
+function toError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+function invalidParams(message) {
+  return new AcpError(
+    ACP_ERROR_CODE_INVALID_PARAMS,
+    `Invalid params: ${message}`
+  );
+}
+function resourceNotFound(resource) {
+  return new AcpError(
+    ACP_ERROR_CODE_RESOURCE_NOT_FOUND,
+    `Resource not found: ${resource}`
+  );
+}
+function assertAbsolutePath(path5) {
+  if (!isAbsolute(path5)) {
+    throw invalidParams('"path" must be an absolute path');
+  }
+}
+function assertOneBasedLineNumber(line) {
+  if (line === null || line === void 0) {
+    return;
+  }
+  if (!Number.isInteger(line) || line < 1) {
+    throw invalidParams('"line" must be a 1-based integer');
+  }
+}
+function assertExtensionMethod2(method) {
+  if (!method.startsWith("_")) {
+    throw new Error('Extension method must start with "_"');
+  }
+}
+function isInjectedTransportOptions(options) {
+  return "transport" in options;
+}
+function createAsyncQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let failure = null;
+  const resolveOne = (value) => {
+    const waiter = waiters.shift();
+    if (!waiter) {
+      return false;
+    }
+    waiter.resolve({ done: false, value });
+    return true;
+  };
+  const iterator = {
+    push(value) {
+      if (closed || failure) {
+        return;
+      }
+      if (!resolveOne(value)) {
+        values.push(value);
+      }
+    },
+    complete() {
+      if (closed || failure) {
+        return;
+      }
+      closed = true;
+      while (waiters.length > 0) {
+        waiters.shift()?.resolve({ done: true, value: void 0 });
+      }
+    },
+    fail(error) {
+      if (closed || failure) {
+        return;
+      }
+      failure = error;
+      while (waiters.length > 0) {
+        waiters.shift()?.reject(error);
+      }
+    },
+    async next() {
+      if (values.length > 0) {
+        const value = values.shift();
+        return { done: false, value };
+      }
+      if (failure) {
+        throw failure;
+      }
+      if (closed) {
+        return { done: true, value: void 0 };
+      }
+      return new Promise((resolve, reject) => {
+        waiters.push({ resolve, reject });
+      });
+    },
+    async return() {
+      iterator.complete();
+      return { done: true, value: void 0 };
+    },
+    async throw(error) {
+      const normalizedError = toError(error);
+      iterator.fail(normalizedError);
+      throw normalizedError;
+    },
+    [Symbol.asyncIterator]() {
+      return iterator;
+    }
+  };
+  return iterator;
+}
+var AcpClient = class {
+  transport;
+  clientProtocolVersion;
+  clientCapabilities;
+  clientInfo;
+  permissionHandler;
+  fsHandler;
+  terminalHandler;
+  activePromptUpdates = /* @__PURE__ */ new Map();
+  trackedTerminalIds = /* @__PURE__ */ new Map();
+  hasRegisteredFsReadHandler = false;
+  hasRegisteredFsWriteHandler = false;
+  hasRegisteredTerminalHandlers = false;
+  disposed = false;
+  lifecycleState = "uninitialized";
+  negotiatedVersion = null;
+  availableAuthMethods = [];
+  negotiatedAgentCapabilities;
+  negotiatedAgentInfo;
+  constructor(options) {
+    this.transport = isInjectedTransportOptions(options) ? options.transport : new AcpTransport({
+      command: options.command,
+      args: options.args,
+      cwd: options.cwd,
+      env: options.env,
+      requestTimeoutMs: options.requestTimeoutMs,
+      firstRequestId: options.firstRequestId,
+      spawn: options.spawn
+    });
+    this.clientProtocolVersion = options.protocolVersion ?? 1;
+    this.clientCapabilities = options.clientCapabilities;
+    this.clientInfo = options.clientInfo;
+    this.permissionHandler = options.handlers?.permission ?? options.permissionHandler;
+    this.fsHandler = options.handlers?.fs ?? options.fsHandler;
+    this.terminalHandler = options.handlers?.terminal ?? options.terminalHandler;
+    this.transport.onRequest(
+      "session/request_permission",
+      async (params) => {
+        if (!this.permissionHandler) {
+          return {
+            outcome: { outcome: "cancelled" }
+          };
+        }
+        const outcome = await this.permissionHandler({
+          toolCall: params.toolCall,
+          options: params.options
+        });
+        return { outcome };
+      }
+    );
+    this.registerCapabilityHandlers(this.clientCapabilities);
+    this.transport.onNotification("session/update", (params) => {
+      this.handleSessionUpdateNotification(params);
+    });
+  }
+  get state() {
+    return this.lifecycleState;
+  }
+  get negotiatedProtocolVersion() {
+    return this.negotiatedVersion;
+  }
+  get authMethods() {
+    return [...this.availableAuthMethods];
+  }
+  get agentCapabilities() {
+    return this.negotiatedAgentCapabilities;
+  }
+  get agentInfo() {
+    return this.negotiatedAgentInfo;
+  }
+  get closed() {
+    return this.transport.closed;
+  }
+  async initialize(clientCapabilities) {
+    if (this.lifecycleState !== "uninitialized") {
+      throw new Error("initialize() can only be called once.");
+    }
+    if (clientCapabilities !== void 0) {
+      this.clientCapabilities = clientCapabilities;
+      this.registerCapabilityHandlers(clientCapabilities);
+    }
+    const response = await this.transport.sendRequest("initialize", {
+      protocolVersion: this.clientProtocolVersion,
+      clientInfo: this.clientInfo,
+      clientCapabilities: this.clientCapabilities
+    });
+    const negotiatedProtocolVersion = Math.min(
+      this.clientProtocolVersion,
+      response.protocolVersion
+    );
+    this.negotiatedVersion = negotiatedProtocolVersion;
+    this.negotiatedAgentCapabilities = response.agentCapabilities;
+    this.negotiatedAgentInfo = response.agentInfo;
+    this.availableAuthMethods = response.authMethods ? [...response.authMethods] : [];
+    this.lifecycleState = this.availableAuthMethods.length > 0 ? "initialized" : "ready";
+    return {
+      protocolVersion: negotiatedProtocolVersion,
+      ...this.negotiatedAgentCapabilities !== void 0 ? { agentCapabilities: this.negotiatedAgentCapabilities } : {},
+      ...this.negotiatedAgentInfo !== void 0 ? { agentInfo: this.negotiatedAgentInfo } : {},
+      ...this.availableAuthMethods.length > 0 ? { authMethods: this.authMethods } : {}
+    };
+  }
+  async authenticate(methodId) {
+    if (this.lifecycleState === "uninitialized") {
+      throw new Error("Cannot authenticate before initialize().");
+    }
+    if (this.lifecycleState === "ready") {
+      throw new Error("Authentication is not required for this agent.");
+    }
+    if (!this.availableAuthMethods.some((authMethod) => authMethod.id === methodId)) {
+      throw new Error(`Unknown auth method "${methodId}".`);
+    }
+    const response = await this.transport.sendRequest("authenticate", {
+      methodId
+    });
+    this.lifecycleState = "ready";
+    return response;
+  }
+  async newSession(cwd, mcpServers) {
+    this.assertReady("session/new");
+    this.assertMcpServerCapabilitySupport(mcpServers);
+    return this.transport.sendRequest("session/new", {
+      cwd,
+      mcpServers
+    });
+  }
+  async loadSession(sessionId, cwd, mcpServers) {
+    this.assertReady("session/load");
+    if (this.negotiatedAgentCapabilities?.loadSession !== true) {
+      throw new Error(
+        'Cannot call "session/load" because the agent does not support session loading.'
+      );
+    }
+    this.assertMcpServerCapabilitySupport(mcpServers);
+    return this.transport.sendRequest("session/load", {
+      sessionId,
+      cwd,
+      mcpServers
+    });
+  }
+  async cancelSession(sessionId) {
+    this.assertReady("session/cancel");
+    const payload = { sessionId };
+    this.transport.sendNotification("session/cancel", payload);
+  }
+  async setMode(sessionId, modeId) {
+    this.assertReady("session/set_mode");
+    return this.transport.sendRequest("session/set_mode", {
+      sessionId,
+      modeId
+    });
+  }
+  async setConfigOption(sessionId, configId, value) {
+    this.assertReady("session/set_config_option");
+    const response = await this.transport.sendRequest("session/set_config_option", {
+      sessionId,
+      configId,
+      value
+    });
+    return response.configOptions;
+  }
+  prompt(sessionId, content) {
+    this.assertReady("session/prompt");
+    this.assertPromptContentCapabilitySupport(content);
+    if (this.activePromptUpdates.has(sessionId)) {
+      throw new Error(
+        `Cannot call "session/prompt" while another prompt is in progress for session "${sessionId}".`
+      );
+    }
+    const updates = createAsyncQueue();
+    this.activePromptUpdates.set(sessionId, updates);
+    let requestPromise;
+    try {
+      requestPromise = this.transport.sendRequest("session/prompt", {
+        sessionId,
+        prompt: content
+      });
+    } catch (error) {
+      const normalizedError = toError(error);
+      this.activePromptUpdates.delete(sessionId);
+      updates.fail(normalizedError);
+      throw normalizedError;
+    }
+    const response = requestPromise.then((promptResponse) => {
+      this.activePromptUpdates.delete(sessionId);
+      updates.complete();
+      return promptResponse;
+    }).catch((error) => {
+      const normalizedError = toError(error);
+      this.activePromptUpdates.delete(sessionId);
+      updates.fail(normalizedError);
+      throw normalizedError;
+    });
+    return {
+      response,
+      [Symbol.asyncIterator]() {
+        return updates;
+      }
+    };
+  }
+  async sendExtRequest(method, params, options = {}) {
+    assertExtensionMethod2(method);
+    return this.transport.sendRequest(method, params, options);
+  }
+  async sendExtNotification(method, params) {
+    assertExtensionMethod2(method);
+    this.transport.sendNotification(method, params);
+  }
+  onExtRequest(method, handler) {
+    assertExtensionMethod2(method);
+    this.transport.onRequest(method, handler);
+  }
+  onExtNotification(method, handler) {
+    assertExtensionMethod2(method);
+    this.transport.onNotification(method, handler);
+  }
+  async dispose() {
+    if (this.disposed) {
+      if (this.transport.closed) {
+        await this.transport.closed;
+      }
+      return;
+    }
+    this.disposed = true;
+    const disposeReason = new Error("ACP client disposed");
+    for (const updates of this.activePromptUpdates.values()) {
+      updates.fail(disposeReason);
+    }
+    this.activePromptUpdates.clear();
+    if (typeof this.transport.dispose === "function") {
+      this.transport.dispose(disposeReason);
+    }
+    if (this.transport.closed) {
+      await this.transport.closed;
+    }
+  }
+  assertReady(operation) {
+    if (this.lifecycleState === "ready") {
+      return;
+    }
+    if (this.lifecycleState === "uninitialized") {
+      throw new Error(`Cannot call "${operation}" before initialize().`);
+    }
+    throw new Error(`Cannot call "${operation}" before authentication completes.`);
+  }
+  registerCapabilityHandlers(capabilities) {
+    if (!this.hasRegisteredFsReadHandler && capabilities?.fs?.readTextFile === true && this.fsHandler?.readTextFile) {
+      const readTextFile = this.fsHandler.readTextFile;
+      this.transport.onRequest(
+        "fs/read_text_file",
+        async (params) => {
+          assertAbsolutePath(params.path);
+          assertOneBasedLineNumber(params.line);
+          const content = await readTextFile({
+            sessionId: params.sessionId,
+            path: params.path,
+            line: params.line,
+            limit: params.limit
+          });
+          return { content };
+        }
+      );
+      this.hasRegisteredFsReadHandler = true;
+    }
+    if (!this.hasRegisteredFsWriteHandler && capabilities?.fs?.writeTextFile === true && this.fsHandler?.writeTextFile) {
+      const writeTextFile = this.fsHandler.writeTextFile;
+      this.transport.onRequest(
+        "fs/write_text_file",
+        async (params) => {
+          assertAbsolutePath(params.path);
+          await writeTextFile({
+            sessionId: params.sessionId,
+            path: params.path,
+            content: params.content
+          });
+          return {};
+        }
+      );
+      this.hasRegisteredFsWriteHandler = true;
+    }
+    if (!this.hasRegisteredTerminalHandlers && capabilities?.terminal === true && this.terminalHandler) {
+      const terminalHandler = this.terminalHandler;
+      this.transport.onRequest(
+        "terminal/create",
+        async (params) => {
+          const terminalId = await terminalHandler.create({
+            sessionId: params.sessionId,
+            command: params.command,
+            args: params.args,
+            cwd: params.cwd,
+            env: params.env,
+            outputByteLimit: params.outputByteLimit
+          });
+          this.trackTerminal(params.sessionId, terminalId);
+          return { terminalId };
+        }
+      );
+      this.transport.onRequest(
+        "terminal/output",
+        async (params) => {
+          this.assertKnownTerminal(params.sessionId, params.terminalId);
+          return terminalHandler.output({
+            sessionId: params.sessionId,
+            terminalId: params.terminalId
+          });
+        }
+      );
+      this.transport.onRequest(
+        "terminal/wait_for_exit",
+        async (params) => {
+          this.assertKnownTerminal(params.sessionId, params.terminalId);
+          return terminalHandler.waitForExit({
+            sessionId: params.sessionId,
+            terminalId: params.terminalId
+          });
+        }
+      );
+      this.transport.onRequest(
+        "terminal/kill",
+        async (params) => {
+          this.assertKnownTerminal(params.sessionId, params.terminalId);
+          await terminalHandler.kill({
+            sessionId: params.sessionId,
+            terminalId: params.terminalId
+          });
+          return {};
+        }
+      );
+      this.transport.onRequest(
+        "terminal/release",
+        async (params) => {
+          this.assertKnownTerminal(params.sessionId, params.terminalId);
+          await terminalHandler.release({
+            sessionId: params.sessionId,
+            terminalId: params.terminalId
+          });
+          this.untrackTerminal(params.sessionId, params.terminalId);
+          return {};
+        }
+      );
+      this.hasRegisteredTerminalHandlers = true;
+    }
+  }
+  assertMcpServerCapabilitySupport(mcpServers) {
+    const mcpCapabilities = this.negotiatedAgentCapabilities?.mcpCapabilities;
+    for (const mcpServer of mcpServers) {
+      if (!("type" in mcpServer)) {
+        continue;
+      }
+      if (mcpServer.type === "http" && mcpCapabilities?.http !== true) {
+        throw new Error('Agent does not support MCP server type "http".');
+      }
+      if (mcpServer.type === "sse" && mcpCapabilities?.sse !== true) {
+        throw new Error('Agent does not support MCP server type "sse".');
+      }
+    }
+  }
+  handleSessionUpdateNotification(notification) {
+    const activePrompt = this.activePromptUpdates.get(notification.sessionId);
+    if (!activePrompt) {
+      return;
+    }
+    activePrompt.push({
+      jsonrpc: "2.0",
+      method: "session/update",
+      params: notification
+    });
+  }
+  trackTerminal(sessionId, terminalId) {
+    const sessionTerminals = this.trackedTerminalIds.get(sessionId);
+    if (sessionTerminals) {
+      sessionTerminals.add(terminalId);
+      return;
+    }
+    this.trackedTerminalIds.set(sessionId, /* @__PURE__ */ new Set([terminalId]));
+  }
+  assertKnownTerminal(sessionId, terminalId) {
+    const sessionTerminals = this.trackedTerminalIds.get(sessionId);
+    if (sessionTerminals?.has(terminalId) === true) {
+      return;
+    }
+    throw resourceNotFound(`terminal "${terminalId}"`);
+  }
+  untrackTerminal(sessionId, terminalId) {
+    const sessionTerminals = this.trackedTerminalIds.get(sessionId);
+    if (!sessionTerminals) {
+      return;
+    }
+    sessionTerminals.delete(terminalId);
+    if (sessionTerminals.size === 0) {
+      this.trackedTerminalIds.delete(sessionId);
+    }
+  }
+  assertPromptContentCapabilitySupport(content) {
+    const promptCapabilities = this.negotiatedAgentCapabilities?.promptCapabilities;
+    for (const block of content) {
+      if (block.type === "image" && promptCapabilities?.image !== true) {
+        throw new Error('Agent does not support prompt content type "image".');
+      }
+      if (block.type === "audio" && promptCapabilities?.audio !== true) {
+        throw new Error('Agent does not support prompt content type "audio".');
+      }
+      if (block.type === "resource" && promptCapabilities?.embeddedContext !== true) {
+        throw new Error('Agent does not support prompt content type "resource".');
+      }
+    }
+  }
+};
+
+// packages/poe-acp-client/src/run-report.ts
+import * as fsPromises from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// packages/poe-acp-client/src/stream-helpers.ts
+async function extractUsageFromSessionUpdateStream(stream) {
+  const updates = [];
+  for await (const entry of stream) {
+    const update = toSessionUpdate(entry);
+    if (update.sessionUpdate === "usage_update") {
+      updates.push(update);
+    }
+  }
+  return updates;
+}
+async function extractToolCallSummariesFromSessionUpdateStream(stream) {
+  const summaries = /* @__PURE__ */ new Map();
+  for await (const entry of stream) {
+    const update = toSessionUpdate(entry);
+    if (update.sessionUpdate === "tool_call") {
+      const summary = {
+        toolCallId: update.toolCallId,
+        title: update.title
+      };
+      if (update.kind !== void 0) {
+        summary.kind = update.kind;
+      }
+      if (update.status !== void 0) {
+        summary.status = update.status;
+      }
+      if (update.rawInput !== void 0) {
+        summary.rawInput = update.rawInput;
+      }
+      if (update.rawOutput !== void 0) {
+        summary.rawOutput = update.rawOutput;
+      }
+      summaries.set(update.toolCallId, summary);
+      continue;
+    }
+    if (update.sessionUpdate === "tool_call_update") {
+      const existing = summaries.get(update.toolCallId);
+      const summary = existing ?? {
+        toolCallId: update.toolCallId,
+        title: toTitle(update.title, update.toolCallId)
+      };
+      if (update.title !== null && update.title !== void 0 && update.title.length > 0) {
+        summary.title = update.title;
+      }
+      if (update.kind !== null && update.kind !== void 0) {
+        summary.kind = update.kind;
+      }
+      if (update.status !== null && update.status !== void 0) {
+        summary.status = update.status;
+      }
+      if (update.rawInput !== void 0) {
+        summary.rawInput = update.rawInput;
+      }
+      if (update.rawOutput !== void 0) {
+        summary.rawOutput = update.rawOutput;
+      }
+      summaries.set(update.toolCallId, summary);
+    }
+  }
+  return Array.from(summaries.values());
+}
+function toSessionUpdate(entry) {
+  if (isSessionUpdateNotification(entry)) {
+    return entry.params.update;
+  }
+  return entry;
+}
+function isSessionUpdateNotification(entry) {
+  return typeof entry.jsonrpc === "string" && entry.method === "session/update";
+}
+function toTitle(value, fallback) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return fallback;
+}
+
+// packages/poe-acp-client/src/run-report.ts
+async function generateRunReportFromSessionUpdateStream(stream, options = {}) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const bufferedEntries = [];
+  let runIdFromStream;
+  for await (const entry of stream) {
+    bufferedEntries.push(entry);
+    if (runIdFromStream) {
+      continue;
+    }
+    if (isSessionUpdateNotification2(entry)) {
+      const sessionId = toNonEmptyString(entry.params.sessionId);
+      if (sessionId) {
+        runIdFromStream = sessionId;
+      }
+    }
+  }
+  const runId = toNonEmptyString(options.runId) ?? runIdFromStream;
+  if (!runId) {
+    throw new Error("Run id is required via options.runId or session/update stream items");
+  }
+  const startTime = normalizeTime(options.startTime, now);
+  const endTime = normalizeTime(options.endTime, now);
+  const toolCalls = await extractToolCallSummariesFromSessionUpdateStream(bufferedEntries);
+  const usageUpdates = await extractUsageFromSessionUpdateStream(bufferedEntries);
+  const usage = summarizeUsage(usageUpdates);
+  const errors = collectErrors(toolCalls, options.errors);
+  const exitStatus = options.exitStatus ?? (errors.length > 0 ? "failed" : "success");
+  return {
+    runId,
+    startTime,
+    endTime,
+    exitStatus,
+    toolCalls,
+    usage,
+    errors
+  };
+}
+function isSessionUpdateNotification2(entry) {
+  return typeof entry.jsonrpc === "string" && entry.method === "session/update";
+}
+function normalizeTime(value, now) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "string" && value.length > 0) {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString();
+    }
+  }
+  return now().toISOString();
+}
+function summarizeUsage(updates) {
+  let used = 0;
+  let size = 0;
+  let cost;
+  for (const update of updates) {
+    used += update.used;
+    size += update.size;
+    if (update.cost !== void 0) {
+      cost = update.cost;
+    }
+  }
+  const usage = {
+    used,
+    size,
+    updates: updates.length
+  };
+  if (cost !== void 0) {
+    usage.cost = cost;
+  }
+  return usage;
+}
+function collectErrors(toolCalls, additionalErrors) {
+  const errors = [];
+  for (const toolCall of toolCalls) {
+    if (toolCall.status !== "failed") {
+      continue;
+    }
+    errors.push({
+      toolCallId: toolCall.toolCallId,
+      message: toErrorMessage(toolCall)
+    });
+  }
+  if (additionalErrors) {
+    for (const message of additionalErrors) {
+      const text = toNonEmptyString(message);
+      if (text) {
+        errors.push({ message: text });
+      }
+    }
+  }
+  return errors;
+}
+function toErrorMessage(toolCall) {
+  if (typeof toolCall.rawOutput === "string" && toolCall.rawOutput.length > 0) {
+    return toolCall.rawOutput;
+  }
+  if (toolCall.rawOutput instanceof Error && toolCall.rawOutput.message.length > 0) {
+    return toolCall.rawOutput.message;
+  }
+  if (toolCall.rawOutput !== void 0 && toolCall.rawOutput !== null) {
+    const encoded = trySerialize(toolCall.rawOutput);
+    if (encoded) {
+      return encoded;
+    }
+  }
+  return `${toolCall.title} failed`;
+}
+function trySerialize(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (typeof serialized === "string" && serialized.length > 0) {
+      return serialized;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function toNonEmptyString(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  return value;
+}
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+import Mustache from "mustache";
+
+// packages/config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse2(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const errors = [];
+  const parsed = jsonc.parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject(parsed)) {
+    throw new Error("Expected JSON object.");
+  }
+  return parsed;
+}
+function serialize(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function merge(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject(existing) && isConfigObject(value)) {
+      result[key] = merge(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject(pattern) && isConfigObject(current)) {
+      const { changed: childChanged, result: childResult } = prune(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var jsonFormat = {
+  parse: parse2,
+  serialize,
+  merge,
+  prune
+};
+
+// packages/config-mutations/src/formats/toml.ts
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function isConfigObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse3(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseToml(content);
+  if (!isConfigObject2(parsed)) {
+    throw new Error("Expected TOML document to be a table.");
+  }
+  return parsed;
+}
+function serialize2(obj) {
+  const serialized = stringifyToml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge2(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject2(existing) && isConfigObject2(value)) {
+      result[key] = merge2(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune2(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject2(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject2(pattern) && isConfigObject2(current)) {
+      const { changed: childChanged, result: childResult } = prune2(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var tomlFormat = {
+  parse: parse3,
+  serialize: serialize2,
+  merge: merge2,
+  prune: prune2
+};
+
+// packages/config-mutations/src/formats/index.ts
+var formatRegistry = {
+  json: jsonFormat,
+  toml: tomlFormat
+};
+var extensionMap = {
+  ".json": "json",
+  ".toml": "toml"
+};
+function getConfigFormat(pathOrFormat) {
+  if (pathOrFormat in formatRegistry) {
+    return formatRegistry[pathOrFormat];
+  }
+  const ext = getExtension(pathOrFormat);
+  const formatName = extensionMap[ext];
+  if (!formatName) {
+    throw new Error(
+      `Unsupported config format. Cannot detect format from "${pathOrFormat}". Supported extensions: ${Object.keys(extensionMap).join(", ")}. Supported format names: ${Object.keys(formatRegistry).join(", ")}.`
+    );
+  }
+  return formatRegistry[formatName];
+}
+function detectFormat(path5) {
+  const ext = getExtension(path5);
+  return extensionMap[ext];
+}
+function getExtension(path5) {
+  const lastDot = path5.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return path5.slice(lastDot).toLowerCase();
+}
+
+// packages/config-mutations/src/execution/path-utils.ts
+import path from "node:path";
+function expandHome(targetPath, homeDir) {
+  if (!targetPath?.startsWith("~")) {
+    return targetPath;
+  }
+  if (targetPath.startsWith("~./")) {
+    targetPath = `~/.${targetPath.slice(3)}`;
+  }
+  let remainder = targetPath.slice(1);
+  if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+    remainder = remainder.slice(1);
+  } else if (remainder.startsWith(".")) {
+    remainder = remainder.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+      remainder = remainder.slice(1);
+    }
+  }
+  return remainder.length === 0 ? homeDir : path.join(homeDir, remainder);
+}
+function validateHomePath(targetPath) {
+  if (typeof targetPath !== "string" || targetPath.length === 0) {
+    throw new Error("Target path must be a non-empty string.");
+  }
+  if (!targetPath.startsWith("~")) {
+    throw new Error(
+      `All target paths must be home-relative (start with ~). Received: "${targetPath}"`
+    );
+  }
+}
+function resolvePath(rawPath, homeDir, pathMapper) {
+  validateHomePath(rawPath);
+  const expanded = expandHome(rawPath, homeDir);
+  if (!pathMapper) {
+    return expanded;
+  }
+  const rawDirectory = path.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path.join(mappedDirectory, filename);
+}
+
+// packages/config-mutations/src/fs-utils.ts
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readFileIfExists(fs2, target) {
+  try {
+    return await fs2.readFile(target, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function pathExists(fs2, target) {
+  try {
+    await fs2.stat(target);
+    return true;
+  } catch (error) {
+    if (isNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function createTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+function resolveValue(resolver, options) {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}
+function createInvalidDocumentBackupPath(targetPath) {
+  const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
+  return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
+}
+async function backupInvalidDocument(fs2, targetPath, content) {
+  const backupPath = createInvalidDocumentBackupPath(targetPath);
+  await fs2.writeFile(backupPath, content, { encoding: "utf8" });
+}
+function describeMutation(kind, targetPath) {
+  const displayPath = targetPath ?? "target";
+  switch (kind) {
+    case "ensureDirectory":
+      return `Create ${displayPath}`;
+    case "removeDirectory":
+      return `Remove directory ${displayPath}`;
+    case "backup":
+      return `Backup ${displayPath}`;
+    case "templateWrite":
+      return `Write ${displayPath}`;
+    case "chmod":
+      return `Set permissions on ${displayPath}`;
+    case "removeFile":
+      return `Remove ${displayPath}`;
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return `Update ${displayPath}`;
+    default:
+      return "Operation";
+  }
+}
+function pruneKeysByPrefix(table, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(table)) {
+    if (!key.startsWith(prefix)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isConfigObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
+  const result = { ...base };
+  const prefixMap = pruneByPrefix ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    const prefix = prefixMap[key];
+    if (isConfigObject3(current) && isConfigObject3(value)) {
+      if (prefix) {
+        const pruned = pruneKeysByPrefix(current, prefix);
+        result[key] = { ...pruned, ...value };
+      } else {
+        result[key] = mergeWithPruneByPrefix(
+          current,
+          value,
+          prefixMap
+        );
+      }
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+async function applyMutation(mutation, context, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+      return applyEnsureDirectory(mutation, context, options);
+    case "removeDirectory":
+      return applyRemoveDirectory(mutation, context, options);
+    case "removeFile":
+      return applyRemoveFile(mutation, context, options);
+    case "chmod":
+      return applyChmod(mutation, context, options);
+    case "backup":
+      return applyBackup(mutation, context, options);
+    case "configMerge":
+      return applyConfigMerge(mutation, context, options);
+    case "configPrune":
+      return applyConfigPrune(mutation, context, options);
+    case "configTransform":
+      return applyConfigTransform(mutation, context, options);
+    case "templateWrite":
+      return applyTemplateWrite(mutation, context, options);
+    case "templateMergeToml":
+      return applyTemplateMerge(mutation, context, options, "toml");
+    case "templateMergeJson":
+      return applyTemplateMerge(mutation, context, options, "json");
+    default: {
+      const never = mutation;
+      throw new Error(`Unknown mutation kind: ${never.kind}`);
+    }
+  }
+}
+async function applyEnsureDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.mkdir(targetPath, { recursive: true });
+  }
+  return {
+    outcome: {
+      changed: !existed,
+      effect: "mkdir",
+      detail: existed ? "noop" : "create"
+    },
+    details
+  };
+}
+async function applyRemoveDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!existed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (typeof context.fs.rm !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.force) {
+    if (!context.dryRun) {
+      await context.fs.rm(targetPath, { recursive: true, force: true });
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const entries = await context.fs.readdir(targetPath);
+  if (entries.length > 0) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    await context.fs.rm(targetPath, { recursive: true, force: true });
+  }
+  return {
+    outcome: { changed: true, effect: "delete", detail: "delete" },
+    details
+  };
+}
+async function applyRemoveFile(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  try {
+    const content = await context.fs.readFile(targetPath, "utf8");
+    const trimmed = content.trim();
+    if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (mutation.whenEmpty && trimmed.length > 0) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyChmod(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  if (typeof context.fs.chmod !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  try {
+    const stat = await context.fs.stat(targetPath);
+    const currentMode = typeof stat.mode === "number" ? stat.mode & 511 : null;
+    if (currentMode === mutation.mode) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.chmod(targetPath, mutation.mode);
+    }
+    return {
+      outcome: { changed: true, effect: "chmod", detail: "update" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyBackup(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const content = await readFileIfExists(context.fs, targetPath);
+  if (content === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    const backupPath = `${targetPath}.backup-${createTimestamp()}`;
+    await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "copy", detail: "backup" },
+    details
+  };
+}
+async function applyConfigMerge(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const value = resolveValue(mutation.value, options);
+  let merged;
+  if (mutation.pruneByPrefix) {
+    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
+  } else {
+    merged = format.merge(current, value);
+  }
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+async function applyConfigPrune(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  if (rawContent === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  let current;
+  try {
+    current = format.parse(rawContent);
+  } catch {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.onlyIf && !mutation.onlyIf(current, options)) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const shape = resolveValue(mutation.shape, options);
+  const { changed, result } = format.prune(current, shape);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (Object.keys(result).length === 0) {
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(result);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "write", detail: "update" },
+    details
+  };
+}
+async function applyConfigTransform(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const { content: transformed, changed } = mutation.transform(current, options);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (transformed === null) {
+    if (rawContent === null) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(transformed);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: rawContent === null ? "create" : "update"
+    },
+    details
+  };
+}
+async function applyTemplateWrite(mutation, context, options) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: existed ? "update" : "create"
+    },
+    details
+  };
+}
+async function applyTemplateMerge(mutation, context, options, formatName) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const format = getConfigFormat(formatName);
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  let templateDoc;
+  try {
+    templateDoc = format.parse(rendered);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error}`,
+      { cause: error }
+    );
+  }
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const merged = format.merge(current, templateDoc);
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+
+// packages/config-mutations/src/execution/run-mutations.ts
+async function runMutations(mutations, context, options) {
+  const effects = [];
+  let anyChanged = false;
+  const resolverOptions = options ?? {};
+  for (const mutation of mutations) {
+    const { outcome } = await executeMutation(
+      mutation,
+      context,
+      resolverOptions
+    );
+    effects.push(outcome);
+    if (outcome.changed) {
+      anyChanged = true;
+    }
+  }
+  return {
+    changed: anyChanged,
+    effects
+  };
+}
+async function executeMutation(mutation, context, options) {
+  context.observers?.onStart?.({
+    kind: mutation.kind,
+    label: mutation.label ?? mutation.kind,
+    targetPath: void 0
+    // Will be resolved during apply
+  });
+  try {
+    const { outcome, details } = await applyMutation(mutation, context, options);
+    context.observers?.onComplete?.(details, outcome);
+    return { outcome, details };
+  } catch (error) {
+    context.observers?.onError?.(
+      {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind,
+        targetPath: void 0
+      },
+      error
+    );
+    throw error;
+  }
+}
+
+// packages/config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
+
+// src/services/service-install.ts
+async function runServiceInstall(definition, context) {
+  const checkContext = {
+    isDryRun: context.isDryRun,
+    runCommand: context.runCommand
+  };
+  let needsInstall = false;
+  try {
+    await definition.check.run(checkContext);
+    context.logger(`${definition.summary} already installed.`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    context.logger(`${definition.summary} not detected: ${detail}`);
+    needsInstall = true;
+  }
+  if (!needsInstall) {
+    return false;
+  }
+  if (context.isDryRun) {
+    logInstallDryRun(definition, context);
+    return true;
+  }
+  const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
+  for (const step of platformSteps) {
+    await runInstallStep(step, context);
+  }
+  await definition.check.run(checkContext);
+  if (definition.postChecks) {
+    for (const postCheck of definition.postChecks) {
+      await postCheck.run(checkContext);
+    }
+  }
+  context.logger(
+    definition.successMessage ?? `${definition.summary} installed.`
+  );
+  return true;
+}
+function describeInstallCommand(step) {
+  return `[${step.id}] ${formatCommand(step.command, step.args)}`;
+}
+function formatCommand(command, args) {
+  return [command, ...args.map(quoteIfNeeded)].join(" ");
+}
+function quoteIfNeeded(value) {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (value.includes(" ") || value.includes("	") || value.includes("\n")) {
+    return `"${value.replaceAll('"', '\\"')}"`;
+  }
+  return value;
+}
+function filterStepsByPlatform(steps, platform) {
+  return steps.filter(
+    (step) => !step.platforms || step.platforms.includes(platform)
+  );
+}
+function logInstallDryRun(definition, context) {
+  context.logger(`Dry run: would install ${definition.summary}.`);
+  const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
+  for (const step of platformSteps) {
+    context.logger(`Dry run: ${describeInstallCommand(step)}`);
+  }
+}
+async function runInstallStep(step, context) {
+  context.logger(`Running ${describeInstallCommand(step)}`);
+  const result = await context.runCommand(step.command, step.args);
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.trim();
+    const suffix = stderr.length > 0 ? `: ${stderr}` : "";
+    throw new Error(
+      `${describeInstallCommand(step)} failed with exit code ${result.exitCode}${suffix}`
+    );
+  }
+}
+
+// src/providers/create-provider.ts
+var templateImports = {
+  "python/env.hbs": () => Promise.resolve().then(() => __toESM(require_env(), 1)),
+  "python/main.py.hbs": () => Promise.resolve().then(() => __toESM(require_main_py(), 1)),
+  "python/requirements.txt.hbs": () => Promise.resolve().then(() => __toESM(require_requirements_txt(), 1)),
+  "codex/config.toml.hbs": () => Promise.resolve().then(() => __toESM(require_config_toml(), 1))
+};
+async function loadTemplate(templateId) {
+  const loader = templateImports[templateId];
+  if (!loader) {
+    throw new Error(`Template not found: ${templateId}`);
+  }
+  const module = await loader();
+  return module.default;
+}
+function createProvider(opts) {
+  const provider2 = {
+    id: opts.id,
+    summary: opts.summary,
+    name: opts.name,
+    aliases: opts.aliases,
+    label: opts.label,
+    branding: opts.branding,
+    disabled: opts.disabled,
+    supportsStdinPrompt: opts.supportsStdinPrompt,
+    configurePrompts: opts.configurePrompts,
+    postConfigureMessages: opts.postConfigureMessages,
+    isolatedEnv: opts.isolatedEnv,
+    async configure(context, runOptions) {
+      await runMutations(opts.manifest.configure, {
+        fs: context.fs,
+        homeDir: context.env.homeDir,
+        observers: runOptions?.observers,
+        templates: loadTemplate,
+        pathMapper: context.pathMapper
+      }, context.options);
+      context.command.flushDryRun({ emitIfEmpty: false });
+    },
+    async unconfigure(context, runOptions) {
+      if (!opts.manifest.unconfigure) {
+        return false;
+      }
+      const result = await runMutations(opts.manifest.unconfigure, {
+        fs: context.fs,
+        homeDir: context.env.homeDir,
+        observers: runOptions?.observers,
+        templates: loadTemplate,
+        pathMapper: context.pathMapper
+      }, context.options);
+      context.command.flushDryRun({ emitIfEmpty: false });
+      return result.changed;
+    }
+  };
+  if (opts.install) {
+    provider2.install = createInstallRunner(opts.install);
+  }
+  if (opts.test) {
+    provider2.test = opts.test;
+  }
+  if (opts.spawn) {
+    provider2.spawn = opts.spawn;
+  }
+  return provider2;
+}
+function createInstallRunner(definition) {
+  return async (context) => {
+    await runServiceInstall(definition, {
+      isDryRun: context.logger.context.dryRun,
+      runCommand: context.command.runCommand,
+      logger: (message) => context.logger.verbose(message),
+      platform: context.env.platform
+    });
+  };
+}
+
+// src/providers/poe-agent.ts
+function createEventQueue() {
+  const values = [];
+  const waiters = [];
+  let completed = false;
+  return {
+    push(value) {
+      if (completed) {
+        return;
+      }
+      const waiter = waiters.shift();
+      if (waiter) {
+        waiter({ done: false, value });
+        return;
+      }
+      values.push(value);
+    },
+    complete() {
+      if (completed) {
+        return;
+      }
+      completed = true;
+      while (waiters.length > 0) {
+        const waiter = waiters.shift();
+        waiter?.({ done: true, value: void 0 });
+      }
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (values.length > 0) {
+            const value = values.shift();
+            return Promise.resolve({ done: false, value });
+          }
+          if (completed) {
+            return Promise.resolve({ done: true, value: void 0 });
+          }
+          return new Promise((resolve) => {
+            waiters.push(resolve);
+          });
+        }
+      };
+    }
+  };
+}
+function createToolRenderState() {
+  return {
+    startedToolCalls: /* @__PURE__ */ new Set(),
+    toolCallKinds: /* @__PURE__ */ new Map(),
+    toolCallTitles: /* @__PURE__ */ new Map()
+  };
+}
+function toErrorMessage2(value) {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return String(value);
+}
+function toErrorStack(value) {
+  if (value instanceof Error && typeof value.stack === "string" && value.stack.length > 0) {
+    return value.stack;
+  }
+  return void 0;
+}
+function mapLegacyToolKind(kind) {
+  if (kind === "read") {
+    return "read";
+  }
+  if (kind === "execute") {
+    return "execute";
+  }
+  if (kind === "edit" || kind === "delete" || kind === "move") {
+    return "write";
+  }
+  if (kind === "other" || kind === "search" || kind === "think" || kind === "fetch" || kind === "switch_mode") {
+    return "other";
+  }
+  return void 0;
+}
+function mapLegacyToolStatus(status) {
+  if (status === "pending" || status === "in_progress" || status === "completed" || status === "failed" || status === "cancelled") {
+    return status;
+  }
+  return void 0;
+}
+function normalizeSessionUpdate(update) {
+  if (update.sessionUpdate === "agent_message_chunk" || update.sessionUpdate === "agent_thought_chunk") {
+    return {
+      sessionUpdate: update.sessionUpdate,
+      content: update.content
+    };
+  }
+  if (update.sessionUpdate === "tool_call") {
+    const normalized2 = {
+      sessionUpdate: "tool_call",
+      toolCallId: update.toolCallId,
+      title: update.title
+    };
+    const kind2 = mapLegacyToolKind(update.kind);
+    if (kind2 !== void 0) {
+      normalized2.kind = kind2;
+    }
+    const status2 = mapLegacyToolStatus(update.status);
+    if (status2 !== void 0) {
+      normalized2.status = status2;
+    }
+    if (update.rawInput !== void 0) {
+      normalized2.rawInput = update.rawInput;
+    }
+    if (update._meta !== void 0) {
+      normalized2._meta = update._meta;
+    }
+    return normalized2;
+  }
+  const normalized = {
+    sessionUpdate: "tool_call_update",
+    toolCallId: update.toolCallId
+  };
+  const kind = mapLegacyToolKind(update.kind);
+  if (kind !== void 0) {
+    normalized.kind = kind;
+  }
+  const status = mapLegacyToolStatus(update.status);
+  if (status !== void 0) {
+    normalized.status = status;
+  }
+  if (update.rawOutput !== void 0) {
+    normalized.rawOutput = update.rawOutput;
+  }
+  if (update._meta !== void 0) {
+    normalized._meta = update._meta;
+  }
+  return normalized;
+}
+function toRenderKind(kind) {
+  if (kind === "execute") {
+    return "exec";
+  }
+  if (kind === "write") {
+    return "edit";
+  }
+  if (kind === "read") {
+    return "read";
+  }
+  return "other";
+}
+function toToolOutput(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0) {
+    return "";
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    if (typeof serialized === "string") {
+      return serialized;
+    }
+  } catch {
+  }
+  return String(value);
+}
+function toPromptText(prompt) {
+  const lines = [];
+  for (const block of prompt) {
+    if (block.type === "text") {
+      lines.push(block.text);
+      continue;
+    }
+    if (block.type === "resource_link") {
+      lines.push(`${block.name}: ${block.uri}`);
+      continue;
+    }
+    if (block.type === "resource") {
+      if ("text" in block.resource) {
+        lines.push(block.resource.text);
+      }
+      continue;
+    }
+  }
+  return lines.join("\n");
+}
+function toEventsFromSessionUpdate(notification, state) {
+  const update = notification.params.update;
+  if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+    return [{ event: "agent_message", text: update.content.text }];
+  }
+  if (update.sessionUpdate === "agent_thought_chunk" && update.content.type === "text") {
+    return [{ event: "reasoning", text: update.content.text }];
+  }
+  if (update.sessionUpdate === "usage_update") {
+    const cachedTokens = Math.max(0, update.size - update.used);
+    const usage = {
+      event: "usage",
+      inputTokens: update.used,
+      outputTokens: 0
+    };
+    if (cachedTokens > 0) {
+      usage.cachedTokens = cachedTokens;
+    }
+    if (update.cost && update.cost.currency === "USD") {
+      usage.costUsd = update.cost.amount;
+    }
+    return [usage];
+  }
+  if (update.sessionUpdate === "tool_call") {
+    const renderKind = toRenderKind(update.kind);
+    state.toolCallKinds.set(update.toolCallId, renderKind);
+    state.toolCallTitles.set(update.toolCallId, update.title);
+    if (state.startedToolCalls.has(update.toolCallId)) {
+      return [];
+    }
+    state.startedToolCalls.add(update.toolCallId);
+    return [{
+      event: "tool_start",
+      kind: renderKind,
+      title: update.title,
+      id: update.toolCallId
+    }];
+  }
+  if (update.sessionUpdate === "tool_call_update") {
+    const renderKind = toRenderKind(update.kind ?? void 0) || state.toolCallKinds.get(update.toolCallId) || "other";
+    state.toolCallKinds.set(update.toolCallId, renderKind);
+    const events = [];
+    const toolTitle = state.toolCallTitles.get(update.toolCallId) ?? update.toolCallId;
+    const status = update.status;
+    const shouldStart = !state.startedToolCalls.has(update.toolCallId) && (status === "pending" || status === "in_progress");
+    if (shouldStart) {
+      state.startedToolCalls.add(update.toolCallId);
+      events.push({
+        event: "tool_start",
+        kind: renderKind,
+        title: toolTitle,
+        id: update.toolCallId
+      });
+    }
+    if (status === "completed" || status === "failed" || status === "cancelled") {
+      if (!state.startedToolCalls.has(update.toolCallId)) {
+        state.startedToolCalls.add(update.toolCallId);
+        events.push({
+          event: "tool_start",
+          kind: renderKind,
+          title: toolTitle,
+          id: update.toolCallId
+        });
+      }
+      events.push({
+        event: "tool_complete",
+        kind: renderKind,
+        path: toToolOutput(update.rawOutput),
+        id: update.toolCallId
+      });
+    }
+    return events;
+  }
+  return [];
+}
+function emitEvent(callback, event) {
+  if (!callback) {
+    return;
+  }
+  callback(event);
+}
+function createInMemoryAcpTransport(options) {
+  const sessions = /* @__PURE__ */ new Map();
+  const notificationHandlers = /* @__PURE__ */ new Map();
+  const requestHandlers = /* @__PURE__ */ new Map();
+  let sessionCounter = 0;
+  let closed = false;
+  let resolveClosed;
+  const closedPromise = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
+  const closeTransport = (reason) => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    const entries = Array.from(sessions.values());
+    sessions.clear();
+    void Promise.all(entries.map(async (session) => {
+      await session.dispose();
+    })).finally(() => {
+      resolveClosed?.({
+        code: 0,
+        signal: null,
+        reason,
+        stderr: ""
+      });
+    });
+  };
+  return {
+    closed: closedPromise,
+    async sendRequest(method, params) {
+      if (method === "initialize") {
+        const request = params;
+        const response = {
+          protocolVersion: request.protocolVersion ?? 1,
+          agentInfo: { name: "poe-agent", version: "0.0.1" },
+          agentCapabilities: {
+            sessionCapabilities: {},
+            promptCapabilities: {}
+          }
+        };
+        return response;
+      }
+      if (method === "session/new") {
+        const request = params;
+        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+        const session = await createAgentSession2({
+          model: options.model,
+          cwd: request.cwd || options.cwd
+        });
+        const sessionId = `poe-agent-session-${sessionCounter + 1}`;
+        sessionCounter += 1;
+        sessions.set(sessionId, session);
+        const response = { sessionId };
+        return response;
+      }
+      if (method === "session/prompt") {
+        const request = params;
+        const session = sessions.get(request.sessionId);
+        if (!session) {
+          throw new Error(`Unknown session "${request.sessionId}".`);
+        }
+        const promptText = toPromptText(request.prompt);
+        await session.sendMessage(promptText, {
+          onSessionUpdate: (legacyUpdate) => {
+            const normalizedUpdate = normalizeSessionUpdate(legacyUpdate);
+            const handlers2 = notificationHandlers.get("session/update");
+            if (!handlers2 || handlers2.length === 0) {
+              return;
+            }
+            const notification = {
+              sessionId: request.sessionId,
+              update: normalizedUpdate
+            };
+            for (const handler of handlers2) {
+              void handler(notification, { method: "session/update" });
+            }
+          }
+        });
+        const response = { stopReason: "completed" };
+        return response;
+      }
+      const handlers = requestHandlers.get(method);
+      if (handlers && handlers.length > 0) {
+        const result = handlers[0](params, { id: null, method });
+        return await Promise.resolve(result);
+      }
+      throw new Error(`Unsupported ACP request method "${method}".`);
+    },
+    sendNotification(method, params) {
+      if (method === "session/cancel") {
+        const sessionId = params?.sessionId;
+        if (sessionId && sessions.has(sessionId)) {
+          const session = sessions.get(sessionId);
+          sessions.delete(sessionId);
+          void session?.dispose();
+        }
+      }
+    },
+    onRequest(method, handler) {
+      const current = requestHandlers.get(method) ?? [];
+      requestHandlers.set(method, [...current, handler]);
+    },
+    onNotification(method, handler) {
+      const current = notificationHandlers.get(method) ?? [];
+      notificationHandlers.set(method, [...current, handler]);
+    },
+    dispose(reason) {
+      closeTransport(reason ?? new Error("ACP in-memory transport disposed"));
+    }
+  };
+}
+async function runPoeAgentAcpLifecycle(options) {
+  const sessionUpdates = [];
+  const toolState = createToolRenderState();
+  let sessionId = "";
+  let assistantText = "";
+  const transport = createInMemoryAcpTransport({
+    model: options.model,
+    cwd: options.cwd
+  });
+  const client = new AcpClient({ transport });
+  try {
+    await client.initialize();
+    const session = await client.newSession(options.cwd, []);
+    sessionId = session.sessionId;
+    emitEvent(options.onEvent, {
+      event: "session_start",
+      threadId: sessionId
+    });
+    const turn = client.prompt(sessionId, [{ type: "text", text: options.prompt }]);
+    for await (const notification of turn) {
+      sessionUpdates.push(notification);
+      const update = notification.params.update;
+      if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+        assistantText += update.content.text;
+      }
+      for (const event of toEventsFromSessionUpdate(notification, toolState)) {
+        emitEvent(options.onEvent, event);
+      }
+    }
+    const promptResponse = await turn.response;
+    await generateRunReportFromSessionUpdateStream(sessionUpdates, {
+      runId: sessionId,
+      exitStatus: promptResponse.stopReason === "completed" ? "success" : "failed"
+    });
+    return {
+      stdout: assistantText.length > 0 ? `${assistantText}
+` : "",
+      stderr: "",
+      exitCode: promptResponse.stopReason === "completed" ? 0 : 1,
+      threadId: sessionId,
+      sessionId
+    };
+  } catch (error) {
+    emitEvent(options.onEvent, {
+      event: "error",
+      message: toErrorMessage2(error),
+      ...toErrorStack(error) ? { stack: toErrorStack(error) } : {}
+    });
+    throw error;
+  } finally {
+    await client.dispose();
+  }
+}
+function spawnPoeAgentWithAcp(options) {
+  const queue = createEventQueue();
+  const model = options.model ?? DEFAULT_FRONTIER_MODEL;
+  const cwd = options.cwd ?? process.cwd();
+  const done = runPoeAgentAcpLifecycle({
+    prompt: options.prompt,
+    model,
+    cwd,
+    onEvent: (event) => {
+      queue.push(event);
+    }
+  }).finally(() => {
+    queue.complete();
+  });
+  return {
+    events: queue,
+    done
+  };
+}
+var poeAgentService = createProvider({
+  id: "poe-agent",
+  name: "poe-agent",
+  label: "Poe Agent",
+  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
+  supportsStdinPrompt: true,
+  manifest: {
+    configure: []
+  },
+  async spawn(context, options) {
+    const result = await runPoeAgentAcpLifecycle({
+      prompt: options.prompt,
+      model: options.model ?? DEFAULT_FRONTIER_MODEL,
+      cwd: options.cwd ?? context.env.cwd
+    });
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode
+    };
+  }
+});
+var provider = poeAgentService;
+export {
+  poeAgentService,
+  provider,
+  spawnPoeAgentWithAcp
+};
+//# sourceMappingURL=poe-agent.js.map