@posthog/agent 1.9.0 → 1.10.0

package/src/agent.ts

@@ -158,13 +158,8 @@ export class Agent {
                     await this.posthogAPI.updateTask(task.id, { workflow: workflowId } as any);
                     (task as any).workflow = workflowId;
                 }
-                if (!(task as any).current_stage && workflow.stages.length > 0) {
-                    const firstStage = [...workflow.stages].sort((a, b) => a.position - b.position)[0];
-                    await this.posthogAPI.updateTaskStage(task.id, firstStage.id);
-                    (task as any).current_stage = firstStage.id;
-                }
             } catch (e) {
-                this.logger.warn('Failed to sync task workflow/stage before execution', { error: (e as Error).message });
+                this.logger.warn('Failed to sync task workflow before execution', { error: (e as Error).message });
             }
         }
 
@@ -172,11 +167,21 @@ export class Agent {
         this.logger.info('Starting workflow execution', { taskId: task.id, workflowId, executionId });
         this.taskManager.startExecution(task.id, 'plan_and_build', executionId);
         await this.progressReporter.start(task.id, {
-            workflowId,
-            workflowRunId: executionId,
             totalSteps: orderedStages.length,
         });
 
+        // Set initial stage on the newly created run
+        const firstStage = orderedStages[0];
+        if (this.posthogAPI && this.progressReporter.runId && firstStage) {
+            try {
+                await this.posthogAPI.updateTaskRun(task.id, this.progressReporter.runId, {
+                    current_stage: firstStage.id
+                });
+            } catch (e) {
+                this.logger.warn('Failed to set initial stage on run', { error: (e as Error).message });
+            }
+        }
+
         try {
             let startIndex = 0;
             const currentStageId = (task as any).current_stage as string | undefined;
@@ -200,11 +205,17 @@ export class Agent {
                 if (idx >= 0) startIndex = idx;
             }
 
-            // Align server-side stage when restarting from the beginning
-            if (this.posthogAPI) {
+            // Align server-side stage when restarting from a different stage
+            if (this.posthogAPI && this.progressReporter.runId) {
                 const targetStage = orderedStages[startIndex];
                 if (targetStage && targetStage.id !== currentStageId) {
-                    try { await this.posthogAPI.updateTaskStage(task.id, targetStage.id); (task as any).current_stage = targetStage.id; } catch {}
+                    try {
+                        await this.posthogAPI.updateTaskRun(task.id, this.progressReporter.runId, {
+                            current_stage: targetStage.id
+                        });
+                    } catch (e) {
+                        this.logger.warn('Failed to update run stage', { error: (e as Error).message });
+                    }
                 }
             }
 
@@ -318,13 +329,16 @@ export class Agent {
     }
 
     async progressToNextStage(taskId: string, currentStageKey?: string): Promise<void> {
-        if (!this.posthogAPI) throw new Error('PostHog API not configured. Cannot progress stage.');
+        if (!this.posthogAPI || !this.progressReporter.runId) {
+            throw new Error('PostHog API not configured or no active run. Cannot progress stage.');
+        }
         try {
-            await this.posthogAPI.progressTask(taskId, { auto: true });
+            await this.posthogAPI.progressTaskRun(taskId, this.progressReporter.runId);
         } catch (error) {
             if (error instanceof Error && error.message.includes('No next stage available')) {
-                this.logger.warn('No next stage available when attempting to progress task', {
+                this.logger.warn('No next stage available when attempting to progress run', {
                     taskId,
+                    runId: this.progressReporter.runId,
                     stage: currentStageKey,
                     error: error.message,
                 });
@@ -479,29 +493,36 @@ Generated by PostHog Agent`;
     }
 
     async attachPullRequestToTask(taskId: string, prUrl: string, branchName?: string): Promise<void> {
-        this.logger.info('Attaching PR to task', { taskId, prUrl, branchName });
+        this.logger.info('Attaching PR to task run', { taskId, prUrl, branchName });
 
-        if (!this.posthogAPI) {
-            const error = new Error('PostHog API not configured. Cannot attach PR to task.');
+        if (!this.posthogAPI || !this.progressReporter.runId) {
+            const error = new Error('PostHog API not configured or no active run. Cannot attach PR to task.');
             this.logger.error('PostHog API not configured', error);
             throw error;
         }
 
-        await this.posthogAPI.attachTaskPullRequest(taskId, prUrl, branchName);
-        this.logger.debug('PR attached to task', { taskId, prUrl });
+        const updates: any = {
+            output: { pr_url: prUrl }
+        };
+        if (branchName) {
+            updates.branch = branchName;
+        }
+
+        await this.posthogAPI.updateTaskRun(taskId, this.progressReporter.runId, updates);
+        this.logger.debug('PR attached to task run', { taskId, runId: this.progressReporter.runId, prUrl });
     }
 
     async updateTaskBranch(taskId: string, branchName: string): Promise<void> {
-        this.logger.info('Updating task branch', { taskId, branchName });
+        this.logger.info('Updating task run branch', { taskId, branchName });
 
-        if (!this.posthogAPI) {
-            const error = new Error('PostHog API not configured. Cannot update task branch.');
+        if (!this.posthogAPI || !this.progressReporter.runId) {
+            const error = new Error('PostHog API not configured or no active run. Cannot update branch.');
             this.logger.error('PostHog API not configured', error);
             throw error;
         }
 
-        await this.posthogAPI.setTaskBranch(taskId, branchName);
-        this.logger.debug('Task branch updated', { taskId, branchName });
+        await this.posthogAPI.updateTaskRun(taskId, this.progressReporter.runId, { branch: branchName });
+        this.logger.debug('Task run branch updated', { taskId, runId: this.progressReporter.runId, branchName });
     }
 
     // Execution management

package/src/posthog-api.ts

@@ -1,4 +1,4 @@
-import type { Task, SupportingFile, PostHogAPIConfig, PostHogResource, ResourceType, UrlMention } from './types.js';
+import type { Task, TaskRun, LogEntry, SupportingFile, PostHogAPIConfig, PostHogResource, ResourceType, UrlMention } from './types.js';
 import type { WorkflowDefinition, AgentDefinition } from './workflow-types.js';
 
 interface PostHogApiResponse<T> {
@@ -8,52 +8,14 @@ interface PostHogApiResponse<T> {
   previous?: string | null;
 }
 
-interface TaskProgressResponse {
-  has_progress: boolean;
-  id?: string;
-  status?: "started" | "in_progress" | "completed" | "failed";
-  current_step?: string;
-  completed_steps?: number;
-  total_steps?: number;
-  progress_percentage?: number;
-  output_log?: string;
-  error_message?: string;
-  created_at?: string;
-  updated_at?: string;
-  completed_at?: string;
-  workflow_id?: string;
-  workflow_run_id?: string;
-  message?: string;
-}
-
-export interface TaskProgressRecord {
-  id: string;
-  task: string;
-  status: "started" | "in_progress" | "completed" | "failed";
-  current_step?: string | null;
-  completed_steps?: number | null;
-  total_steps?: number | null;
-  progress_percentage?: number | null;
-  output_log?: string | null;
-  error_message?: string | null;
-  workflow_id?: string | null;
-  workflow_run_id?: string | null;
-  activity_id?: string | null;
-  created_at: string;
-  updated_at: string;
-  completed_at?: string | null;
-}
-
-export interface TaskProgressUpdate {
-  status?: TaskProgressRecord["status"];
-  current_step?: string | null;
-  completed_steps?: number | null;
-  total_steps?: number | null;
-  output_log?: string | null;
+export interface TaskRunUpdate {
+  status?: TaskRun["status"];
+  branch?: string | null;
+  current_stage?: string | null;
+  log?: LogEntry[];
   error_message?: string | null;
-  workflow_id?: string | null;
-  workflow_run_id?: string | null;
-  activity_id?: string | null;
+  output?: Record<string, unknown> | null;
+  state?: Record<string, unknown>;
 }
 
 export class PostHogAPIClient {
@@ -172,65 +134,76 @@ export class PostHogAPIClient {
     });
   }
 
-  async updateTaskStage(taskId: string, stageId: string): Promise<Task> {
+  // TaskRun methods
+  async listTaskRuns(taskId: string): Promise<TaskRun[]> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/update_stage/`, {
-      method: 'PATCH',
-      body: JSON.stringify({ current_stage: stageId }),
-    });
+    const response = await this.apiRequest<PostHogApiResponse<TaskRun>>(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/`
+    );
+    return response.results || [];
   }
 
-  async setTaskBranch(taskId: string, branch: string): Promise<Task> {
+  async getTaskRun(taskId: string, runId: string): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/set_branch/`, {
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`);
+  }
+
+  async createTaskRun(
+    taskId: string,
+    payload?: Partial<Omit<TaskRun, 'id' | 'task' | 'team' | 'created_at' | 'updated_at' | 'completed_at'>>
+  ): Promise<TaskRun> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/`, {
       method: "POST",
-      body: JSON.stringify({ branch }),
+      body: JSON.stringify(payload || {}),
     });
   }
 
-  async attachTaskPullRequest(taskId: string, prUrl: string, branch?: string): Promise<Task> {
+  async updateTaskRun(
+    taskId: string,
+    runId: string,
+    payload: TaskRunUpdate
+  ): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    const payload: Record<string, string> = { pr_url: prUrl };
-    if (branch) {
-      payload.branch = branch;
-    }
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/attach_pr/`, {
-      method: "POST",
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`, {
+      method: "PATCH",
       body: JSON.stringify(payload),
     });
   }
 
-  async getTaskProgress(taskId: string): Promise<TaskProgressResponse> {
+  async updateTaskRunStage(taskId: string, runId: string, stageId: string): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<TaskProgressResponse>(`/api/projects/${teamId}/tasks/${taskId}/progress/`);
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/update_stage/`, {
+      method: 'PATCH',
+      body: JSON.stringify({ current_stage: stageId }),
+    });
   }
 
-  async createTaskProgress(
-    taskId: string,
-    payload: TaskProgressUpdate & { status: TaskProgressRecord["status"] }
-  ): Promise<TaskProgressRecord> {
+  async progressTaskRun(taskId: string, runId: string, nextStageId?: string): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<TaskProgressRecord>(`/api/projects/${teamId}/task_progress/`, {
-      method: "POST",
-      body: JSON.stringify({
-        ...payload,
-        task: taskId,
-      }),
+    const payload: Record<string, string> = {};
+    if (nextStageId) {
+      payload.next_stage_id = nextStageId;
+    }
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/progress_run/`, {
+      method: 'POST',
+      body: JSON.stringify(payload),
     });
   }
 
-  async updateTaskProgress(
-    taskId: string,
-    progressId: string,
-    payload: TaskProgressUpdate
-  ): Promise<TaskProgressRecord> {
+  async setTaskRunOutput(taskId: string, runId: string, output: Record<string, unknown>): Promise<TaskRun> {
     const teamId = await this.getTeamId();
-    return this.apiRequest<TaskProgressRecord>(`/api/projects/${teamId}/task_progress/${progressId}/`, {
-      method: "PATCH",
-      body: JSON.stringify({
-        ...payload,
-        task: taskId,
-      }),
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/set_output/`, {
+      method: 'PATCH',
+      body: JSON.stringify({ output }),
+    });
+  }
+
+  async appendTaskRunLog(taskId: string, runId: string, entries: LogEntry[]): Promise<TaskRun> {
+    const teamId = await this.getTeamId();
+    return this.apiRequest<TaskRun>(`/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/append_log/`, {
+      method: 'POST',
+      body: JSON.stringify({ entries }),
     });
   }
 
@@ -251,14 +224,6 @@ export class PostHogAPIClient {
     return this.apiRequest<AgentDefinition[]>(`/api/agents/`);
   }
 
-  async progressTask(taskId: string, options?: { next_stage_id?: string; auto?: boolean }): Promise<Task> {
-    const teamId = await this.getTeamId();
-    return this.apiRequest<Task>(`/api/projects/${teamId}/tasks/${taskId}/progress_task/`, {
-      method: 'POST',
-      body: JSON.stringify(options || {}),
-    });
-  }
-
   /**
    * Fetch error details from PostHog error tracking
    */

package/src/task-progress-reporter.ts

@@ -1,11 +1,8 @@
 import type { Logger } from './utils/logger.js';
-import type { PostHogAPIClient, TaskProgressRecord, TaskProgressUpdate } from './posthog-api.js';
-import type { AgentEvent } from './types.js';
+import type { PostHogAPIClient, TaskRunUpdate } from './posthog-api.js';
+import type { AgentEvent, TaskRun } from './types.js';
 
 interface ProgressMetadata {
-  workflowId?: string;
-  workflowRunId?: string;
-  activityId?: string;
   totalSteps?: number;
 }
 
@@ -18,7 +15,7 @@ interface ProgressMetadata {
 export class TaskProgressReporter {
   private posthogAPI?: PostHogAPIClient;
   private logger: Logger;
-  private progressRecord?: TaskProgressRecord;
+  private taskRun?: TaskRun;
   private taskId?: string;
   private outputLog: string[] = [];
   private totalSteps?: number;
@@ -29,8 +26,8 @@ export class TaskProgressReporter {
     this.logger = logger.child('TaskProgressReporter');
   }
 
-  get progressId(): string | undefined {
-    return this.progressRecord?.id;
+  get runId(): string | undefined {
+    return this.taskRun?.id;
   }
 
   async start(taskId: string, metadata: ProgressMetadata = {}): Promise<void> {
@@ -42,37 +39,27 @@ export class TaskProgressReporter {
     this.totalSteps = metadata.totalSteps;
 
     try {
-      const record = await this.posthogAPI.createTaskProgress(taskId, {
+      const run = await this.posthogAPI.createTaskRun(taskId, {
         status: 'started',
-        current_step: 'initializing',
-        total_steps: metadata.totalSteps ?? 0,
-        completed_steps: 0,
-        workflow_id: metadata.workflowId,
-        workflow_run_id: metadata.workflowRunId,
-        activity_id: metadata.activityId,
-        output_log: '',
+        log: [],
       });
-      this.progressRecord = record;
-      this.outputLog = record.output_log ? record.output_log.split('\n') : [];
-      this.logger.debug('Created task progress record', { taskId, progressId: record.id });
+      this.taskRun = run;
+      this.outputLog = [];
+      this.logger.debug('Created task run', { taskId, runId: run.id });
     } catch (error) {
-      this.logger.warn('Failed to create task progress record', { taskId, error: (error as Error).message });
+      this.logger.warn('Failed to create task run', { taskId, error: (error as Error).message });
     }
   }
 
   async stageStarted(stageKey: string, stageIndex: number): Promise<void> {
     await this.update({
       status: 'in_progress',
-      current_step: stageKey,
-      completed_steps: Math.min(stageIndex, this.totalSteps ?? stageIndex),
     }, `Stage started: ${stageKey}`);
   }
 
   async stageCompleted(stageKey: string, completedStages: number): Promise<void> {
     await this.update({
       status: 'in_progress',
-      current_step: stageKey,
-      completed_steps: Math.min(completedStages, this.totalSteps ?? completedStages),
     }, `Stage completed: ${stageKey}`);
   }
 
@@ -97,7 +84,7 @@ export class TaskProgressReporter {
   }
 
   async complete(): Promise<void> {
-    await this.update({ status: 'completed', completed_steps: this.totalSteps }, 'Workflow execution completed');
+    await this.update({ status: 'completed' }, 'Workflow execution completed');
   }
 
   async fail(error: Error | string): Promise<void> {
@@ -110,7 +97,7 @@ export class TaskProgressReporter {
   }
 
   async recordEvent(event: AgentEvent): Promise<void> {
-    if (!this.posthogAPI || !this.progressId || !this.taskId) {
+    if (!this.posthogAPI || !this.runId || !this.taskId) {
       return;
     }
 
@@ -178,32 +165,39 @@ export class TaskProgressReporter {
     }
   }
 
-  private async update(update: TaskProgressUpdate, logLine?: string): Promise<void> {
-    if (!this.posthogAPI || !this.progressId || !this.taskId) {
+  private async update(update: TaskRunUpdate, logLine?: string): Promise<void> {
+    if (!this.posthogAPI || !this.runId || !this.taskId) {
       return;
     }
 
-    if (logLine) {
-      if (logLine !== this.lastLogEntry) {
-        this.outputLog.push(logLine);
+    // If there's a log line, append it separately using the append_log endpoint
+    if (logLine && logLine !== this.lastLogEntry) {
+      try {
+        await this.posthogAPI.appendTaskRunLog(this.taskId, this.runId, [
+          { type: 'info', message: logLine }
+        ]);
         this.lastLogEntry = logLine;
+      } catch (error) {
+        this.logger.warn('Failed to append log entry', {
+          taskId: this.taskId,
+          runId: this.runId,
+          error: (error as Error).message,
+        });
       }
-      update.output_log = this.outputLog.join('\n');
     }
 
-    try {
-      const record = await this.posthogAPI.updateTaskProgress(this.taskId, this.progressId, update);
-      // Sync local cache with server response to avoid drift if server modifies values
-      this.progressRecord = record;
-      if (record.output_log !== undefined && record.output_log !== null) {
-        this.outputLog = record.output_log ? record.output_log.split('\n') : [];
+    // Update other fields if provided
+    if (Object.keys(update).length > 0) {
+      try {
+        const run = await this.posthogAPI.updateTaskRun(this.taskId, this.runId, update);
+        this.taskRun = run;
+      } catch (error) {
+        this.logger.warn('Failed to update task run', {
+          taskId: this.taskId,
+          runId: this.runId,
+          error: (error as Error).message,
+        });
       }
-    } catch (error) {
-      this.logger.warn('Failed to update task progress record', {
-        taskId: this.taskId,
-        progressId: this.progressId,
-        error: (error as Error).message,
-      });
     }
   }
 

package/src/types.ts

@@ -6,15 +6,43 @@ export interface Task {
   origin_product: 'error_tracking' | 'eval_clusters' | 'user_created' | 'support_queue' | 'session_summaries';
   position?: number;
   workflow?: string | null;
-  current_stage?: string | null;
   github_integration?: number | null;
   repository_config?: unknown; // JSONField
   repository_list: string;
   primary_repository: string;
-  github_branch: string | null;
-  github_pr_url: string | null;
   created_at: string;
   updated_at: string;
+
+  // DEPRECATED: These fields have been moved to TaskRun
+  // Use task.latest_run instead
+  current_stage?: string | null;
+  github_branch?: string | null;
+  github_pr_url?: string | null;
+  latest_run?: TaskRun;
+}
+
+// Log entry structure for TaskRun.log
+export interface LogEntry {
+  type: string; // e.g., "info", "warning", "error", "success", "debug"
+  message: string;
+  [key: string]: unknown; // Allow additional fields
+}
+
+// TaskRun model - represents individual execution runs of tasks
+export interface TaskRun {
+  id: string;
+  task: string; // Task ID
+  team: number;
+  branch: string | null;
+  current_stage: string | null; // WorkflowStage ID
+  status: 'started' | 'in_progress' | 'completed' | 'failed';
+  log: LogEntry[]; // Array of log entry objects
+  error_message: string | null;
+  output: Record<string, unknown> | null; // Structured output (PR URL, commit SHA, etc.)
+  state: Record<string, unknown>; // Intermediate run state (defaults to {}, never null)
+  created_at: string;
+  updated_at: string;
+  completed_at: string | null;
 }
 
 export interface SupportingFile {