@posthog/agent 2.3.93 → 2.3.110

package/dist/types.d.ts

@@ -88,7 +88,8 @@ type LogLevel = "debug" | "info" | "warn" | "error";
 type OnLogCallback = (level: LogLevel, scope: string, message: string, data?: unknown) => void;
 interface PostHogAPIConfig {
     apiUrl: string;
-    getApiKey: () => string;
+    getApiKey: () => string | Promise<string>;
+    refreshApiKey?: () => string | Promise<string>;
     projectId: number;
     userAgent?: string;
 }

package/package.json

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

package/src/agent.ts

@@ -45,17 +45,17 @@ export class Agent {
     }
   }
 
-  private _configureLlmGateway(overrideUrl?: string): {
+  private async _configureLlmGateway(overrideUrl?: string): Promise<{
     gatewayUrl: string;
     apiKey: string;
-  } | null {
+  } | null> {
     if (!this.posthogAPI) {
       return null;
     }
 
     try {
       const gatewayUrl = overrideUrl ?? this.posthogAPI.getLlmGatewayUrl();
-      const apiKey = this.posthogAPI.getApiKey();
+      const apiKey = await this.posthogAPI.getApiKey();
 
       process.env.OPENAI_BASE_URL = `${gatewayUrl}/v1`;
       process.env.OPENAI_API_KEY = apiKey;
@@ -74,7 +74,7 @@ export class Agent {
     taskRunId: string,
     options: TaskExecutionOptions = {},
   ): Promise<InProcessAcpConnection> {
-    const gatewayConfig = this._configureLlmGateway(options.gatewayUrl);
+    const gatewayConfig = await this._configureLlmGateway(options.gatewayUrl);
     this.logger.info("Configured LLM gateway", {
       adapter: options.adapter,
     });

package/src/posthog-api.test.ts

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { PostHogAPIClient } from "./posthog-api";
+
+const mockFetch = vi.fn();
+
+vi.stubGlobal("fetch", mockFetch);
+
+describe("PostHogAPIClient", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("refreshes once when fetching task run logs gets an auth failure", async () => {
+    const getApiKey = vi.fn().mockResolvedValue("stale-token");
+    const refreshApiKey = vi.fn().mockResolvedValue("fresh-token");
+    const client = new PostHogAPIClient({
+      apiUrl: "https://app.posthog.com",
+      getApiKey,
+      refreshApiKey,
+      projectId: 1,
+    });
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        text: vi
+          .fn()
+          .mockResolvedValue(
+            `${JSON.stringify({ type: "notification", notification: { method: "foo" } })}\n`,
+          ),
+      });
+
+    const logs = await client.fetchTaskRunLogs({
+      id: "run-1",
+      task: "task-1",
+    } as never);
+
+    expect(logs).toHaveLength(1);
+    expect(getApiKey).toHaveBeenCalledTimes(1);
+    expect(refreshApiKey).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+});

package/src/posthog-api.ts

@@ -47,27 +47,63 @@ export class PostHogAPIClient {
     return host;
   }
 
-  private get headers(): Record<string, string> {
-    return {
-      Authorization: `Bearer ${this.config.getApiKey()}`,
-      "Content-Type": "application/json",
-      "User-Agent": this.config.userAgent ?? DEFAULT_USER_AGENT,
-    };
+  private isAuthFailure(status: number): boolean {
+    return status === 401 || status === 403;
   }
 
-  private async apiRequest<T>(
+  private async resolveApiKey(forceRefresh = false): Promise<string> {
+    if (forceRefresh && this.config.refreshApiKey) {
+      return this.config.refreshApiKey();
+    }
+
+    return this.config.getApiKey();
+  }
+
+  private async buildHeaders(
+    options: RequestInit,
+    forceRefresh = false,
+  ): Promise<Headers> {
+    const headers = new Headers(options.headers);
+    headers.set(
+      "Authorization",
+      `Bearer ${await this.resolveApiKey(forceRefresh)}`,
+    );
+    headers.set("Content-Type", "application/json");
+    headers.set("User-Agent", this.config.userAgent ?? DEFAULT_USER_AGENT);
+    return headers;
+  }
+
+  private async performRequest(
     endpoint: string,
-    options: RequestInit = {},
-  ): Promise<T> {
+    options: RequestInit,
+    forceRefresh = false,
+  ): Promise<Response> {
     const url = `${this.baseUrl}${endpoint}`;
 
-    const response = await fetch(url, {
+    return fetch(url, {
       ...options,
-      headers: {
-        ...this.headers,
-        ...options.headers,
-      },
+      headers: await this.buildHeaders(options, forceRefresh),
     });
+  }
+
+  private async performRequestWithRetry(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<Response> {
+    let response = await this.performRequest(endpoint, options);
+
+    if (!response.ok && this.isAuthFailure(response.status)) {
+      response = await this.performRequest(endpoint, options, true);
+    }
+
+    return response;
+  }
+
+  private async apiRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const response = await this.performRequestWithRetry(endpoint, options);
 
     if (!response.ok) {
       let errorMessage: string;
@@ -87,8 +123,8 @@ export class PostHogAPIClient {
     return this.config.projectId;
   }
 
-  getApiKey(): string {
-    return this.config.getApiKey();
+  async getApiKey(forceRefresh = false): Promise<string> {
+    return this.resolveApiKey(forceRefresh);
   }
 
   getLlmGatewayUrl(): string {
@@ -228,12 +264,10 @@ export class PostHogAPIClient {
    */
   async fetchTaskRunLogs(taskRun: TaskRun): Promise<StoredEntry[]> {
     const teamId = this.getTeamId();
+    const endpoint = `/api/projects/${teamId}/tasks/${taskRun.task}/runs/${taskRun.id}/logs`;
 
     try {
-      const response = await fetch(
-        `${this.baseUrl}/api/projects/${teamId}/tasks/${taskRun.task}/runs/${taskRun.id}/logs`,
-        { headers: this.headers },
-      );
+      const response = await this.performRequestWithRetry(endpoint);
 
       if (!response.ok) {
         if (response.status === 404) {

package/src/session-log-writer.test.ts

@@ -168,4 +168,91 @@ describe("SessionLogWriter", () => {
       expect(logWriter.isRegistered(sessionId)).toBe(true);
     });
   });
+
+  describe("flush serialization", () => {
+    it("serializes concurrent flush calls so they do not overlap", async () => {
+      const sessionId = "s1";
+      logWriter.register(sessionId, { taskId: "t1", runId: sessionId });
+
+      const callOrder: string[] = [];
+      let resolveFirst!: () => void;
+      const firstBlocked = new Promise<void>((r) => {
+        resolveFirst = r;
+      });
+
+      mockAppendLog
+        .mockImplementationOnce(async () => {
+          callOrder.push("first-start");
+          // Add a new entry while the first flush is in-flight
+          logWriter.appendRawLine(sessionId, JSON.stringify({ method: "b" }));
+          await firstBlocked;
+          callOrder.push("first-end");
+        })
+        .mockImplementationOnce(async () => {
+          callOrder.push("second-start");
+        });
+
+      logWriter.appendRawLine(sessionId, JSON.stringify({ method: "a" }));
+      const flush1 = logWriter.flush(sessionId);
+
+      // Wait for the first flush to be in-flight — "b" is added inside the mock
+      await vi.waitFor(() => expect(callOrder).toContain("first-start"));
+
+      // Queue a second flush for the entry added while first was in-flight
+      const flush2 = logWriter.flush(sessionId);
+
+      // First flush is blocked — second should not have started
+      expect(callOrder).not.toContain("second-start");
+
+      // Unblock first flush
+      resolveFirst?.();
+      await flush1;
+      await flush2;
+
+      // Second started only after first completed
+      expect(callOrder).toEqual(["first-start", "first-end", "second-start"]);
+    });
+
+    it("does not lose entries when flushes are serialized", async () => {
+      const sessionId = "s1";
+      logWriter.register(sessionId, { taskId: "t1", runId: sessionId });
+
+      let resolveFirst!: () => void;
+      const firstBlocked = new Promise<void>((r) => {
+        resolveFirst = r;
+      });
+
+      mockAppendLog
+        .mockImplementationOnce(async () => {
+          // Add a new entry while the first flush is in-flight — simulates
+          // the agent emitting end_turn while a scheduled flush is sending
+          // earlier entries to S3.
+          logWriter.appendRawLine(sessionId, JSON.stringify({ method: "b" }));
+          await firstBlocked;
+        })
+        .mockImplementationOnce(async () => undefined);
+
+      // Batch 1
+      logWriter.appendRawLine(sessionId, JSON.stringify({ method: "a" }));
+      const flush1 = logWriter.flush(sessionId);
+
+      // Wait for first flush to be in-flight (and "b" to be added)
+      await vi.waitFor(() => expect(mockAppendLog).toHaveBeenCalledTimes(1));
+
+      // Queue flush for the entry added while first was in-flight
+      const flush2 = logWriter.flush(sessionId);
+
+      resolveFirst?.();
+      await flush1;
+      await flush2;
+
+      expect(mockAppendLog).toHaveBeenCalledTimes(2);
+      const batch1: StoredNotification[] = mockAppendLog.mock.calls[0][2];
+      const batch2: StoredNotification[] = mockAppendLog.mock.calls[1][2];
+      expect(batch1).toHaveLength(1);
+      expect(batch1[0].notification.method).toBe("a");
+      expect(batch2).toHaveLength(1);
+      expect(batch2[0].notification.method).toBe("b");
+    });
+  });
 });

package/src/session-log-writer.ts

@@ -40,6 +40,7 @@ export class SessionLogWriter {
   private lastFlushAttemptTime: Map<string, number> = new Map();
   private retryCounts: Map<string, number> = new Map();
   private sessions: Map<string, SessionState> = new Map();
+  private flushQueues: Map<string, Promise<void>> = new Map();
 
   private logger: Logger;
   private localCachePath?: string;
@@ -155,6 +156,19 @@ export class SessionLogWriter {
   }
 
   async flush(sessionId: string): Promise<void> {
+    // Serialize flushes per session
+    const prev = this.flushQueues.get(sessionId) ?? Promise.resolve();
+    const next = prev.catch(() => {}).then(() => this._doFlush(sessionId));
+    this.flushQueues.set(sessionId, next);
+    next.finally(() => {
+      if (this.flushQueues.get(sessionId) === next) {
+        this.flushQueues.delete(sessionId);
+      }
+    });
+    return next;
+  }
+
+  private async _doFlush(sessionId: string): Promise<void> {
     const session = this.sessions.get(sessionId);
     if (!session) {
       this.logger.warn("flush: no session found", { sessionId });

package/src/types.ts

@@ -126,7 +126,8 @@ export type OnLogCallback = (
 
 export interface PostHogAPIConfig {
   apiUrl: string;
-  getApiKey: () => string;
+  getApiKey: () => string | Promise<string>;
+  refreshApiKey?: () => string | Promise<string>;
   projectId: number;
   userAgent?: string;
 }