@posthog/agent 2.3.305 → 2.3.308

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.305",
+  "version": "2.3.308",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {

package/src/adapters/acp-connection.ts

@@ -103,7 +103,6 @@ function createClaudeConnection(config: AcpConnectionConfig): AcpConnection {
       ...config.processCallbacks,
       onStructuredOutput: config.onStructuredOutput,
     });
-    logger.info(`Created ${agent.adapterName} agent`);
     return agent;
   }, agentStream);
 
@@ -194,7 +193,6 @@ function createCodexConnection(config: AcpConnectionConfig): AcpConnection {
       codexProcessOptions: config.codexOptions ?? {},
       processCallbacks: config.processCallbacks,
     });
-    logger.info(`Created ${agent.adapterName} agent`);
     return agent;
   }, agentStream);
 

package/src/adapters/claude/claude-agent.ts

@@ -433,11 +433,6 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               }
             }
             this.session.lastContextWindowSize = lastContextWindowSize;
-            this.logger.debug("Context window size from result", {
-              sdkReported: contextWindows,
-              resolved: lastContextWindowSize,
-              modelId: this.session.modelId,
-            });
 
             this.session.contextSize = lastContextWindowSize;
             if (lastAssistantTotalUsage !== null) {
@@ -963,7 +958,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         ? { type: "json_schema" as const, schema: meta.jsonSchema }
         : undefined;
 
-    this.logger.info(isResume ? "Resuming session" : "Creating new session", {
+    this.logger.debug(isResume ? "Resuming session" : "Creating new session", {
       sessionId,
       taskId,
       taskRunId: meta?.taskRunId,
@@ -1033,13 +1028,6 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     this.session = session;
     this.sessionId = sessionId;
 
-    this.logger.info(
-      isResume
-        ? "Session query initialized, awaiting resumption"
-        : "Session query initialized, awaiting initialization",
-      { sessionId, taskId, taskRunId: meta?.taskRunId },
-    );
-
     if (isResume) {
       // Resume must block on initialization to validate the session is still alive.
       // For stale sessions this throws (e.g. "No conversation found").
@@ -1166,17 +1154,6 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       this.deferBackgroundFetches(q);
     }
 
-    this.logger.info(
-      isResume
-        ? "Session resumed successfully"
-        : "Session created successfully",
-      {
-        sessionId,
-        taskId,
-        taskRunId: meta?.taskRunId,
-      },
-    );
-
     return { sessionId, modes, models, configOptions };
   }
 
@@ -1412,7 +1389,6 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
    * Both populate caches used later — neither is needed to return configOptions.
    */
   private deferBackgroundFetches(q: Query): void {
-    this.logger.info("Starting background fetches (commands + MCP metadata)");
     Promise.all([
       new Promise<void>((resolve) => setTimeout(resolve, 10)).then(() =>
         this.sendAvailableCommandsUpdate(),

package/src/adapters/claude/session/jsonl-hydration.ts

@@ -503,9 +503,6 @@ export async function hydrateSessionJsonl(params: {
     const jsonlPath = getSessionJsonlPath(params.sessionId, params.cwd);
     try {
       await fs.access(jsonlPath);
-      log.info("Local JSONL exists, skipping S3 hydration", {
-        sessionId: params.sessionId,
-      });
       return true;
     } catch {
       // File doesn't exist, proceed with hydration

package/src/adapters/codex/codex-agent.test.ts

@@ -209,6 +209,92 @@ describe("CodexAcpAgent", () => {
     });
   });
 
+  it("serializes concurrent prompts so usage accumulators are not wiped mid-turn", async () => {
+    const { agent } = createAgent();
+    mockCodexConnection.newSession.mockResolvedValue({
+      sessionId: "session-1",
+      modes: { currentModeId: "auto", availableModes: [] },
+      configOptions: [],
+    } satisfies Partial<NewSessionResponse>);
+    await agent.newSession({
+      cwd: process.cwd(),
+      _meta: { taskRunId: "run-1" },
+    } as never);
+
+    const callOrder: string[] = [];
+    let releaseA: () => void;
+    const aStarted = new Promise<void>((resolve) => {
+      releaseA = resolve;
+    });
+    let allowAResolve: () => void;
+    const aHold = new Promise<void>((resolve) => {
+      allowAResolve = resolve;
+    });
+
+    mockCodexConnection.prompt.mockImplementationOnce(async () => {
+      callOrder.push("A:start");
+      releaseA();
+      await aHold;
+      callOrder.push("A:end");
+      return { stopReason: "end_turn" };
+    });
+    mockCodexConnection.prompt.mockImplementationOnce(async () => {
+      callOrder.push("B:start");
+      return { stopReason: "end_turn" };
+    });
+
+    const promptA = agent.prompt({
+      sessionId: "session-1",
+      prompt: [{ type: "text", text: "A" }],
+    } as never);
+
+    await aStarted;
+
+    const promptB = agent.prompt({
+      sessionId: "session-1",
+      prompt: [{ type: "text", text: "B" }],
+    } as never);
+
+    // B must not have started while A is still in-flight.
+    expect(callOrder).toEqual(["A:start"]);
+
+    allowAResolve!();
+    await Promise.all([promptA, promptB]);
+
+    expect(callOrder).toEqual(["A:start", "A:end", "B:start"]);
+  });
+
+  it("does not let a failing prompt block subsequent prompts", async () => {
+    const { agent } = createAgent();
+    mockCodexConnection.newSession.mockResolvedValue({
+      sessionId: "session-1",
+      modes: { currentModeId: "auto", availableModes: [] },
+      configOptions: [],
+    } satisfies Partial<NewSessionResponse>);
+    await agent.newSession({
+      cwd: process.cwd(),
+    } as never);
+
+    mockCodexConnection.prompt.mockRejectedValueOnce(new Error("boom"));
+    mockCodexConnection.prompt.mockResolvedValueOnce({
+      stopReason: "end_turn",
+    });
+
+    await expect(
+      agent.prompt({
+        sessionId: "session-1",
+        prompt: [{ type: "text", text: "A" }],
+      } as never),
+    ).rejects.toThrow("boom");
+
+    await expect(
+      agent.prompt({
+        sessionId: "session-1",
+        prompt: [{ type: "text", text: "B" }],
+      } as never),
+    ).resolves.toEqual({ stopReason: "end_turn" });
+  });
+
   it("broadcasts user prompt as user_message_chunk before delegating to codex-acp", async () => {
     const { agent, client } = createAgent();
     // Seed an active session so prompt() has the state it expects.

package/src/adapters/codex/codex-agent.ts

@@ -145,6 +145,17 @@ export class CodexAcpAgent extends BaseAcpAgent {
   private codexProcess: CodexProcess;
   private codexConnection: ClientSideConnection;
   private sessionState: CodexSessionState;
+  /**
+   * FIFO serializer for prompt() calls. codex-acp and codex-rs themselves
+   * serialize submissions at the conversation level, but our adapter
+   * accumulates per-turn usage into sessionState.accumulatedUsage via the
+   * codex-client sessionUpdate handler. If two prompts ran concurrently on
+   * the JS side, the second's resetUsage() would wipe out the first's
+   * in-flight counters and both TURN_COMPLETE notifications would report
+   * garbled totals. Serializing on the JS side keeps the accumulator
+   * single-owner.
+   */
+  private promptMutex: Promise<unknown> = Promise.resolve();
 
   constructor(client: AgentSideConnection, options: CodexAcpAgentOptions) {
     super(client);
@@ -397,6 +408,13 @@ export class CodexAcpAgent extends BaseAcpAgent {
   }
 
   async prompt(params: PromptRequest): Promise<PromptResponse> {
+    const previous = this.promptMutex;
+    const next = previous.catch(() => {}).then(() => this.runPrompt(params));
+    this.promptMutex = next;
+    return next;
+  }
+
+  private async runPrompt(params: PromptRequest): Promise<PromptResponse> {
     this.session.cancelled = false;
     this.session.interruptReason = undefined;
     resetUsage(this.sessionState);

package/src/agent.ts

@@ -76,9 +76,6 @@ export class Agent {
     options: TaskExecutionOptions = {},
   ): Promise<InProcessAcpConnection> {
     const gatewayConfig = await this._configureLlmGateway(options.gatewayUrl);
-    this.logger.info("Configured LLM gateway", {
-      adapter: options.adapter,
-    });
     this.taskRunId = taskRunId;
 
     let allowedModelIds: Set<string> | undefined;

package/src/session-log-writer.ts

@@ -70,10 +70,6 @@ export class SessionLogWriter {
       return;
     }
 
-    this.logger.info("Session registered", {
-      taskId: context.taskId,
-      runId: context.runId,
-    });
     this.sessions.set(sessionId, { context, currentTurnMessages: [] });
 
     this.lastFlushAttemptTime.set(sessionId, Date.now());