@posthog/agent 2.3.167 → 2.3.169

package/dist/agent.js

@@ -1,131 +1,5 @@
 // src/adapters/acp-connection.ts
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
-
-// src/acp-extensions.ts
-var POSTHOG_NOTIFICATIONS = {
-  /** Git branch was created for a task */
-  BRANCH_CREATED: "_posthog/branch_created",
-  /** Task run has started execution */
-  RUN_STARTED: "_posthog/run_started",
-  /** Task has completed (success or failure) */
-  TASK_COMPLETE: "_posthog/task_complete",
-  /** Agent finished processing a turn (prompt returned, waiting for next input) */
-  TURN_COMPLETE: "_posthog/turn_complete",
-  /** Error occurred during task execution */
-  ERROR: "_posthog/error",
-  /** Console/log output from the agent */
-  CONSOLE: "_posthog/console",
-  /** Maps taskRunId to agent's sessionId and adapter type (for resumption) */
-  SDK_SESSION: "_posthog/sdk_session",
-  /** Tree state snapshot captured (git tree hash + file archive) */
-  TREE_SNAPSHOT: "_posthog/tree_snapshot",
-  /** Agent mode changed (interactive/background) */
-  MODE_CHANGE: "_posthog/mode_change",
-  /** Request to resume a session from previous state */
-  SESSION_RESUME: "_posthog/session/resume",
-  /** User message sent from client to agent */
-  USER_MESSAGE: "_posthog/user_message",
-  /** Request to cancel current operation */
-  CANCEL: "_posthog/cancel",
-  /** Request to close the session */
-  CLOSE: "_posthog/close",
-  /** Agent status update (thinking, working, etc.) */
-  STATUS: "_posthog/status",
-  /** Task-level notification (progress, milestones) */
-  TASK_NOTIFICATION: "_posthog/task_notification",
-  /** Marks a boundary for log compaction */
-  COMPACT_BOUNDARY: "_posthog/compact_boundary"
-};
-
-// src/gateway-models.ts
-var DEFAULT_GATEWAY_MODEL = "claude-opus-4-6";
-var BLOCKED_MODELS = /* @__PURE__ */ new Set(["gpt-5-mini", "openai/gpt-5-mini"]);
-var CACHE_TTL = 10 * 60 * 1e3;
-var gatewayModelsCache = null;
-async function fetchGatewayModels(options) {
-  const gatewayUrl = options?.gatewayUrl ?? process.env.ANTHROPIC_BASE_URL;
-  if (!gatewayUrl) {
-    return [];
-  }
-  if (gatewayModelsCache && gatewayModelsCache.url === gatewayUrl && Date.now() < gatewayModelsCache.expiry) {
-    return gatewayModelsCache.models;
-  }
-  const modelsUrl = `${gatewayUrl}/v1/models`;
-  try {
-    const response = await fetch(modelsUrl);
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const models = (data.data ?? []).filter((m) => !BLOCKED_MODELS.has(m.id));
-    gatewayModelsCache = {
-      models,
-      expiry: Date.now() + CACHE_TTL,
-      url: gatewayUrl
-    };
-    return models;
-  } catch {
-    return [];
-  }
-}
-function isAnthropicModel(model) {
-  if (model.owned_by) {
-    return model.owned_by === "anthropic";
-  }
-  return model.id.startsWith("claude-") || model.id.startsWith("anthropic/");
-}
-var modelsListCache = null;
-async function fetchModelsList(options) {
-  const gatewayUrl = options?.gatewayUrl ?? process.env.ANTHROPIC_BASE_URL;
-  if (!gatewayUrl) {
-    return [];
-  }
-  if (modelsListCache && modelsListCache.url === gatewayUrl && Date.now() < modelsListCache.expiry) {
-    return modelsListCache.models;
-  }
-  try {
-    const modelsUrl = `${gatewayUrl}/v1/models`;
-    const response = await fetch(modelsUrl);
-    if (!response.ok) {
-      return [];
-    }
-    const data = await response.json();
-    const models = Array.isArray(data) ? data : data.data ?? data.models ?? [];
-    const results = [];
-    for (const model of models) {
-      const id = model?.id ? String(model.id) : "";
-      if (!id) continue;
-      results.push({ id, owned_by: model?.owned_by });
-    }
-    modelsListCache = {
-      models: results,
-      expiry: Date.now() + CACHE_TTL,
-      url: gatewayUrl
-    };
-    return results;
-  } catch {
-    return [];
-  }
-}
-var PROVIDER_PREFIXES = ["anthropic/", "openai/", "google-vertex/"];
-function formatGatewayModelName(model) {
-  return formatModelId(model.id);
-}
-function formatModelId(modelId) {
-  let cleanId = modelId;
-  for (const prefix of PROVIDER_PREFIXES) {
-    if (cleanId.startsWith(prefix)) {
-      cleanId = cleanId.slice(prefix.length);
-      break;
-    }
-  }
-  cleanId = cleanId.replace(/(\d)-(\d)/g, "$1.$2");
-  const words = cleanId.split(/[-_]/).map((word) => {
-    if (word.match(/^[0-9.]+$/)) return word;
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-  });
-  return words.join(" ");
-}
+import { AgentSideConnection, ndJsonStream as ndJsonStream2 } from "@agentclientprotocol/sdk";
 
 // src/utils/logger.ts
 var Logger = class _Logger {
@@ -181,7 +55,7 @@ var Logger = class _Logger {
 };
 
 // src/utils/streams.ts
-import { ReadableStream, WritableStream as WritableStream2 } from "stream/web";
+import { ReadableStream, WritableStream } from "stream/web";
 var Pushable = class {
   queue = [];
   resolvers = [];
@@ -239,7 +113,7 @@ function createBidirectionalStreams() {
   const agentToClientPushable = new Pushable();
   const clientToAgentReadable = pushableToReadableStream(clientToAgentPushable);
   const agentToClientReadable = pushableToReadableStream(agentToClientPushable);
-  const clientToAgentWritable = new WritableStream2({
+  const clientToAgentWritable = new WritableStream({
     write(chunk) {
       clientToAgentPushable.push(chunk);
     },
@@ -247,7 +121,7 @@ function createBidirectionalStreams() {
       clientToAgentPushable.end();
     }
   });
-  const agentToClientWritable = new WritableStream2({
+  const agentToClientWritable = new WritableStream({
     write(chunk) {
       agentToClientPushable.push(chunk);
     },
@@ -271,7 +145,7 @@ function createTappedWritableStream(underlying, options) {
   const decoder = new TextDecoder();
   let buffer = "";
   let _messageCount = 0;
-  return new WritableStream2({
+  return new WritableStream({
     async write(chunk) {
       buffer += decoder.decode(chunk, { stream: true });
       const lines = buffer.split("\n");
@@ -327,7 +201,7 @@ function nodeReadableToWebReadable(nodeStream) {
   });
 }
 function nodeWritableToWebWritable(nodeStream) {
-  return new WritableStream2({
+  return new WritableStream({
     write(chunk) {
       return new Promise((resolve3, reject) => {
         const ok = nodeStream.write(Buffer.from(chunk), (err) => {
@@ -371,7 +245,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.167",
+  version: "2.3.169",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -518,6 +392,97 @@ function unreachable(value, logger) {
   logger.error(`Unexpected case: ${valueAsString}`);
 }
 
+// src/gateway-models.ts
+var DEFAULT_GATEWAY_MODEL = "claude-opus-4-6";
+var DEFAULT_CODEX_MODEL = "gpt-5.4";
+var BLOCKED_MODELS = /* @__PURE__ */ new Set(["gpt-5-mini", "openai/gpt-5-mini"]);
+var CACHE_TTL = 10 * 60 * 1e3;
+var gatewayModelsCache = null;
+async function fetchGatewayModels(options) {
+  const gatewayUrl = options?.gatewayUrl ?? process.env.ANTHROPIC_BASE_URL;
+  if (!gatewayUrl) {
+    return [];
+  }
+  if (gatewayModelsCache && gatewayModelsCache.url === gatewayUrl && Date.now() < gatewayModelsCache.expiry) {
+    return gatewayModelsCache.models;
+  }
+  const modelsUrl = `${gatewayUrl}/v1/models`;
+  try {
+    const response = await fetch(modelsUrl);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    const models = (data.data ?? []).filter((m) => !BLOCKED_MODELS.has(m.id));
+    gatewayModelsCache = {
+      models,
+      expiry: Date.now() + CACHE_TTL,
+      url: gatewayUrl
+    };
+    return models;
+  } catch {
+    return [];
+  }
+}
+function isAnthropicModel(model) {
+  if (model.owned_by) {
+    return model.owned_by === "anthropic";
+  }
+  return model.id.startsWith("claude-") || model.id.startsWith("anthropic/");
+}
+var modelsListCache = null;
+async function fetchModelsList(options) {
+  const gatewayUrl = options?.gatewayUrl ?? process.env.ANTHROPIC_BASE_URL;
+  if (!gatewayUrl) {
+    return [];
+  }
+  if (modelsListCache && modelsListCache.url === gatewayUrl && Date.now() < modelsListCache.expiry) {
+    return modelsListCache.models;
+  }
+  try {
+    const modelsUrl = `${gatewayUrl}/v1/models`;
+    const response = await fetch(modelsUrl);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    const models = Array.isArray(data) ? data : data.data ?? data.models ?? [];
+    const results = [];
+    for (const model of models) {
+      const id = model?.id ? String(model.id) : "";
+      if (!id) continue;
+      results.push({ id, owned_by: model?.owned_by });
+    }
+    modelsListCache = {
+      models: results,
+      expiry: Date.now() + CACHE_TTL,
+      url: gatewayUrl
+    };
+    return results;
+  } catch {
+    return [];
+  }
+}
+var PROVIDER_PREFIXES = ["anthropic/", "openai/", "google-vertex/"];
+function formatGatewayModelName(model) {
+  return formatModelId(model.id);
+}
+function formatModelId(modelId) {
+  let cleanId = modelId;
+  for (const prefix of PROVIDER_PREFIXES) {
+    if (cleanId.startsWith(prefix)) {
+      cleanId = cleanId.slice(prefix.length);
+      break;
+    }
+  }
+  cleanId = cleanId.replace(/(\d)-(\d)/g, "$1.$2");
+  const words = cleanId.split(/[-_]/).map((word) => {
+    if (word.match(/^[0-9.]+$/)) return word;
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+  return words.join(" ");
+}
+
 // src/adapters/base-acp-agent.ts
 var DEFAULT_CONTEXT_WINDOW = 2e5;
 var BaseAcpAgent = class {
@@ -725,8 +690,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path8, oldText, newText) {
-    this.items.push({ type: "diff", path: path8, oldText, newText });
+  diff(path9, oldText, newText) {
+    this.items.push({ type: "diff", path: path9, oldText, newText });
     return this;
   }
   build() {
@@ -4137,6 +4102,224 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   }
 };
 
+// src/adapters/codex/codex-agent.ts
+import {
+  ClientSideConnection,
+  ndJsonStream
+} from "@agentclientprotocol/sdk";
+
+// src/acp-extensions.ts
+var POSTHOG_NOTIFICATIONS = {
+  /** Git branch was created for a task */
+  BRANCH_CREATED: "_posthog/branch_created",
+  /** Task run has started execution */
+  RUN_STARTED: "_posthog/run_started",
+  /** Task has completed (success or failure) */
+  TASK_COMPLETE: "_posthog/task_complete",
+  /** Agent finished processing a turn (prompt returned, waiting for next input) */
+  TURN_COMPLETE: "_posthog/turn_complete",
+  /** Error occurred during task execution */
+  ERROR: "_posthog/error",
+  /** Console/log output from the agent */
+  CONSOLE: "_posthog/console",
+  /** Maps taskRunId to agent's sessionId and adapter type (for resumption) */
+  SDK_SESSION: "_posthog/sdk_session",
+  /** Tree state snapshot captured (git tree hash + file archive) */
+  TREE_SNAPSHOT: "_posthog/tree_snapshot",
+  /** Agent mode changed (interactive/background) */
+  MODE_CHANGE: "_posthog/mode_change",
+  /** Request to resume a session from previous state */
+  SESSION_RESUME: "_posthog/session/resume",
+  /** User message sent from client to agent */
+  USER_MESSAGE: "_posthog/user_message",
+  /** Request to cancel current operation */
+  CANCEL: "_posthog/cancel",
+  /** Request to close the session */
+  CLOSE: "_posthog/close",
+  /** Agent status update (thinking, working, etc.) */
+  STATUS: "_posthog/status",
+  /** Task-level notification (progress, milestones) */
+  TASK_NOTIFICATION: "_posthog/task_notification",
+  /** Marks a boundary for log compaction */
+  COMPACT_BOUNDARY: "_posthog/compact_boundary"
+};
+
+// src/adapters/codex/codex-client.ts
+function createCodexClient(upstreamClient, logger, sessionState, callbacks) {
+  const terminalHandles = /* @__PURE__ */ new Map();
+  return {
+    async requestPermission(params) {
+      logger.debug("Relaying permission request to upstream", {
+        sessionId: params.sessionId
+      });
+      return upstreamClient.requestPermission(params);
+    },
+    async sessionUpdate(params) {
+      const update = params.update;
+      if (update?.sessionUpdate === "usage_update") {
+        const used = update.used;
+        const size = update.size;
+        if (used !== void 0) sessionState.contextUsed = used;
+        if (size !== void 0) sessionState.contextSize = size;
+        callbacks?.onUsageUpdate?.(update);
+      }
+      await upstreamClient.sessionUpdate(params);
+    },
+    async readTextFile(params) {
+      return upstreamClient.readTextFile(params);
+    },
+    async writeTextFile(params) {
+      return upstreamClient.writeTextFile(params);
+    },
+    async createTerminal(params) {
+      const handle = await upstreamClient.createTerminal(params);
+      terminalHandles.set(handle.id, handle);
+      return { terminalId: handle.id };
+    },
+    async terminalOutput(params) {
+      const handle = terminalHandles.get(params.terminalId);
+      if (!handle) {
+        return { output: "", truncated: false };
+      }
+      return handle.currentOutput();
+    },
+    async releaseTerminal(params) {
+      const handle = terminalHandles.get(params.terminalId);
+      if (handle) {
+        terminalHandles.delete(params.terminalId);
+        const result = await handle.release();
+        return result ?? void 0;
+      }
+    },
+    async waitForTerminalExit(params) {
+      const handle = terminalHandles.get(params.terminalId);
+      if (!handle) {
+        return { exitCode: 1 };
+      }
+      return handle.waitForExit();
+    },
+    async killTerminal(params) {
+      const handle = terminalHandles.get(params.terminalId);
+      if (handle) {
+        return handle.kill();
+      }
+    },
+    async extMethod(method, params) {
+      return upstreamClient.extMethod(method, params);
+    },
+    async extNotification(method, params) {
+      return upstreamClient.extNotification(method, params);
+    }
+  };
+}
+
+// src/adapters/codex/session-state.ts
+function createSessionState(sessionId, cwd, opts) {
+  return {
+    sessionId,
+    cwd,
+    modeId: opts?.modeId ?? "default",
+    modelId: opts?.modelId,
+    configOptions: [],
+    accumulatedUsage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      cachedReadTokens: 0,
+      cachedWriteTokens: 0
+    },
+    cancelled: false,
+    taskRunId: opts?.taskRunId,
+    taskId: opts?.taskId
+  };
+}
+function resetUsage(state) {
+  state.accumulatedUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedReadTokens: 0,
+    cachedWriteTokens: 0
+  };
+}
+
+// src/adapters/codex/settings.ts
+import * as fs5 from "fs";
+import * as os5 from "os";
+import * as path7 from "path";
+var CodexSettingsManager = class {
+  cwd;
+  settings = {};
+  initialized = false;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.loadSettings();
+    this.initialized = true;
+  }
+  getConfigPath() {
+    return path7.join(os5.homedir(), ".codex", "config.toml");
+  }
+  async loadSettings() {
+    const configPath = this.getConfigPath();
+    try {
+      const content = await fs5.promises.readFile(configPath, "utf-8");
+      this.settings = parseCodexToml(content, this.cwd);
+    } catch {
+      this.settings = {};
+    }
+  }
+  getSettings() {
+    return this.settings;
+  }
+  getCwd() {
+    return this.cwd;
+  }
+  async setCwd(cwd) {
+    if (this.cwd === cwd) {
+      return;
+    }
+    this.dispose();
+    this.cwd = cwd;
+    this.initialized = false;
+    await this.initialize();
+  }
+  dispose() {
+    this.initialized = false;
+  }
+};
+function parseCodexToml(content, cwd) {
+  const settings = {};
+  let currentSection = "";
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const sectionMatch = trimmed.match(/^\[(.+)\]$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1] ?? "";
+      continue;
+    }
+    const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (!kvMatch) continue;
+    const key = kvMatch[1];
+    let value = kvMatch[2]?.trim() ?? "";
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (!currentSection) {
+      if (key === "model") settings.model = value;
+      if (key === "personality") settings.personality = value;
+      if (key === "model_reasoning_effort")
+        settings.modelReasoningEffort = value;
+    } else if (currentSection === `projects."${cwd}"`) {
+      if (key === "trust_level") settings.trustLevel = value;
+    }
+  }
+  return settings;
+}
+
 // src/adapters/codex/spawn.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync3 } from "fs";
@@ -4233,64 +4416,216 @@ function spawnCodexProcess(options) {
   };
 }
 
-// src/adapters/acp-connection.ts
-function isGroupedOptions(options) {
-  return options.length > 0 && "group" in options[0];
-}
-function formatOption(o) {
-  if (!o.value) return o;
-  return { ...o, name: formatModelId(o.value) };
-}
-function filterModelConfigOptions(msg, allowedModelIds) {
-  const payload = msg;
-  const configOptions = payload.result?.configOptions ?? payload.params?.update?.configOptions;
-  if (!configOptions) return null;
-  const filtered = configOptions.map((opt) => {
-    if (opt.category !== "model" || !opt.options) return opt;
-    const options = opt.options;
-    if (isGroupedOptions(options)) {
-      const filteredOptions2 = options.map((group) => ({
-        ...group,
-        options: (group.options ?? []).filter((o) => o?.value && allowedModelIds.has(o.value)).map(formatOption)
-      }));
-      const flat = filteredOptions2.flatMap((g) => g.options ?? []);
-      const currentAllowed2 = opt.currentValue && allowedModelIds.has(opt.currentValue);
-      const nextCurrent2 = currentAllowed2 || flat.length === 0 ? opt.currentValue : flat[0]?.value;
-      return {
-        ...opt,
-        currentValue: nextCurrent2,
-        options: filteredOptions2
-      };
-    }
-    const valueOptions = options;
-    const filteredOptions = valueOptions.filter((o) => o?.value && allowedModelIds.has(o.value)).map(formatOption);
-    const currentAllowed = opt.currentValue && allowedModelIds.has(opt.currentValue);
-    const nextCurrent = currentAllowed || filteredOptions.length === 0 ? opt.currentValue : filteredOptions[0]?.value;
-    return {
-      ...opt,
-      currentValue: nextCurrent,
-      options: filteredOptions
+// src/adapters/codex/codex-agent.ts
+var CodexAcpAgent = class extends BaseAcpAgent {
+  adapterName = "codex";
+  codexProcess;
+  codexConnection;
+  sessionState;
+  constructor(client, options) {
+    super(client);
+    this.logger = new Logger({ debug: true, prefix: "[CodexAcpAgent]" });
+    this.codexProcess = spawnCodexProcess({
+      ...options.codexProcessOptions,
+      logger: this.logger,
+      processCallbacks: options.processCallbacks
+    });
+    const codexReadable = nodeReadableToWebReadable(this.codexProcess.stdout);
+    const codexWritable = nodeWritableToWebWritable(this.codexProcess.stdin);
+    const codexStream = ndJsonStream(codexWritable, codexReadable);
+    const cwd = options.codexProcessOptions.cwd ?? process.cwd();
+    const settingsManager = new CodexSettingsManager(cwd);
+    const abortController = new AbortController();
+    this.session = {
+      abortController,
+      settingsManager,
+      notificationHistory: [],
+      cancelled: false
     };
-  });
-  if (payload.result?.configOptions) {
-    return { ...msg, result: { ...payload.result, configOptions: filtered } };
+    this.codexConnection = new ClientSideConnection(
+      (_agent) => createCodexClient(
+        this.client,
+        this.logger,
+        this.sessionState ?? {
+          sessionId: "",
+          cwd: "",
+          modeId: "default",
+          configOptions: [],
+          accumulatedUsage: {
+            inputTokens: 0,
+            outputTokens: 0,
+            cachedReadTokens: 0,
+            cachedWriteTokens: 0
+          },
+          cancelled: false
+        }
+      ),
+      codexStream
+    );
   }
-  if (payload.params?.update?.configOptions) {
+  async initialize(request) {
+    await this.session.settingsManager.initialize();
+    const response = await this.codexConnection.initialize(request);
     return {
-      ...msg,
-      params: {
-        ...payload.params,
-        update: { ...payload.params.update, configOptions: filtered }
+      ...response,
+      agentCapabilities: {
+        ...response.agentCapabilities,
+        sessionCapabilities: {
+          ...response.agentCapabilities?.sessionCapabilities,
+          resume: {},
+          fork: {}
+        },
+        _meta: {
+          posthog: {
+            resumeSession: true
+          }
+        }
+      },
+      agentInfo: {
+        name: package_default.name,
+        title: "Codex Agent",
+        version: package_default.version
       }
     };
   }
-  return null;
-}
-function extractReasoningEffort(configOptions) {
-  if (!configOptions) return void 0;
-  const option = configOptions.find((opt) => opt.id === "reasoning_effort");
-  return option?.currentValue ?? void 0;
-}
+  async newSession(params) {
+    const meta = params._meta;
+    const response = await this.codexConnection.newSession(params);
+    this.sessionState = createSessionState(response.sessionId, params.cwd, {
+      taskRunId: meta?.taskRunId,
+      taskId: meta?.taskId ?? meta?.persistence?.taskId,
+      modeId: response.modes?.currentModeId ?? "default",
+      modelId: response.models?.currentModelId
+    });
+    this.sessionId = response.sessionId;
+    this.sessionState.configOptions = response.configOptions ?? [];
+    if (meta?.taskRunId) {
+      await this.client.extNotification(POSTHOG_NOTIFICATIONS.SDK_SESSION, {
+        taskRunId: meta.taskRunId,
+        sessionId: response.sessionId,
+        adapter: "codex"
+      });
+    }
+    this.logger.info("Codex session created", {
+      sessionId: response.sessionId,
+      taskRunId: meta?.taskRunId
+    });
+    return response;
+  }
+  async loadSession(params) {
+    const response = await this.codexConnection.loadSession(params);
+    this.sessionState = createSessionState(params.sessionId, params.cwd);
+    this.sessionId = params.sessionId;
+    this.sessionState.configOptions = response.configOptions ?? [];
+    return response;
+  }
+  async unstable_resumeSession(params) {
+    const loadResponse = await this.codexConnection.loadSession({
+      sessionId: params.sessionId,
+      cwd: params.cwd,
+      mcpServers: params.mcpServers ?? []
+    });
+    this.sessionState = createSessionState(params.sessionId, params.cwd);
+    this.sessionId = params.sessionId;
+    this.sessionState.configOptions = loadResponse.configOptions ?? [];
+    const meta = params._meta;
+    if (meta?.taskRunId) {
+      await this.client.extNotification(POSTHOG_NOTIFICATIONS.SDK_SESSION, {
+        taskRunId: meta.taskRunId,
+        sessionId: params.sessionId,
+        adapter: "codex"
+      });
+    }
+    return {
+      modes: loadResponse.modes,
+      models: loadResponse.models,
+      configOptions: loadResponse.configOptions
+    };
+  }
+  async unstable_forkSession(params) {
+    const newResponse = await this.codexConnection.newSession({
+      cwd: params.cwd,
+      mcpServers: params.mcpServers ?? [],
+      _meta: params._meta
+    });
+    this.sessionState = createSessionState(newResponse.sessionId, params.cwd);
+    this.sessionId = newResponse.sessionId;
+    this.sessionState.configOptions = newResponse.configOptions ?? [];
+    return newResponse;
+  }
+  async listSessions(params) {
+    return this.codexConnection.listSessions(params);
+  }
+  async unstable_listSessions(params) {
+    return this.codexConnection.listSessions(params);
+  }
+  async prompt(params) {
+    if (this.sessionState) {
+      this.sessionState.cancelled = false;
+      this.sessionState.interruptReason = void 0;
+      resetUsage(this.sessionState);
+    }
+    const response = await this.codexConnection.prompt(params);
+    if (this.sessionState?.taskRunId && response.usage) {
+      await this.client.extNotification("_posthog/usage_update", {
+        sessionId: params.sessionId,
+        used: {
+          inputTokens: response.usage.inputTokens ?? 0,
+          outputTokens: response.usage.outputTokens ?? 0,
+          cachedReadTokens: response.usage.cachedReadTokens ?? 0,
+          cachedWriteTokens: response.usage.cachedWriteTokens ?? 0
+        },
+        cost: null
+      });
+    }
+    return response;
+  }
+  async interrupt() {
+    if (this.sessionState) {
+      this.sessionState.cancelled = true;
+    }
+    await this.codexConnection.cancel({
+      sessionId: this.sessionId
+    });
+  }
+  async cancel(params) {
+    if (this.sessionState) {
+      this.sessionState.cancelled = true;
+      const meta = params._meta;
+      if (meta?.interruptReason) {
+        this.sessionState.interruptReason = meta.interruptReason;
+      }
+    }
+    await this.codexConnection.cancel(params);
+  }
+  async setSessionMode(params) {
+    const response = await this.codexConnection.setSessionMode(params);
+    if (this.sessionState) {
+      this.sessionState.modeId = params.modeId;
+    }
+    return response ?? {};
+  }
+  async setSessionConfigOption(params) {
+    const response = await this.codexConnection.setSessionConfigOption(params);
+    if (this.sessionState && response.configOptions) {
+      this.sessionState.configOptions = response.configOptions;
+    }
+    return response;
+  }
+  async authenticate(_params) {
+  }
+  async closeSession() {
+    this.logger.info("Closing Codex session", { sessionId: this.sessionId });
+    this.session.settingsManager.dispose();
+    try {
+      this.codexProcess.kill();
+    } catch (err) {
+      this.logger.warn("Failed to kill codex-acp process", { error: err });
+    }
+  }
+};
+
+// src/adapters/acp-connection.ts
 function createAcpConnection(config = {}) {
   const adapterType = config.adapter ?? "claude";
   if (adapterType === "codex") {
@@ -4331,7 +4666,7 @@ function createClaudeConnection(config) {
       hasLogWriter: !!logWriter
     });
   }
-  const agentStream = ndJsonStream(agentWritable, streams.agent.readable);
+  const agentStream = ndJsonStream2(agentWritable, streams.agent.readable);
   let agent = null;
   const agentConnection = new AgentSideConnection((client) => {
     agent = new ClaudeAcpAgent(client, config.processCallbacks);
@@ -4363,214 +4698,63 @@ function createClaudeConnection(config) {
 function createCodexConnection(config) {
   const logger = config.logger?.child("CodexConnection") ?? new Logger({ debug: true, prefix: "[CodexConnection]" });
   const { logWriter } = config;
-  const allowedModelIds = config.allowedModelIds;
-  const codexProcess = spawnCodexProcess({
-    ...config.codexOptions,
-    logger,
-    processCallbacks: config.processCallbacks
-  });
-  let clientReadable = nodeReadableToWebReadable(codexProcess.stdout);
-  let clientWritable = nodeWritableToWebWritable(codexProcess.stdin);
-  let isLoadingSession = false;
-  let loadRequestId = null;
-  let newSessionRequestId = null;
-  let sdkSessionEmitted = false;
-  const reasoningEffortBySessionId = /* @__PURE__ */ new Map();
-  let injectedConfigId = 0;
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let readBuffer = "";
-  const taskRunId = config.taskRunId;
-  const filteringReadable = clientReadable.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        readBuffer += decoder.decode(chunk, { stream: true });
-        const lines = readBuffer.split("\n");
-        readBuffer = lines.pop() ?? "";
-        const outputLines = [];
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed) {
-            outputLines.push(line);
-            continue;
-          }
-          let shouldFilter = false;
-          try {
-            const msg = JSON.parse(trimmed);
-            const sessionId = msg?.params?.sessionId ?? msg?.result?.sessionId ?? null;
-            const configOptions = msg?.result?.configOptions ?? msg?.params?.update?.configOptions;
-            if (sessionId && configOptions) {
-              const effort = extractReasoningEffort(configOptions);
-              if (effort) {
-                reasoningEffortBySessionId.set(sessionId, effort);
-              }
-            }
-            if (!sdkSessionEmitted && newSessionRequestId !== null && msg.id === newSessionRequestId && "result" in msg) {
-              const sessionId2 = msg.result?.sessionId;
-              if (sessionId2 && taskRunId) {
-                const sdkSessionNotification = {
-                  jsonrpc: "2.0",
-                  method: POSTHOG_NOTIFICATIONS.SDK_SESSION,
-                  params: {
-                    taskRunId,
-                    sessionId: sessionId2,
-                    adapter: "codex"
-                  }
-                };
-                outputLines.push(JSON.stringify(sdkSessionNotification));
-                sdkSessionEmitted = true;
-              }
-              newSessionRequestId = null;
-            }
-            if (isLoadingSession) {
-              if (msg.id === loadRequestId && "result" in msg) {
-                logger.debug("session/load complete, resuming stream");
-                isLoadingSession = false;
-                loadRequestId = null;
-              } else if (msg.method === "session/update") {
-                shouldFilter = true;
-              }
-            }
-            if (!shouldFilter && allowedModelIds && allowedModelIds.size > 0) {
-              const updated = filterModelConfigOptions(msg, allowedModelIds);
-              if (updated) {
-                outputLines.push(JSON.stringify(updated));
-                continue;
-              }
-            }
-          } catch {
-          }
-          if (!shouldFilter) {
-            outputLines.push(line);
-            const isChunkNoise = trimmed.includes('"sessionUpdate":"agent_message_chunk"') || trimmed.includes('"sessionUpdate":"agent_thought_chunk"');
-            if (!isChunkNoise) {
-              logger.debug("codex-acp stdout:", trimmed);
-            }
-          }
-        }
-        if (outputLines.length > 0) {
-          const output = `${outputLines.join("\n")}
-`;
-          controller.enqueue(encoder.encode(output));
-        }
-      },
-      flush(controller) {
-        if (readBuffer.trim()) {
-          controller.enqueue(encoder.encode(readBuffer));
-        }
-      }
-    })
-  );
-  clientReadable = filteringReadable;
-  const originalWritable = clientWritable;
-  clientWritable = new WritableStream({
-    write(chunk) {
-      const text2 = decoder.decode(chunk, { stream: true });
-      const trimmed = text2.trim();
-      logger.debug("codex-acp stdin:", trimmed);
-      try {
-        const msg = JSON.parse(trimmed);
-        if (msg.method === "session/set_config_option" && msg.params?.configId === "reasoning_effort" && msg.params?.sessionId && msg.params?.value) {
-          reasoningEffortBySessionId.set(
-            msg.params.sessionId,
-            msg.params.value
-          );
-        }
-        if (msg.method === "session/prompt" && msg.params?.sessionId) {
-          const effort = reasoningEffortBySessionId.get(msg.params.sessionId);
-          if (effort) {
-            const injection = {
-              jsonrpc: "2.0",
-              id: `reasoning_effort_${Date.now()}_${injectedConfigId++}`,
-              method: "session/set_config_option",
-              params: {
-                sessionId: msg.params.sessionId,
-                configId: "reasoning_effort",
-                value: effort
-              }
-            };
-            const injectionLine = `${JSON.stringify(injection)}
-`;
-            const writer2 = originalWritable.getWriter();
-            return writer2.write(encoder.encode(injectionLine)).then(() => writer2.releaseLock()).then(() => {
-              const nextWriter = originalWritable.getWriter();
-              return nextWriter.write(chunk).finally(() => nextWriter.releaseLock());
-            });
-          }
-        }
-        if (msg.method === "session/new" && msg.id) {
-          logger.debug("session/new detected, tracking request ID");
-          newSessionRequestId = msg.id;
-        } else if (msg.method === "session/load" && msg.id) {
-          logger.debug("session/load detected, pausing stream updates");
-          isLoadingSession = true;
-          loadRequestId = msg.id;
-        }
-      } catch {
-      }
-      const writer = originalWritable.getWriter();
-      return writer.write(chunk).finally(() => writer.releaseLock());
-    },
-    close() {
-      const writer = originalWritable.getWriter();
-      return writer.close().finally(() => writer.releaseLock());
-    }
-  });
-  const shouldTapLogs = config.taskRunId && logWriter;
-  if (shouldTapLogs && config.taskRunId) {
-    const taskRunId2 = config.taskRunId;
-    if (!logWriter.isRegistered(taskRunId2)) {
-      logWriter.register(taskRunId2, {
-        taskId: config.taskId ?? taskRunId2,
-        runId: taskRunId2
+  const streams = createBidirectionalStreams();
+  let agentWritable = streams.agent.writable;
+  let clientWritable = streams.client.writable;
+  if (config.taskRunId && logWriter) {
+    if (!logWriter.isRegistered(config.taskRunId)) {
+      logWriter.register(config.taskRunId, {
+        taskId: config.taskId ?? config.taskRunId,
+        runId: config.taskRunId,
+        deviceType: config.deviceType
       });
     }
-    clientWritable = createTappedWritableStream(clientWritable, {
+    const taskRunId = config.taskRunId;
+    agentWritable = createTappedWritableStream(streams.agent.writable, {
       onMessage: (line) => {
-        logWriter.appendRawLine(taskRunId2, line);
+        logWriter.appendRawLine(taskRunId, line);
+      },
+      logger
+    });
+    clientWritable = createTappedWritableStream(streams.client.writable, {
+      onMessage: (line) => {
+        logWriter.appendRawLine(taskRunId, line);
       },
       logger
     });
-    const originalReadable = clientReadable;
-    const logDecoder = new TextDecoder();
-    let logBuffer = "";
-    clientReadable = originalReadable.pipeThrough(
-      new TransformStream({
-        transform(chunk, controller) {
-          logBuffer += logDecoder.decode(chunk, { stream: true });
-          const lines = logBuffer.split("\n");
-          logBuffer = lines.pop() ?? "";
-          for (const line of lines) {
-            if (line.trim()) {
-              logWriter.appendRawLine(taskRunId2, line);
-            }
-          }
-          controller.enqueue(chunk);
-        },
-        flush() {
-          if (logBuffer.trim()) {
-            logWriter.appendRawLine(taskRunId2, logBuffer);
-          }
-        }
-      })
-    );
   } else {
     logger.info("Tapped streams NOT enabled for Codex", {
       hasTaskRunId: !!config.taskRunId,
       hasLogWriter: !!logWriter
     });
   }
+  const agentStream = ndJsonStream2(agentWritable, streams.agent.readable);
+  let agent = null;
+  const agentConnection = new AgentSideConnection((client) => {
+    agent = new CodexAcpAgent(client, {
+      codexProcessOptions: config.codexOptions ?? {},
+      processCallbacks: config.processCallbacks
+    });
+    logger.info(`Created ${agent.adapterName} agent`);
+    return agent;
+  }, agentStream);
   return {
-    agentConnection: void 0,
+    agentConnection,
     clientStreams: {
-      readable: clientReadable,
+      readable: streams.client.readable,
       writable: clientWritable
     },
     cleanup: async () => {
       logger.info("Cleaning up Codex connection");
-      codexProcess.kill();
+      if (agent) {
+        await agent.closeSession();
+      }
       try {
-        await clientWritable.close();
+        await streams.client.writable.close();
+      } catch {
+      }
+      try {
+        await streams.agent.writable.close();
       } catch {
       }
     }
@@ -4778,9 +4962,9 @@ var PostHogAPIClient = class {
 };
 
 // src/session-log-writer.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import fsp from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -4820,13 +5004,13 @@ var SessionLogWriter = class _SessionLogWriter {
     this.sessions.set(sessionId, { context, currentTurnMessages: [] });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
     if (this.localCachePath) {
-      const sessionDir = path7.join(
+      const sessionDir = path8.join(
         this.localCachePath,
         "sessions",
         context.runId
       );
       try {
-        fs5.mkdirSync(sessionDir, { recursive: true });
+        fs6.mkdirSync(sessionDir, { recursive: true });
       } catch (error) {
         this.logger.warn("Failed to create local cache directory", {
           sessionDir,
@@ -5078,14 +5262,14 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!this.localCachePath) return;
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    const logPath = path7.join(
+    const logPath = path8.join(
       this.localCachePath,
       "sessions",
       session.context.runId,
       "logs.ndjson"
     );
     try {
-      fs5.appendFileSync(logPath, `${JSON.stringify(entry)}
+      fs6.appendFileSync(logPath, `${JSON.stringify(entry)}
 `);
     } catch (error) {
       this.logger.warn("Failed to write to local cache", {
@@ -5097,13 +5281,13 @@ var SessionLogWriter = class _SessionLogWriter {
     }
   }
   static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path7.join(localCachePath, "sessions");
+    const sessionsDir = path8.join(localCachePath, "sessions");
     let deleted = 0;
     try {
       const entries = await fsp.readdir(sessionsDir);
       const now = Date.now();
       for (const entry of entries) {
-        const entryPath = path7.join(sessionsDir, entry);
+        const entryPath = path8.join(sessionsDir, entry);
         try {
           const stats = await fsp.stat(entryPath);
           if (stats.isDirectory() && now - stats.birthtimeMs > _SessionLogWriter.SESSIONS_MAX_AGE_MS) {
@@ -5189,7 +5373,7 @@ var Agent = class {
         allowedModelIds = new Set(codexModelIds);
       }
       if (!sanitizedModel || !allowedModelIds?.has(sanitizedModel)) {
-        sanitizedModel = codexModelIds[0];
+        sanitizedModel = codexModelIds.includes(DEFAULT_CODEX_MODEL) ? DEFAULT_CODEX_MODEL : codexModelIds[0];
       }
     }
     if (!sanitizedModel && options.adapter !== "codex") {