@posthog/agent 1.21.0 → 1.24.0

package/src/task-manager.ts

@@ -1,9 +1,9 @@
-import { randomBytes } from 'crypto';
+import { randomBytes } from "node:crypto";
 
 export interface TaskExecutionState {
   taskId: string;
-  status: 'running' | 'completed' | 'failed' | 'canceled' | 'timeout';
-  mode: 'plan_only' | 'plan_and_build' | 'build_only';
+  status: "running" | "completed" | "failed" | "canceled" | "timeout";
+  mode: "plan_only" | "plan_and_build" | "build_only";
   result?: any;
   startedAt: number;
   completedAt?: number;
@@ -11,21 +11,21 @@ export interface TaskExecutionState {
 }
 
 export class TaskManager {
-  private executionStates = new Map<string, TaskExecutionState>();
+  public executionStates = new Map<string, TaskExecutionState>();
   private defaultTimeout = 10 * 60 * 1000; // 10 minutes
 
   generateExecutionId(): string {
-    return randomBytes(16).toString('hex');
+    return randomBytes(16).toString("hex");
   }
 
   startExecution(
-    taskId: string, 
-    mode: 'plan_only' | 'plan_and_build' | 'build_only',
-    executionId: string = this.generateExecutionId()
+    taskId: string,
+    mode: "plan_only" | "plan_and_build" | "build_only",
+    executionId: string = this.generateExecutionId(),
   ): TaskExecutionState {
     const executionState: TaskExecutionState = {
       taskId,
-      status: 'running',
+      status: "running",
       mode,
       startedAt: Date.now(),
       abortController: new AbortController(),
@@ -33,7 +33,7 @@ export class TaskManager {
 
     this.executionStates.set(executionId, executionState);
     this.scheduleTimeout(executionId);
-    
+
     return executionState;
   }
 
@@ -43,7 +43,7 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    if (execution.result && execution.status === 'completed') {
+    if (execution.result && execution.status === "completed") {
       return execution.result;
     }
 
@@ -56,16 +56,21 @@ export class TaskManager {
           return;
         }
 
-        if (currentExecution.status === 'completed' && currentExecution.result) {
+        if (
+          currentExecution.status === "completed" &&
+          currentExecution.result
+        ) {
           clearInterval(checkInterval);
           resolve(currentExecution.result);
         } else if (
-          currentExecution.status === 'failed' || 
-          currentExecution.status === 'canceled' || 
-          currentExecution.status === 'timeout'
+          currentExecution.status === "failed" ||
+          currentExecution.status === "canceled" ||
+          currentExecution.status === "timeout"
         ) {
           clearInterval(checkInterval);
-          reject(new Error(`Execution ${executionId} ${currentExecution.status}`));
+          reject(
+            new Error(`Execution ${executionId} ${currentExecution.status}`),
+          );
         }
       }, 100);
     });
@@ -77,7 +82,7 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    execution.status = 'completed';
+    execution.status = "completed";
     execution.result = result;
     execution.completedAt = Date.now();
   }
@@ -88,11 +93,11 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    execution.status = 'failed';
+    execution.status = "failed";
     execution.completedAt = Date.now();
     execution.result = {
       error: error.message,
-      status: 'failed',
+      status: "failed",
     };
   }
 
@@ -102,14 +107,14 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    execution.status = 'canceled';
+    execution.status = "canceled";
     execution.completedAt = Date.now();
     execution.abortController?.abort();
-    
+
     if (!execution.result) {
       execution.result = {
-        status: 'canceled',
-        message: 'Execution was canceled',
+        status: "canceled",
+        message: "Execution was canceled",
       };
     }
   }
@@ -126,18 +131,21 @@ export class TaskManager {
     return this.executionStates.get(executionId)?.abortController;
   }
 
