@exaudeus/workrail 3.32.0 → 3.34.0

package/dist/daemon/agent-loop.js

@@ -43,7 +43,7 @@ class AgentLoop {
         }
     }
     async _runLoop() {
-        const { client, modelId, systemPrompt, tools, maxTokens = 8192 } = this._options;
+        const { client, modelId, systemPrompt, tools, maxTokens = 8192, callbacks } = this._options;
         while (true) {
             if (this._aborted || this._abortController.signal.aborted) {
                 this._appendErrorMessage('aborted');
@@ -56,6 +56,10 @@ class AgentLoop {
                 description: t.description,
                 input_schema: t.inputSchema,
             }));
+            try {
+                callbacks?.onLlmTurnStarted?.({ messageCount: apiMessages.length, modelId });
+            }
+            catch { }
             let response;
             try {
                 response = await client.messages.create({
@@ -74,6 +78,20 @@ class AgentLoop {
                 await this._emitEvent({ type: 'agent_end' });
                 return;
             }
+            {
+                const toolNamesRequested = response.content
+                    .filter((block) => block.type === 'tool_use')
+                    .map((block) => block.name);
+                try {
+                    callbacks?.onLlmTurnCompleted?.({
+                        stopReason: response.stop_reason ?? 'unknown',
+                        outputTokens: response.usage.output_tokens,
+                        inputTokens: response.usage.input_tokens,
+                        toolNamesRequested,
+                    });
+                }
+                catch { }
+            }
             const stopReason = this._mapStopReason(response.stop_reason);
             const assistantMsg = {
                 role: 'assistant',
@@ -116,6 +134,7 @@ class AgentLoop {
         }
     }
     async _executeTools(toolUseBlocks) {
+        const { callbacks } = this._options;
         const results = [];
         for (const block of toolUseBlocks) {
             if (this._abortController.signal.aborted) {
@@ -141,12 +160,23 @@ class AgentLoop {
                 continue;
             }
             const params = (block.input ?? {});
+            const argsSummary = JSON.stringify(params).slice(0, 200);
+            try {
+                callbacks?.onToolCallStarted?.({ toolName: block.name, argsSummary });
+            }
+            catch { }
+            const toolStartMs = Date.now();
             let result;
             try {
                 result = await tool.execute(block.id, params);
             }
             catch (err) {
+                const durationMs = Date.now() - toolStartMs;
                 const message = err instanceof Error ? err.message : String(err);
+                try {
+                    callbacks?.onToolCallFailed?.({ toolName: block.name, durationMs, errorMessage: message.slice(0, 200) });
+                }
+                catch { }
                 results.push({
                     toolCallId: block.id,
                     toolName: block.name,
@@ -155,6 +185,14 @@ class AgentLoop {
                 });
                 continue;
             }
+            {
+                const durationMs = Date.now() - toolStartMs;
+                const resultSummary = (result.content[0]?.text ?? '(no output)').slice(0, 200);
+                try {
+                    callbacks?.onToolCallCompleted?.({ toolName: block.name, durationMs, resultSummary });
+                }
+                catch { }
+            }
             results.push({
                 toolCallId: block.id,
                 toolName: block.name,

package/dist/daemon/daemon-events.d.ts

@@ -18,22 +18,26 @@ export interface SessionStartedEvent {
     readonly sessionId: string;
     readonly workflowId: string;
     readonly workspacePath: string;
+    readonly workrailSessionId?: string;
 }
 export interface ToolCalledEvent {
     readonly kind: 'tool_called';
     readonly sessionId: string;
     readonly toolName: string;
     readonly summary?: string;
+    readonly workrailSessionId?: string;
 }
 export interface ToolErrorEvent {
     readonly kind: 'tool_error';
     readonly sessionId: string;
     readonly toolName: string;
     readonly error: string;
+    readonly workrailSessionId?: string;
 }
 export interface StepAdvancedEvent {
     readonly kind: 'step_advanced';
     readonly sessionId: string;
+    readonly workrailSessionId?: string;
 }
 export interface SessionCompletedEvent {
     readonly kind: 'session_completed';
@@ -41,6 +45,7 @@ export interface SessionCompletedEvent {
     readonly workflowId: string;
     readonly outcome: 'success' | 'error' | 'timeout';
     readonly detail?: string;
+    readonly workrailSessionId?: string;
 }
 export interface DeliveryAttemptedEvent {
     readonly kind: 'delivery_attempted';
@@ -48,7 +53,64 @@ export interface DeliveryAttemptedEvent {
     readonly outcome: 'success' | 'http_error' | 'network_error';
     readonly statusCode?: number;
 }
-export type DaemonEvent = DaemonStartedEvent | TriggerFiredEvent | SessionQueuedEvent | SessionStartedEvent | ToolCalledEvent | ToolErrorEvent | StepAdvancedEvent | SessionCompletedEvent | DeliveryAttemptedEvent;
+export interface IssueReportedEvent {
+    readonly kind: 'issue_reported';
+    readonly sessionId: string;
+    readonly issueKind: 'tool_failure' | 'blocked' | 'unexpected_behavior' | 'needs_human' | 'self_correction';
+    readonly severity: 'info' | 'warn' | 'error' | 'fatal';
+    readonly summary: string;
+    readonly continueToken?: string;
+    readonly workrailSessionId?: string;
+}
+export interface LlmTurnStartedEvent {
+    readonly kind: 'llm_turn_started';
+    readonly sessionId: string;
+    readonly messageCount: number;
+    readonly modelId?: string;
+    readonly workrailSessionId?: string;
+}
+export interface LlmTurnCompletedEvent {
+    readonly kind: 'llm_turn_completed';
+    readonly sessionId: string;
+    readonly stopReason: string;
+    readonly outputTokens: number;
+    readonly inputTokens: number;
+    readonly toolNamesRequested: readonly string[];
+    readonly workrailSessionId?: string;
+}
+export interface ToolCallStartedEvent {
+    readonly kind: 'tool_call_started';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly argsSummary: string;
+    readonly workrailSessionId?: string;
+}
+export interface ToolCallCompletedEvent {
+    readonly kind: 'tool_call_completed';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly durationMs: number;
+    readonly resultSummary: string;
+    readonly workrailSessionId?: string;
+}
+export interface ToolCallFailedEvent {
+    readonly kind: 'tool_call_failed';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly durationMs: number;
+    readonly errorMessage: string;
+    readonly workrailSessionId?: string;
+}
+export interface AgentStuckEvent {
+    readonly kind: 'agent_stuck';
+    readonly sessionId: string;
+    readonly reason: 'repeated_tool_call' | 'no_progress' | 'timeout_imminent';
+    readonly detail: string;
+    readonly toolName?: string;
+    readonly argsSummary?: string;
+    readonly workrailSessionId?: string;
+}
+export type DaemonEvent = DaemonStartedEvent | TriggerFiredEvent | SessionQueuedEvent | SessionStartedEvent | ToolCalledEvent | ToolErrorEvent | StepAdvancedEvent | SessionCompletedEvent | DeliveryAttemptedEvent | IssueReportedEvent | LlmTurnStartedEvent | LlmTurnCompletedEvent | ToolCallStartedEvent | ToolCallCompletedEvent | ToolCallFailedEvent | AgentStuckEvent;
 export declare class DaemonEventEmitter {
     private readonly _dir;
     constructor(dirOverride?: string);

package/dist/daemon/workflow-runner.d.ts

@@ -60,8 +60,9 @@ export declare function readDaemonSessionState(sessionId: string): Promise<{
 } | null>;
 export declare function readAllDaemonSessions(sessionsDir?: string): Promise<OrphanedSession[]>;
 export declare function runStartupRecovery(sessionsDir?: string): Promise<void>;
-export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter): AgentTool;
-export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter): AgentTool;
+export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
+export declare function makeReportIssueTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, issuesDirOverride?: string, onIssueSummary?: (summary: string) => void): AgentTool;
 export declare function buildSessionRecap(notes: readonly string[]): string;
 export declare function buildSystemPrompt(trigger: WorkflowTrigger, sessionState: string, soulContent: string, workspaceContext: string | null): string;
 export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter): Promise<WorkflowRunResult>;