@posthog/agent 2.1.22 → 2.1.29

package/dist/server/agent-server.js

@@ -1183,7 +1183,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.1.22",
+  version: "2.1.29",
   repository: "https://github.com/PostHog/twig",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -4266,19 +4266,36 @@ var PostHogAPIClient = class {
 };
 
 // src/session-log-writer.ts
-var SessionLogWriter = class {
+var SessionLogWriter = class _SessionLogWriter {
+  static FLUSH_DEBOUNCE_MS = 500;
+  static FLUSH_MAX_INTERVAL_MS = 5e3;
+  static MAX_FLUSH_RETRIES = 10;
+  static MAX_RETRY_DELAY_MS = 3e4;
   posthogAPI;
   pendingEntries = /* @__PURE__ */ new Map();
   flushTimeouts = /* @__PURE__ */ new Map();
+  lastFlushAttemptTime = /* @__PURE__ */ new Map();
+  retryCounts = /* @__PURE__ */ new Map();
   sessions = /* @__PURE__ */ new Map();
+  messageCounts = /* @__PURE__ */ new Map();
   logger;
   constructor(options = {}) {
     this.posthogAPI = options.posthogAPI;
     this.logger = options.logger ?? new Logger({ debug: false, prefix: "[SessionLogWriter]" });
   }
   async flushAll() {
+    const sessionIds = [...this.sessions.keys()];
+    const pendingCounts = sessionIds.map((id) => ({
+      id,
+      pending: this.pendingEntries.get(id)?.length ?? 0,
+      messages: this.messageCounts.get(id) ?? 0
+    }));
+    this.logger.info("flushAll called", {
+      sessions: sessionIds.length,
+      pending: pendingCounts
+    });
     const flushPromises = [];
-    for (const sessionId of this.sessions.keys()) {
+    for (const sessionId of sessionIds) {
       flushPromises.push(this.flush(sessionId));
     }
     await Promise.all(flushPromises);
@@ -4287,7 +4304,12 @@ var SessionLogWriter = class {
     if (this.sessions.has(sessionId)) {
       return;
     }
+    this.logger.info("Session registered", {
+      sessionId,
+      taskId: context.taskId
+    });
     this.sessions.set(sessionId, { context });
+    this.lastFlushAttemptTime.set(sessionId, Date.now());
   }
   isRegistered(sessionId) {
     return this.sessions.has(sessionId);
@@ -4295,8 +4317,16 @@ var SessionLogWriter = class {
   appendRawLine(sessionId, line) {
     const session = this.sessions.get(sessionId);
     if (!session) {
+      this.logger.warn("appendRawLine called for unregistered session", {
+        sessionId
+      });
       return;
     }
+    const count = (this.messageCounts.get(sessionId) ?? 0) + 1;
+    this.messageCounts.set(sessionId, count);
+    if (count % 10 === 1) {
+      this.logger.info("Messages received", { count, sessionId });
+    }
     try {
       const message = JSON.parse(line);
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -4332,24 +4362,56 @@ var SessionLogWriter = class {
   }
   async flush(sessionId) {
     const session = this.sessions.get(sessionId);
-    if (!session) return;
+    if (!session) {
+      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;
+    if (!this.posthogAPI || !pending?.length) {
+      this.logger.info("flush: nothing to persist", {
+        sessionId,
+        hasPosthogAPI: !!this.posthogAPI,
+        pendingCount: pending?.length ?? 0
+      });
+      return;
+    }
     this.pendingEntries.delete(sessionId);
     const timeout = this.flushTimeouts.get(sessionId);
     if (timeout) {
       clearTimeout(timeout);
       this.flushTimeouts.delete(sessionId);
     }
+    this.lastFlushAttemptTime.set(sessionId, Date.now());
     try {
       await this.posthogAPI.appendTaskRunLog(
         session.context.taskId,
         session.context.runId,
         pending
       );
+      this.retryCounts.set(sessionId, 0);
+      this.logger.info("Flushed session logs", {
+        sessionId,
+        entryCount: pending.length
+      });
     } catch (error) {
-      this.logger.error("Failed to persist session logs:", error);
+      const retryCount = (this.retryCounts.get(sessionId) ?? 0) + 1;
+      this.retryCounts.set(sessionId, retryCount);
+      if (retryCount >= _SessionLogWriter.MAX_FLUSH_RETRIES) {
+        this.logger.error(
+          `Dropping ${pending.length} session log entries after ${retryCount} failed flush attempts`,
+          { sessionId, error }
+        );
+        this.retryCounts.set(sessionId, 0);
+      } else {
+        this.logger.error(
+          `Failed to persist session logs (attempt ${retryCount}/${_SessionLogWriter.MAX_FLUSH_RETRIES}):`,
+          error
+        );
+        const currentPending = this.pendingEntries.get(sessionId) ?? [];
+        this.pendingEntries.set(sessionId, [...pending, ...currentPending]);
+        this.scheduleFlush(sessionId);
+      }
     }
   }
   isAgentMessageChunk(message) {
@@ -4395,7 +4457,21 @@ var SessionLogWriter = class {
   scheduleFlush(sessionId) {
     const existing = this.flushTimeouts.get(sessionId);
     if (existing) clearTimeout(existing);
-    const timeout = setTimeout(() => this.flush(sessionId), 500);
+    const retryCount = this.retryCounts.get(sessionId) ?? 0;
+    const lastAttempt = this.lastFlushAttemptTime.get(sessionId) ?? 0;
+    const elapsed = Date.now() - lastAttempt;
+    let delay2;
+    if (retryCount > 0) {
+      delay2 = Math.min(
+        _SessionLogWriter.FLUSH_DEBOUNCE_MS * 2 ** retryCount,
+        _SessionLogWriter.MAX_RETRY_DELAY_MS
+      );
+    } else if (elapsed >= _SessionLogWriter.FLUSH_MAX_INTERVAL_MS) {
+      delay2 = 0;
+    } else {
+      delay2 = _SessionLogWriter.FLUSH_DEBOUNCE_MS;
+    }
+    const timeout = setTimeout(() => this.flush(sessionId), delay2);
     this.flushTimeouts.set(sessionId, timeout);
   }
 };
@@ -10369,6 +10445,7 @@ var AgentServer = class {
       });
       const mode = this.getEffectiveMode(payload);
       if (mode === "background") {
+        await this.session.logWriter.flushAll();
         await this.signalTaskComplete(payload, result.stopReason);
       } else {
         this.logger.info("Interactive mode - staying open for conversation");
@@ -10377,6 +10454,9 @@ var AgentServer = class {
       this.logger.error("Failed to send initial task message", error);
       const mode = this.getEffectiveMode(payload);
       if (mode === "background") {
+        if (this.session) {
+          await this.session.logWriter.flushAll();
+        }
         await this.signalTaskComplete(payload, "error");
       }
     }
@@ -10391,10 +10471,24 @@ After completing the requested changes:
 3. Push the branch to origin
 4. Create a pull request using \`gh pr create\` with a descriptive title and body
 
-Important: Always create the PR. Do not ask for confirmation.
+Important:
+- Always create the PR. Do not ask for confirmation.
+- Do NOT add "Co-Authored-By" trailers to commit messages.
+- Do NOT add "Generated with [Claude Code]" or similar attribution lines to PR descriptions.
 `;
   }
   async signalTaskComplete(payload, stopReason) {
+    if (this.session?.payload.run_id === payload.run_id) {
+      try {
+        await this.session.logWriter.flush(payload.run_id);
+      } catch (error) {
+        this.logger.warn("Failed to flush session logs before completion", {
+          taskId: payload.task_id,
+          runId: payload.run_id,
+          error
+        });
+      }
+    }
     const status = stopReason === "cancelled" ? "cancelled" : stopReason === "error" ? "failed" : "completed";
     try {
       await this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {