@posthog/agent 2.3.104 → 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.104",
+  "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/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;
 }