@posthog/agent 2.3.104 → 2.3.116

package/dist/server/bin.cjs

@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // 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: {
@@ -5433,22 +5433,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 {
@@ -5464,8 +5483,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);
@@ -5565,11 +5584,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 [];
@@ -11340,9 +11357,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);
@@ -11398,7 +11415,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;
@@ -11424,7 +11445,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));
@@ -11442,7 +11469,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;
@@ -11491,11 +11517,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;
@@ -11540,6 +11572,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) {
@@ -12151,7 +12192,9 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
         }
         let assistantMessage;
         try {
-          await this.session.logWriter.flush(this.session.payload.run_id);
+          await this.session.logWriter.flush(this.session.payload.run_id, {
+            coalesce: true
+          });
           assistantMessage = this.session.logWriter.getFullAgentResponse(
             this.session.payload.run_id
           );
@@ -12324,6 +12367,9 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
       }
     });
     this.logger.info("Session initialized successfully");
+    this.logger.info(
+      `Agent version: ${this.config.version ?? package_default.version}`
+    );
     this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {
       status: "in_progress"
     }).catch(
@@ -12601,7 +12647,9 @@ Important:
   async signalTaskComplete(payload, stopReason) {
     if (this.session?.payload.run_id === payload.run_id) {
       try {
-        await this.session.logWriter.flush(payload.run_id);
+        await this.session.logWriter.flush(payload.run_id, {
+          coalesce: true
+        });
       } catch (error) {
         this.logger.warn("Failed to flush session logs before completion", {
           taskId: payload.task_id,
@@ -12710,7 +12758,7 @@ Important:
       return;
     }
     try {
-      await this.session.logWriter.flush(payload.run_id);
+      await this.session.logWriter.flush(payload.run_id, { coalesce: true });
     } catch (error) {
       this.logger.warn("Failed to flush logs before Slack relay", {
         taskId: payload.task_id,
@@ -12859,7 +12907,9 @@ Important:
       this.logger.error("Failed to capture final tree state", error);
     }
     try {
-      await this.session.logWriter.flush(this.session.payload.run_id);
+      await this.session.logWriter.flush(this.session.payload.run_id, {
+        coalesce: true
+      });
     } catch (error) {
       this.logger.error("Failed to flush session logs", error);
     }