@posthog/agent 2.3.104 → 2.3.116

package/dist/agent.js

@@ -371,7 +371,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.104",
+  version: "2.3.116",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -4530,22 +4530,41 @@ var PostHogAPIClient = class {
     const host = this.config.apiUrl.endsWith("/") ? this.config.apiUrl.slice(0, -1) : this.config.apiUrl;
     return host;
   }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.getApiKey()}`,
-      "Content-Type": "application/json",
-      "User-Agent": this.config.userAgent ?? DEFAULT_USER_AGENT
-    };
+  isAuthFailure(status) {
+    return status === 401 || status === 403;
   }
-  async apiRequest(endpoint, options = {}) {
+  async resolveApiKey(forceRefresh = false) {
+    if (forceRefresh && this.config.refreshApiKey) {
+      return this.config.refreshApiKey();
+    }
+    return this.config.getApiKey();
+  }
+  async buildHeaders(options, forceRefresh = false) {
+    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;
+  }
+  async performRequest(endpoint, options, forceRefresh = false) {
     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)
     });
+  }
+  async performRequestWithRetry(endpoint, options = {}) {
+    let response = await this.performRequest(endpoint, options);
+    if (!response.ok && this.isAuthFailure(response.status)) {
+      response = await this.performRequest(endpoint, options, true);
+    }
+    return response;
+  }
+  async apiRequest(endpoint, options = {}) {
+    const response = await this.performRequestWithRetry(endpoint, options);
     if (!response.ok) {
       let errorMessage;
       try {
@@ -4561,8 +4580,8 @@ var PostHogAPIClient = class {
   getTeamId() {
     return this.config.projectId;
   }
-  getApiKey() {
-    return this.config.getApiKey();
+  async getApiKey(forceRefresh = false) {
+    return this.resolveApiKey(forceRefresh);
   }
   getLlmGatewayUrl() {
     return getLlmGatewayUrl(this.baseUrl);
@@ -4662,11 +4681,9 @@ var PostHogAPIClient = class {
    */
   async fetchTaskRunLogs(taskRun) {
     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) {
           return [];
@@ -4713,9 +4730,9 @@ var SessionLogWriter = class _SessionLogWriter {
     this.logger = options.logger ?? new Logger({ debug: false, prefix: "[SessionLogWriter]" });
   }
   async flushAll() {
-    const sessionIds = [...this.sessions.keys()];
     const flushPromises = [];
-    for (const sessionId of sessionIds) {
+    for (const [sessionId, session] of this.sessions) {
+      this.emitCoalescedMessage(sessionId, session);
       flushPromises.push(this.flush(sessionId));
     }
     await Promise.all(flushPromises);
@@ -4771,7 +4788,11 @@ var SessionLogWriter = class _SessionLogWriter {
         }
         return;
       }
-      this.emitCoalescedMessage(sessionId, session);
+      if (this.isDirectAgentMessage(message) && session.chunkBuffer) {
+        session.chunkBuffer = void 0;
+      } else {
+        this.emitCoalescedMessage(sessionId, session);
+      }
       const nonChunkAgentText = this.extractAgentMessageText(message);
       if (nonChunkAgentText) {
         session.lastAgentMessage = nonChunkAgentText;
@@ -4797,7 +4818,13 @@ var SessionLogWriter = class _SessionLogWriter {
       });
     }
   }
-  async flush(sessionId) {
+  async flush(sessionId, { coalesce = false } = {}) {
+    if (coalesce) {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        this.emitCoalescedMessage(sessionId, session);
+      }
+    }
     const prev = this.flushQueues.get(sessionId) ?? Promise.resolve();
     const next = prev.catch(() => {
     }).then(() => this._doFlush(sessionId));
@@ -4815,7 +4842,6 @@ var SessionLogWriter = class _SessionLogWriter {
       this.logger.warn("flush: no session found", { sessionId });
       return;
     }
-    this.emitCoalescedMessage(sessionId, session);
     const pending = this.pendingEntries.get(sessionId);
     if (!this.posthogAPI || !pending?.length) {
       return;
@@ -4864,11 +4890,17 @@ var SessionLogWriter = class _SessionLogWriter {
       }
     }
   }
-  isAgentMessageChunk(message) {
-    if (message.method !== "session/update") return false;
+  getSessionUpdateType(message) {
+    if (message.method !== "session/update") return void 0;
     const params = message.params;
     const update = params?.update;
-    return update?.sessionUpdate === "agent_message_chunk";
+    return update?.sessionUpdate;
+  }
+  isDirectAgentMessage(message) {
+    return this.getSessionUpdateType(message) === "agent_message";
+  }
+  isAgentMessageChunk(message) {
+    return this.getSessionUpdateType(message) === "agent_message_chunk";
   }
   extractChunkText(message) {
     const params = message.params;
@@ -4913,6 +4945,15 @@ var SessionLogWriter = class _SessionLogWriter {
   getFullAgentResponse(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session || session.currentTurnMessages.length === 0) return void 0;
+    if (session.chunkBuffer) {
+      this.logger.warn(
+        "getFullAgentResponse called with non-empty chunk buffer",
+        {
+          sessionId,
+          bufferedLength: session.chunkBuffer.text.length
+        }
+      );
+    }
     return session.currentTurnMessages.join("\n\n");
   }
   resetTurnMessages(sessionId) {
@@ -5036,13 +5077,13 @@ var Agent = class {
       }
     }
   }
-  _configureLlmGateway(overrideUrl) {
+  async _configureLlmGateway(overrideUrl) {
     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;
       process.env.ANTHROPIC_BASE_URL = gatewayUrl;
@@ -5054,7 +5095,7 @@ var Agent = class {
     }
   }
   async run(taskId, taskRunId, options = {}) {
-    const gatewayConfig = this._configureLlmGateway(options.gatewayUrl);
+    const gatewayConfig = await this._configureLlmGateway(options.gatewayUrl);
     this.logger.info("Configured LLM gateway", {
       adapter: options.adapter
     });
@@ -5131,7 +5172,7 @@ var Agent = class {
   }
   async cleanup() {
     if (this.sessionLogWriter && this.taskRunId) {
-      await this.sessionLogWriter.flush(this.taskRunId);
+      await this.sessionLogWriter.flush(this.taskRunId, { coalesce: true });
     }
     await this.acpConnection?.cleanup();
   }