@posthog/agent 2.3.168 → 2.3.169

package/dist/server/bin.cjs

@@ -509,7 +509,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os6 = require("os");
+    var os7 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -557,7 +557,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os7.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -805,10 +805,10 @@ var require_src2 = __commonJS({
     var fs_1 = require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path12, isFile, isDirectory) {
-      log(`checking %s`, path12);
+    function check(path13, isFile, isDirectory) {
+      log(`checking %s`, path13);
       try {
-        const stat = fs_1.statSync(path12);
+        const stat = fs_1.statSync(path13);
         if (stat.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -828,8 +828,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path12, type = exports2.READABLE) {
-      return check(path12, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
+    function exists2(path13, type = exports2.READABLE) {
+      return check(path13, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
     }
     exports2.exists = exists2;
     exports2.FILE = 1;
@@ -897,14 +897,14 @@ var import_commander = require("commander");
 var import_zod4 = require("zod");
 
 // src/server/agent-server.ts
-var import_sdk4 = require("@agentclientprotocol/sdk");
+var import_sdk5 = require("@agentclientprotocol/sdk");
 var import_node_server = require("@hono/node-server");
 var import_hono = require("hono");
 
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.168",
+  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: {
@@ -1066,64 +1066,7 @@ var POSTHOG_NOTIFICATIONS = {
 };
 
 // src/adapters/acp-connection.ts
-var import_sdk3 = require("@agentclientprotocol/sdk");
-
-// 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 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(" ");
-}
+var import_sdk4 = require("@agentclientprotocol/sdk");
 
 // src/utils/logger.ts
 var Logger = class _Logger {
@@ -1382,6 +1325,63 @@ function unreachable(value, logger) {
   logger.error(`Unexpected case: ${valueAsString}`);
 }
 
+// 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 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 {
@@ -1589,8 +1589,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path12, oldText, newText) {
-    this.items.push({ type: "diff", path: path12, oldText, newText });
+  diff(path13, oldText, newText) {
+    this.items.push({ type: "diff", path: path13, oldText, newText });
     return this;
   }
   build() {
@@ -5001,6 +5001,185 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   }
 };
 
+// src/adapters/codex/codex-agent.ts
+var import_sdk3 = require("@agentclientprotocol/sdk");
+
+// 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
+var fs5 = __toESM(require("fs"), 1);
+var os5 = __toESM(require("os"), 1);
+var path7 = __toESM(require("path"), 1);
+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 trimmed2 = line.trim();
+    if (!trimmed2 || trimmed2.startsWith("#")) continue;
+    const sectionMatch = trimmed2.match(/^\[(.+)\]$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1] ?? "";
+      continue;
+    }
+    const kvMatch = trimmed2.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
 var import_node_child_process2 = require("child_process");
 var import_node_fs2 = require("fs");
@@ -5097,64 +5276,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;
+// 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 = (0, import_sdk3.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
+    };
+    this.codexConnection = new import_sdk3.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
+    );
+  }
+  async initialize(request) {
+    await this.session.settingsManager.initialize();
+    const response = await this.codexConnection.initialize(request);
     return {
-      ...opt,
-      currentValue: nextCurrent,
-      options: filteredOptions
+      ...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
+      }
     };
-  });
-  if (payload.result?.configOptions) {
-    return { ...msg, result: { ...payload.result, configOptions: filtered } };
   }
-  if (payload.params?.update?.configOptions) {
+  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 {
-      ...msg,
-      params: {
-        ...payload.params,
-        update: { ...payload.params.update, configOptions: filtered }
-      }
+      modes: loadResponse.modes,
+      models: loadResponse.models,
+      configOptions: loadResponse.configOptions
     };
   }
-  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 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") {
@@ -5195,9 +5526,9 @@ function createClaudeConnection(config) {
       hasLogWriter: !!logWriter
     });
   }
-  const agentStream = (0, import_sdk3.ndJsonStream)(agentWritable, streams.agent.readable);
+  const agentStream = (0, import_sdk4.ndJsonStream)(agentWritable, streams.agent.readable);
   let agent = null;