-  private scheduleTimeout(executionId: string, timeout: number = this.defaultTimeout): void {
+  private scheduleTimeout(
+    executionId: string,
+    timeout: number = this.defaultTimeout,
+  ): void {
     setTimeout(() => {
       const execution = this.executionStates.get(executionId);
-      if (execution && execution.status === 'running') {
-        execution.status = 'timeout';
+      if (execution && execution.status === "running") {
+        execution.status = "timeout";
         execution.completedAt = Date.now();
         execution.abortController?.abort();
-        
+
         if (!execution.result) {
           execution.result = {
-            status: 'timeout',
-            message: 'Execution timed out',
+            status: "timeout",
+            message: "Execution timed out",
           };
         }
       }
@@ -152,4 +160,4 @@ export class TaskManager {
       }
     }
   }
-}
+}

package/src/task-progress-reporter.ts

@@ -1,6 +1,6 @@
-import type { Logger } from './utils/logger.js';
-import type { PostHogAPIClient, TaskRunUpdate } from './posthog-api.js';
-import type { AgentEvent, TaskRun, LogEntry } from './types.js';
+import type { PostHogAPIClient, TaskRunUpdate } from "./posthog-api.js";
+import type { AgentEvent, LogEntry, TaskRun } from "./types.js";
+import type { Logger } from "./utils/logger.js";
 
 interface ProgressMetadata {
   totalSteps?: number;
@@ -17,10 +17,9 @@ export class TaskProgressReporter {
   private logger: Logger;
   private taskRun?: TaskRun;
   private taskId?: string;
-  private outputLog: string[] = [];
   private totalSteps?: number;
   private lastLogEntry?: string;
-  private tokenBuffer: string = '';
+  private tokenBuffer: string = "";
   private tokenCount: number = 0;
   private tokenFlushTimer?: NodeJS.Timeout;
   private readonly TOKEN_BATCH_SIZE = 100;
@@ -31,7 +30,7 @@ export class TaskProgressReporter {
 
   constructor(posthogAPI: PostHogAPIClient | undefined, logger: Logger) {
     this.posthogAPI = posthogAPI;
-    this.logger = logger.child('TaskProgressReporter');
+    this.logger = logger.child("TaskProgressReporter");
   }
 
   get runId(): string | undefined {
@@ -48,28 +47,49 @@ export class TaskProgressReporter {
 
     try {
       const run = await this.posthogAPI.createTaskRun(taskId, {
-        status: 'started',
+        status: "started",
       });
       this.taskRun = run;
-      this.outputLog = [];
-      this.logger.debug('Created task run', { taskId, runId: run.id });
+      this.logger.debug("Created task run", { taskId, runId: run.id });
     } catch (error) {
-      this.logger.warn('Failed to create task run', { taskId, error: (error as Error).message });
+      this.logger.warn("Failed to create task run", {
+        taskId,
+        error: (error as Error).message,
+      });
     }
   }
 
   async complete(): Promise<void> {
     await this.flushTokens(); // Flush any remaining tokens before completion
+    try {
+      await this.logWriteQueue;
+    } catch (error) {
+      this.logger.debug("Pending logs failed to write during completion", {
+        error,
+      });
+    }
+
     if (this.tokenFlushTimer) {
       clearTimeout(this.tokenFlushTimer);
       this.tokenFlushTimer = undefined;
     }
-    await this.update({ status: 'completed' }, 'Task execution completed');
+    await this.update({ status: "completed" }, "Task execution completed");
   }
 
   async fail(error: Error | string): Promise<void> {
-    const message = typeof error === 'string' ? error : error.message;
-    await this.update({ status: 'failed', error_message: message }, `Task execution failed: ${message}`);
+    try {
+      await this.logWriteQueue;
+    } catch (logError) {
+      this.logger.debug("Pending logs failed to write during fail", {
+        error: logError,
+      });
+    }
+
+    const message = typeof error === "string" ? error : error.message;
+    await this.update(
+      { status: "failed", error_message: message },
+      `Task execution failed: ${message}`,
+    );
   }
 
   async appendLog(line: string): Promise<void> {
@@ -82,11 +102,11 @@ export class TaskProgressReporter {
     }
 
     const buffer = this.tokenBuffer;
-    this.tokenBuffer = '';
+    this.tokenBuffer = "";
     this.tokenCount = 0;
 
     await this.appendLogEntry({
-      type: 'token',
+      type: "token",
       message: buffer,
     });
   }
@@ -99,7 +119,7 @@ export class TaskProgressReporter {
     this.tokenFlushTimer = setTimeout(() => {
       this.tokenFlushTimer = undefined;
       this.flushTokens().catch((err) => {
-        this.logger.warn('Failed to flush tokens', { error: err });
+        this.logger.warn("Failed to flush tokens", { error: err });
       });
     }, this.TOKEN_FLUSH_INTERVAL_MS);
   }
@@ -114,8 +134,7 @@ export class TaskProgressReporter {
 
     this.logWriteQueue = this.logWriteQueue
       .catch((error) => {
-        // Ensure previous failures don't block subsequent writes
-        this.logger.debug('Previous log append failed', {
+        this.logger.debug("Previous log append failed", {
           taskId,
           runId,
           error: error instanceof Error ? error.message : String(error),
@@ -140,7 +159,7 @@ export class TaskProgressReporter {
         await this.posthogAPI.appendTaskRunLog(taskId, runId, [entry]);
         return;
       } catch (error) {
-        this.logger.warn('Failed to append log entry', {
+        this.logger.warn("Failed to append log entry", {
           taskId,
           runId,
           attempt,
@@ -153,7 +172,7 @@ export class TaskProgressReporter {
         }
 
         const delayMs =
-          this.LOG_APPEND_RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+          this.LOG_APPEND_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
         await new Promise((resolve) => setTimeout(resolve, delayMs));
       }
     }
@@ -165,7 +184,7 @@ export class TaskProgressReporter {
     }
 
     switch (event.type) {
-      case 'token': {
+      case "token": {
         // Batch tokens for efficiency
         this.tokenBuffer += event.content;
         this.tokenCount++;
@@ -182,9 +201,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'content_block_start': {
+      case "content_block_start": {
         await this.appendLogEntry({
-          type: 'content_block_start',
+          type: "content_block_start",
           message: JSON.stringify({
             index: event.index,
             contentType: event.contentType,
@@ -196,9 +215,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'content_block_stop': {
+      case "content_block_stop": {
         await this.appendLogEntry({
-          type: 'content_block_stop',
+          type: "content_block_stop",
           message: JSON.stringify({
             index: event.index,
             ts: event.ts,
@@ -207,9 +226,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'message_start': {
+      case "message_start": {
         await this.appendLogEntry({
-          type: 'message_start',
+          type: "message_start",
           message: JSON.stringify({
             messageId: event.messageId,
             model: event.model,
@@ -219,9 +238,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'message_delta': {
+      case "message_delta": {
         await this.appendLogEntry({
-          type: 'message_delta',
+          type: "message_delta",
           message: JSON.stringify({
             stopReason: event.stopReason,
             stopSequence: event.stopSequence,
@@ -232,17 +251,17 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'message_stop': {
+      case "message_stop": {
         await this.appendLogEntry({
-          type: 'message_stop',
+          type: "message_stop",
           message: JSON.stringify({ ts: event.ts }),
         });
         return;
       }
 
-      case 'status': {
+      case "status": {
         await this.appendLogEntry({
-          type: 'status',
+          type: "status",
           message: JSON.stringify({
             phase: event.phase,
             kind: event.kind,
@@ -257,9 +276,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'artifact': {
+      case "artifact": {
         await this.appendLogEntry({
-          type: 'artifact',
+          type: "artifact",
           message: JSON.stringify({
             kind: event.kind,
             content: event.content,
@@ -269,9 +288,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'init': {
+      case "init": {
         await this.appendLogEntry({
-          type: 'init',
+          type: "init",
           message: JSON.stringify({
             model: event.model,
             tools: event.tools,
@@ -284,9 +303,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'metric': {
+      case "metric": {
         await this.appendLogEntry({
-          type: 'metric',
+          type: "metric",
           message: JSON.stringify({
             key: event.key,
             value: event.value,
@@ -297,9 +316,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'compact_boundary': {
+      case "compact_boundary": {
         await this.appendLogEntry({
-          type: 'compact_boundary',
+          type: "compact_boundary",
           message: JSON.stringify({
             trigger: event.trigger,
             preTokens: event.preTokens,
@@ -309,9 +328,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'tool_call': {
+      case "tool_call": {
         await this.appendLogEntry({
-          type: 'tool_call',
+          type: "tool_call",
           message: JSON.stringify({
             toolName: event.toolName,
             callId: event.callId,
@@ -323,9 +342,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'tool_result': {
+      case "tool_result": {
         await this.appendLogEntry({
-          type: 'tool_result',
+          type: "tool_result",
           message: JSON.stringify({
             toolName: event.toolName,
             callId: event.callId,
@@ -338,9 +357,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'error': {
+      case "error": {
         await this.appendLogEntry({
-          type: 'error',
+          type: "error",
           message: JSON.stringify({
             message: event.message,
             errorType: event.errorType,
@@ -351,9 +370,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'done': {
+      case "done": {
         await this.appendLogEntry({
-          type: 'done',
+          type: "done",
           message: JSON.stringify({
             result: event.result,
             durationMs: event.durationMs,
@@ -369,9 +388,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'user_message': {
+      case "user_message": {
         await this.appendLogEntry({
-          type: 'user_message',
+          type: "user_message",
           message: JSON.stringify({
             content: event.content,
             isSynthetic: event.isSynthetic,
@@ -381,14 +400,14 @@ export class TaskProgressReporter {
         return;
       }
 
-      case 'raw_sdk_event': {
+      case "raw_sdk_event": {
         // Skip raw SDK events - too verbose for persistence
         return;
       }
 
       default:
         // For any unfamiliar event types, log them as-is
-        this.logger.debug('Unknown event type', { type: (event as any).type });
+        this.logger.debug("Unknown event type", { type: (event as any).type });
         return;
     }
   }
@@ -402,11 +421,11 @@ export class TaskProgressReporter {
     if (logLine && logLine !== this.lastLogEntry) {
       try {
         await this.posthogAPI.appendTaskRunLog(this.taskId, this.runId, [
-          { type: 'info', message: logLine }
+          { type: "info", message: logLine },
         ]);
         this.lastLogEntry = logLine;
       } catch (error) {
-        this.logger.warn('Failed to append log entry', {
+        this.logger.warn("Failed to append log entry", {
           taskId: this.taskId,
           runId: this.runId,
           error: (error as Error).message,
@@ -417,10 +436,14 @@ export class TaskProgressReporter {
     // Update other fields if provided
     if (Object.keys(update).length > 0) {
       try {
-        const run = await this.posthogAPI.updateTaskRun(this.taskId, this.runId, update);
+        const run = await this.posthogAPI.updateTaskRun(
+          this.taskId,
+          this.runId,
+          update,
+        );
         this.taskRun = run;
       } catch (error) {
-        this.logger.warn('Failed to update task run', {
+        this.logger.warn("Failed to update task run", {
           taskId: this.taskId,
           runId: this.runId,
           error: (error as Error).message,
@@ -428,5 +451,4 @@ export class TaskProgressReporter {
       }
     }
   }
-
 }