@posthog/agent 2.3.126 → 2.3.137

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.126",
+  "version": "2.3.137",
   "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/claude/claude-agent.ts

@@ -876,58 +876,92 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       { sessionId, taskId, taskRunId: meta?.taskRunId },
     );
 
-    try {
-      const result = await withTimeout(
-        q.initializationResult(),
-        SESSION_VALIDATION_TIMEOUT_MS,
-      );
-      if (result.result === "timeout") {
-        throw new Error(
-          `Session ${isResume ? (forkSession ? "fork" : "resumption") : "initialization"} timed out for sessionId=${sessionId}`,
+    if (isResume) {
+      // Resume must block on initialization to validate the session is still alive.
+      // For stale sessions this throws (e.g. "No conversation found").
+      try {
+        const result = await withTimeout(
+          q.initializationResult(),
+          SESSION_VALIDATION_TIMEOUT_MS,
         );
+        if (result.result === "timeout") {
+          throw new Error(
+            `Session ${forkSession ? "fork" : "resumption"} timed out for sessionId=${sessionId}`,
+          );
+        }
+      } catch (err) {
+        settingsManager.dispose();
+        if (
+          err instanceof Error &&
+          err.message === "Query closed before response received"
+        ) {
+          throw RequestError.resourceNotFound(sessionId);
+        }
+        this.logger.error(
+          forkSession ? "Session fork failed" : "Session resumption failed",
+          {
+            sessionId,
+            taskId,
+            taskRunId: meta?.taskRunId,
+            error: err instanceof Error ? err.message : String(err),
+          },
+        );
+        throw err;
       }
-    } catch (err) {
-      settingsManager.dispose();
-      if (
-        isResume &&
-        err instanceof Error &&
-        err.message === "Query closed before response received"
-      ) {
-        throw RequestError.resourceNotFound(sessionId);
-      }
-      this.logger.error(
-        isResume
-          ? forkSession
-            ? "Session fork failed"
-            : "Session resumption failed"
-          : "Session initialization failed",
-        {
+    }
+
+    // Kick off SDK initialization for new sessions so it runs concurrently
+    // with the model config fetch below (the gateway REST call is independent).
+    const initPromise = !isResume
+      ? withTimeout(q.initializationResult(), SESSION_VALIDATION_TIMEOUT_MS)
+      : undefined;
+
+    const [modelOptions] = await Promise.all([
+      this.getModelConfigOptions(
+        settingsManager.getSettings().model || meta?.model || undefined,
+      ),
+      ...(meta?.taskRunId
+        ? [
+            this.client.extNotification("_posthog/sdk_session", {
+              taskRunId: meta.taskRunId,
+              sessionId,
+              adapter: "claude",
+            }),
+          ]
+        : []),
+    ]);
+
+    if (initPromise) {
+      try {
+        const initResult = await initPromise;
+        if (initResult.result === "timeout") {
+          settingsManager.dispose();
+          throw new Error(
+            `Session initialization timed out for sessionId=${sessionId}`,
+          );
+        }
+      } catch (err) {
+        settingsManager.dispose();
+        this.logger.error("Session initialization failed", {
           sessionId,
           taskId,
           taskRunId: meta?.taskRunId,
           error: err instanceof Error ? err.message : String(err),
-        },
-      );
-      throw err;
-    }
-
-    if (meta?.taskRunId) {
-      await this.client.extNotification("_posthog/sdk_session", {
-        taskRunId: meta.taskRunId,
-        sessionId,
-        adapter: "claude",
-      });
+        });
+        throw err;
+      }
     }
 
-    // Resolve model: settings model takes priority, then gateway
     const settingsModel = settingsManager.getSettings().model;
-    const modelOptions = await this.getModelConfigOptions();
-    const resolvedModelId = settingsModel || modelOptions.currentModelId;
+    const metaModel = meta?.model;
+    const resolvedModelId =
+      settingsModel || metaModel || modelOptions.currentModelId;
     session.modelId = resolvedModelId;
     session.lastContextWindowSize =
       this.getContextWindowForModel(resolvedModelId);
 
     const resolvedSdkModel = toSdkModelId(resolvedModelId);
+
     if (!isResume && resolvedSdkModel !== DEFAULT_MODEL) {
       await this.session.query.setModel(resolvedSdkModel);
     }

package/src/adapters/claude/types.ts

@@ -108,6 +108,8 @@ export type NewSessionMeta = {
   persistence?: { taskId?: string; runId?: string; logUrl?: string };
   additionalRoots?: string[];
   allowedDomains?: string[];
+  /** Model ID to use for this session (e.g. "claude-sonnet-4-6") */
+  model?: string;
   claudeCode?: {
     options?: Options;
   };

package/src/server/agent-server.ts

@@ -169,6 +169,12 @@ export class AgentServer {
   private initializationPromise: Promise<void> | null = null;
   private pendingEvents: Record<string, unknown>[] = [];
 
+  private detachSseController(controller: SseController): void {
+    if (this.session?.sseController === controller) {
+      this.session.sseController = null;
+    }
+  }
+
   private emitConsoleLog = (
     level: LogLevel,
     _scope: string,
@@ -250,18 +256,15 @@ export class AgentServer {
                 controller.enqueue(
                   new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`),
                 );
-              } catch (error) {
-                this.logger.debug(
-                  "SSE send failed (stream may be closed)",
-                  error,
-                );
+              } catch {
+                this.detachSseController(sseController);
               }
             },
             close: () => {
               try {
                 controller.close();
-              } catch (error) {
-                this.logger.debug("SSE close failed (already closed)", error);
+              } catch {
+                this.detachSseController(sseController);
               }
             },
           };
@@ -1577,6 +1580,10 @@ Important:
   }
 
   private sendSseEvent(controller: SseController, data: unknown): void {
-    controller.send(data);
+    try {
+      controller.send(data);
+    } catch {
+      this.detachSseController(controller);
+    }
   }
 }

package/src/server/question-relay.test.ts

@@ -235,6 +235,71 @@ describe("Question relay", () => {
 
         expect(result.outcome.outcome).toBe("selected");
       });
+
+      it("keeps auto-approving permissions after SSE send failures", async () => {
+        const appendRawLine = vi.fn();
+        const brokenSseController = {
+          send: vi.fn(() => {
+            throw new Error("stream closed");
+          }),
+          close: vi.fn(),
+        };
+
+        const cloudPermissionServer = server as TestableAgentServer & {
+          emitConsoleLog: (
+            level: "debug" | "info" | "warn" | "error",
+            scope: string,
+            message: string,
+            data?: unknown,
+          ) => void;
+          logger: { debug: (message: string, data?: unknown) => void };
+          session: {
+            payload: typeof TEST_PAYLOAD;
+            sseController: typeof brokenSseController | null;
+            logWriter: {
+              appendRawLine: (runId: string, line: string) => void;
+            };
+          };
+        };
+
+        cloudPermissionServer.session = {
+          payload: TEST_PAYLOAD,
+          sseController: brokenSseController,
+          logWriter: {
+            appendRawLine,
+          },
+        };
+        cloudPermissionServer.logger = {
+          debug: (message: string, data?: unknown) => {
+            cloudPermissionServer.emitConsoleLog(
+              "debug",
+              "agent",
+              message,
+              data,
+            );
+          },
+        };
+
+        const client = cloudPermissionServer.createCloudClient(TEST_PAYLOAD);
+
+        const firstResult = await client.requestPermission({
+          options: ALLOW_OPTIONS,
+          toolCall: { _meta: { codeToolKind: "bash" } },
+        });
+
+        expect(firstResult.outcome.outcome).toBe("selected");
+        expect(brokenSseController.send).toHaveBeenCalledTimes(1);
+        expect(cloudPermissionServer.session.sseController).toBeNull();
+
+        const secondResult = await client.requestPermission({
+          options: ALLOW_OPTIONS,
+          toolCall: { _meta: { codeToolKind: "bash" } },
+        });
+
+        expect(secondResult.outcome.outcome).toBe("selected");
+        expect(brokenSseController.send).toHaveBeenCalledTimes(1);
+        expect(appendRawLine).toHaveBeenCalledTimes(2);
+      });
     });
   });