-  const agentConnection = new import_sdk3.AgentSideConnection((client) => {
+  const agentConnection = new import_sdk4.AgentSideConnection((client) => {
     agent = new ClaudeAcpAgent(client, config.processCallbacks);
     logger.info(`Created ${agent.adapterName} agent`);
     return agent;
@@ -5227,214 +5558,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 trimmed2 = line.trim();
-          if (!trimmed2) {
-            outputLines.push(line);
-            continue;
-          }
-          let shouldFilter = false;
-          try {
-            const msg = JSON.parse(trimmed2);
-            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 = trimmed2.includes('"sessionUpdate":"agent_message_chunk"') || trimmed2.includes('"sessionUpdate":"agent_thought_chunk"');
-            if (!isChunkNoise) {
-              logger.debug("codex-acp stdout:", trimmed2);
-            }
-          }
-        }
-        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 trimmed2 = text2.trim();
-      logger.debug("codex-acp stdin:", trimmed2);
-      try {
-        const msg = JSON.parse(trimmed2);
-        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 = (0, import_sdk4.ndJsonStream)(agentWritable, streams.agent.readable);
+  let agent = null;
+  const agentConnection = new import_sdk4.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 {
       }
     }
@@ -5443,9 +5623,9 @@ function createCodexConnection(config) {
 
 // src/adapters/claude/session/jsonl-hydration.ts
 var import_node_crypto2 = require("crypto");
-var fs5 = __toESM(require("fs/promises"), 1);
-var os5 = __toESM(require("os"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
+var os6 = __toESM(require("os"), 1);
+var path8 = __toESM(require("path"), 1);
 var CHARS_PER_TOKEN = 4;
 var DEFAULT_MAX_TOKENS = 15e4;
 function estimateTurnTokens(turn) {
@@ -5808,8 +5988,8 @@ var Saga = class {
 };
 
 // ../git/dist/queries.js
-var fs7 = __toESM(require("fs/promises"), 1);
-var path9 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs/promises"), 1);
+var path10 = __toESM(require("path"), 1);
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_node_buffer = require("buffer");
@@ -5848,8 +6028,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path12) {
-  return path12 instanceof String && cache.has(path12);
+function isPathSpec(path13) {
+  return path13 instanceof String && cache.has(path13);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -5938,8 +6118,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path12) {
-  return (0, import_file_exists.exists)(path12, import_file_exists.FOLDER);
+function folderExists(path13) {
+  return (0, import_file_exists.exists)(path13, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -6343,8 +6523,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path12) {
-      return /^\.(git)?$/.test(path12.trim());
+    parser(path13) {
+      return /^\.(git)?$/.test(path13.trim());
     }
   };
 }
@@ -6778,11 +6958,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path12, line, preview] = input.split(NULL);
-    paths.add(path12);
-    (results[path12] = results[path12] || []).push({
+    const [path13, line, preview] = input.split(NULL);
+    paths.add(path13);
+    (results[path13] = results[path13] || []).push({
       line: asNumber(line),
-      path: path12,
+      path: path13,
       preview
     });
   });
@@ -7547,14 +7727,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path12, text2) {
+function parseInit(bare, path13, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path12, false, result[1]);
+    return new InitSummary(bare, path13, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path12, true, result[1]);
+    return new InitSummary(bare, path13, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -7565,7 +7745,7 @@ function parseInit(bare, path12, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path12, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path13, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -7574,9 +7754,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path12, existing, gitDir) {
+      constructor(bare, path13, existing, gitDir) {
         this.bare = bare;
-        this.path = path12;
+        this.path = path13;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -7588,7 +7768,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path12, customArgs) {
+function initTask(bare = false, path13, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -7597,7 +7777,7 @@ function initTask(bare = false, path12, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path12, text2);
+      return parseInit(commands.includes("--bare"), path13, text2);
     }
   };
 }
@@ -8413,12 +8593,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path12, index, working_dir) {
-        this.path = path12;
+      constructor(path13, index, working_dir) {
+        this.path = path13;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path12) || [null, path12, path12];
+          const detail = fromPathRegex.exec(path13) || [null, path13, path13];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -8449,14 +8629,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path12) {
+  function data(index, workingDir, path13) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path12);
+      handler(result, path13);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path12, index, workingDir));
+      result.files.push(new FileStatusSummary(path13, index, workingDir));
     }
   }
 }
@@ -8769,9 +8949,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path12, write) {
+      hashObject(path13, write) {
         return this._runTask(
-          hashObjectTask(path12, write === true),
+          hashObjectTask(path13, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -9124,8 +9304,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path12 = input.trim().replace(/^["']|["']$/g, "");
-  return path12 && (0, import_node_path3.normalize)(path12);
+  const path13 = input.trim().replace(/^["']|["']$/g, "");
+  return path13 && (0, import_node_path3.normalize)(path13);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -9439,8 +9619,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path12) {
-  return subModuleTask(["add", repo, path12]);
+function addSubModuleTask(repo, path13) {
+  return subModuleTask(["add", repo, path13]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -9770,8 +9950,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path12, then) {
-      return this._runTask(addSubModuleTask2(repo, path12), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path13, then) {
+      return this._runTask(addSubModuleTask2(repo, path13), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -10583,8 +10763,8 @@ var import_node_path5 = require("path");
 
 // ../git/dist/sagas/tree.js
 var import_node_fs3 = require("fs");
-var fs8 = __toESM(require("fs/promises"), 1);
-var path10 = __toESM(require("path"), 1);
+var fs9 = __toESM(require("fs/promises"), 1);
+var path11 = __toESM(require("path"), 1);
 var tar = __toESM(require("tar"), 1);
 
 // ../git/dist/git-saga.js
@@ -10611,14 +10791,14 @@ var CaptureTreeSaga = class extends GitSaga {
   tempIndexPath = null;
   async executeGitOperations(input) {
     const { baseDir, lastTreeHash, archivePath, signal } = input;
-    const tmpDir = path10.join(baseDir, ".git", "posthog-code-tmp");
+    const tmpDir = path11.join(baseDir, ".git", "posthog-code-tmp");
     await this.step({
       name: "create_tmp_dir",
-      execute: () => fs8.mkdir(tmpDir, { recursive: true }),
+      execute: () => fs9.mkdir(tmpDir, { recursive: true }),
       rollback: async () => {
       }
     });
-    this.tempIndexPath = path10.join(tmpDir, `index-${Date.now()}`);
+    this.tempIndexPath = path11.join(tmpDir, `index-${Date.now()}`);
     const tempIndexGit = this.git.env({
       ...process.env,
       GIT_INDEX_FILE: this.tempIndexPath
@@ -10628,7 +10808,7 @@ var CaptureTreeSaga = class extends GitSaga {
       execute: () => tempIndexGit.raw(["read-tree", "HEAD"]),
       rollback: async () => {
         if (this.tempIndexPath) {
-          await fs8.rm(this.tempIndexPath, { force: true }).catch(() => {
+          await fs9.rm(this.tempIndexPath, { force: true }).catch(() => {
           });
         }
       }
@@ -10637,7 +10817,7 @@ var CaptureTreeSaga = class extends GitSaga {
     const treeHash = await this.readOnlyStep("write_tree", () => tempIndexGit.raw(["write-tree"]));
     if (lastTreeHash && treeHash === lastTreeHash) {
       this.log.debug("No changes since last capture", { treeHash });
-      await fs8.rm(this.tempIndexPath, { force: true }).catch(() => {
+      await fs9.rm(this.tempIndexPath, { force: true }).catch(() => {
       });
       return { snapshot: null, changed: false };
     }
@@ -10649,7 +10829,7 @@ var CaptureTreeSaga = class extends GitSaga {
       }
     });
     const changes = await this.readOnlyStep("get_changes", () => this.getChanges(this.git, baseCommit, treeHash));
-    await fs8.rm(this.tempIndexPath, { force: true }).catch(() => {
+    await fs9.rm(this.tempIndexPath, { force: true }).catch(() => {
     });
     const snapshot = {
       treeHash,
@@ -10673,15 +10853,15 @@ var CaptureTreeSaga = class extends GitSaga {
     if (filesToArchive.length === 0) {
       return void 0;
     }
-    const existingFiles = filesToArchive.filter((f) => (0, import_node_fs3.existsSync)(path10.join(baseDir, f)));
+    const existingFiles = filesToArchive.filter((f) => (0, import_node_fs3.existsSync)(path11.join(baseDir, f)));
     if (existingFiles.length === 0) {
       return void 0;
     }
     await this.step({
       name: "create_archive",
       execute: async () => {
-        const archiveDir = path10.dirname(archivePath);
-        await fs8.mkdir(archiveDir, { recursive: true });
+        const archiveDir = path11.dirname(archivePath);
+        await fs9.mkdir(archiveDir, { recursive: true });
         await tar.create({
           gzip: true,
           file: archivePath,
@@ -10689,7 +10869,7 @@ var CaptureTreeSaga = class extends GitSaga {
         }, existingFiles);
       },
       rollback: async () => {
-        await fs8.rm(archivePath, { force: true }).catch(() => {
+        await fs9.rm(archivePath, { force: true }).catch(() => {
         });
       }
     });
@@ -10789,9 +10969,9 @@ var ApplyTreeSaga = class extends GitSaga {
       const filesToExtract = changes.filter((c) => c.status !== "D").map((c) => c.path);
       await this.readOnlyStep("backup_existing_files", async () => {
         for (const filePath of filesToExtract) {
-          const fullPath = path10.join(baseDir, filePath);
+          const fullPath = path11.join(baseDir, filePath);
           try {
-            const content = await fs8.readFile(fullPath);
+            const content = await fs9.readFile(fullPath);
             this.fileBackups.set(filePath, content);
           } catch {
           }
@@ -10808,16 +10988,16 @@ var ApplyTreeSaga = class extends GitSaga {
         },
         rollback: async () => {
           for (const filePath of this.extractedFiles) {
-            const fullPath = path10.join(baseDir, filePath);
+            const fullPath = path11.join(baseDir, filePath);
             const backup = this.fileBackups.get(filePath);
             if (backup) {
-              const dir = path10.dirname(fullPath);
-              await fs8.mkdir(dir, { recursive: true }).catch(() => {
+              const dir = path11.dirname(fullPath);
+              await fs9.mkdir(dir, { recursive: true }).catch(() => {
               });
-              await fs8.writeFile(fullPath, backup).catch(() => {
+              await fs9.writeFile(fullPath, backup).catch(() => {
               });
             } else {
-              await fs8.rm(fullPath, { force: true }).catch(() => {
+              await fs9.rm(fullPath, { force: true }).catch(() => {
               });
             }
           }
@@ -10825,10 +11005,10 @@ var ApplyTreeSaga = class extends GitSaga {
       });
     }
     for (const change of changes.filter((c) => c.status === "D")) {
-      const fullPath = path10.join(baseDir, change.path);
+      const fullPath = path11.join(baseDir, change.path);
       const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
         try {
-          return await fs8.readFile(fullPath);
+          return await fs9.readFile(fullPath);
         } catch {
           return null;
         }
@@ -10836,15 +11016,15 @@ var ApplyTreeSaga = class extends GitSaga {
       await this.step({
         name: `delete_${change.path}`,
         execute: async () => {
-          await fs8.rm(fullPath, { force: true });
+          await fs9.rm(fullPath, { force: true });
           this.log.debug(`Deleted file: ${change.path}`);
         },
         rollback: async () => {
           if (backupContent) {
-            const dir = path10.dirname(fullPath);
-            await fs8.mkdir(dir, { recursive: true }).catch(() => {
+            const dir = path11.dirname(fullPath);
+            await fs9.mkdir(dir, { recursive: true }).catch(() => {
             });
-            await fs8.writeFile(fullPath, backupContent).catch(() => {
+            await fs9.writeFile(fullPath, backupContent).catch(() => {
             });
           }
         }
@@ -12378,13 +12558,13 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
       onAcpMessage,
       this.logger
     );
-    const clientStream = (0, import_sdk4.ndJsonStream)(tappedWritable, tappedReadable);
-    const clientConnection = new import_sdk4.ClientSideConnection(
+    const clientStream = (0, import_sdk5.ndJsonStream)(tappedWritable, tappedReadable);
+    const clientConnection = new import_sdk5.ClientSideConnection(
       () => this.createCloudClient(payload),
       clientStream
     );
     await clientConnection.initialize({
-      protocolVersion: import_sdk4.PROTOCOL_VERSION,
+      protocolVersion: import_sdk5.PROTOCOL_VERSION,
       clientCapabilities: {}
     });
     let preTaskRun = null;