@posthog/agent 2.3.312 → 2.3.316

package/dist/agent.js

@@ -245,7 +245,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.312",
+  version: "2.3.316",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -4299,7 +4299,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
 // src/adapters/codex/codex-agent.ts
 import {
   ClientSideConnection,
-  ndJsonStream
+  ndJsonStream,
+  RequestError as RequestError3
 } from "@agentclientprotocol/sdk";
 
 // src/adapters/codex/codex-client.ts
@@ -4699,11 +4700,18 @@ var CodexAcpAgent = class extends BaseAcpAgent {
    * single-owner.
    */
   promptMutex = Promise.resolve();
+  codexProcessOptions;
+  processCallbacks;
+  // Snapshot of the initialize() request so refreshSession can replay the
+  // same handshake against a respawned codex-acp subprocess.
+  lastInitRequest;
   constructor(client, options) {
     super(client);
     this.logger = new Logger({ debug: true, prefix: "[CodexAcpAgent]" });
     const cwd = options.codexProcessOptions.cwd ?? process.cwd();
     const settingsManager = new CodexSettingsManager(cwd);
+    this.codexProcessOptions = options.codexProcessOptions;
+    this.processCallbacks = options.processCallbacks;
     this.codexProcess = spawnCodexProcess({
       ...options.codexProcessOptions,
       settings: settingsManager.getSettings(),
@@ -4718,7 +4726,8 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       abortController,
       settingsManager,
       notificationHistory: [],
-      cancelled: false
+      cancelled: false,
+      promptRunning: false
     };
     this.sessionState = createSessionState("", cwd);
     this.codexConnection = new ClientSideConnection(
@@ -4728,6 +4737,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
   }
   async initialize(request) {
     await this.session.settingsManager.initialize();
+    this.lastInitRequest = request;
     const response = await this.codexConnection.initialize(request);
     return {
       ...response,
@@ -4896,9 +4906,13 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     this.session.interruptReason = void 0;
     resetUsage(this.sessionState);
     await this.broadcastUserMessage(params);
-    const response = await this.codexConnection.prompt(
-      prependPrContext(params)
-    );
+    this.session.promptRunning = true;
+    let response;
+    try {
+      response = await this.codexConnection.prompt(prependPrContext(params));
+    } finally {
+      this.session.promptRunning = false;
+    }
     if (this.sessionState.taskRunId) {
       const { accumulatedUsage } = this.sessionState;
       await this.client.extNotification(POSTHOG_NOTIFICATIONS.TURN_COMPLETE, {
@@ -4945,6 +4959,94 @@ var CodexAcpAgent = class extends BaseAcpAgent {
       this.appendNotification(params.sessionId, notification);
     }
   }
+  /**
+   * Refresh the session between turns. Currently the only refreshable field
+   * is `mcpServers`. Unlike Claude (where we rebuild an in-process Query with
+   * `resume`), Codex runs as a `codex-acp` subprocess whose MCP set is bound
+   * at `newSession`/`loadSession` time and whose user-local MCPs are disabled
+   * via spawn-time `-c mcp_servers.<name>.enabled=false` CLI args. To
+   * guarantee the caller-supplied set fully wins, we respawn the subprocess
+   * and rehydrate the session via `loadSession` — codex-acp persists sessions
+   * to disk, so conversation history is preserved.
+   *
+   * This is an `extMethod` (request/response), not `extNotification`, so the
+   * caller can await completion before sending the next prompt.
+   *
+   * Caller contract: only call REFRESH_SESSION between turns (no prompt in flight).
+   */
+  async extMethod(method, params) {
+    if (!isMethod(method, POSTHOG_METHODS.REFRESH_SESSION)) {
+      throw RequestError3.methodNotFound(method);
+    }
+    if (params.mcpServers === void 0) {
+      throw new RequestError3(
+        -32602,
+        "refresh_session requires at least one refreshable field (e.g. mcpServers)"
+      );
+    }
+    if (!Array.isArray(params.mcpServers)) {
+      throw new RequestError3(
+        -32602,
+        "refresh_session: mcpServers must be an array"
+      );
+    }
+    await this.refreshSession(params.mcpServers);
+    return { refreshed: true };
+  }
+  async refreshSession(mcpServers) {
+    const prev = this.session;
+    if (prev.promptRunning) {
+      throw new RequestError3(
+        -32002,
+        "Cannot refresh session while a prompt turn is in flight"
+      );
+    }
+    this.logger.info("Refreshing Codex session with fresh MCP servers", {
+      serverCount: mcpServers.length,
+      sessionId: this.sessionId
+    });
+    prev.abortController.abort();
+    try {
+      await this.codexConnection.cancel({ sessionId: this.sessionId });
+    } catch (err) {
+      this.logger.warn("cancel() during refresh failed (non-fatal)", {
+        error: err
+      });
+    }
+    this.codexProcess.kill();
+    const cwd = prev.settingsManager.getCwd();
+    const newSettingsManager = new CodexSettingsManager(cwd);
+    await newSettingsManager.initialize();
+    const newProcess = spawnCodexProcess({
+      ...this.codexProcessOptions,
+      cwd,
+      settings: newSettingsManager.getSettings(),
+      logger: this.logger,
+      processCallbacks: this.processCallbacks
+    });
+    const codexReadable = nodeReadableToWebReadable(newProcess.stdout);
+    const codexWritable = nodeWritableToWebWritable(newProcess.stdin);
+    const codexStream = ndJsonStream(codexWritable, codexReadable);
+    const newAbortController = new AbortController();
+    const newConnection = new ClientSideConnection(
+      (_agent) => createCodexClient(this.client, this.logger, this.sessionState),
+      codexStream
+    );
+    const initRequest = this.lastInitRequest ?? {
+      protocolVersion: 1
+    };
+    await newConnection.initialize(initRequest);
+    await newConnection.loadSession({
+      sessionId: this.sessionId,
+      cwd: this.sessionState.cwd,
+      mcpServers
+    });
+    this.codexProcess = newProcess;
+    this.codexConnection = newConnection;
+    prev.settingsManager.dispose();
+    prev.settingsManager = newSettingsManager;
+    prev.abortController = newAbortController;
+  }
   async setSessionMode(params) {
     const requestedMode = toCodexPermissionMode(params.modeId);
     const nativeMode = toCodexNativeMode(params.modeId);