@exaudeus/workrail 3.31.1 → 3.33.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 });
+            }
+            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,7 +160,39 @@ class AgentLoop {
                 continue;
             }
             const params = (block.input ?? {});
-            const result = await tool.execute(block.id, params);
+            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,
+                    result: { content: [{ type: 'text', text: `Tool execution failed: ${message}` }], details: null },
+                    isError: true,
+                });
+                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

@@ -0,0 +1,103 @@
+export interface DaemonStartedEvent {
+    readonly kind: 'daemon_started';
+    readonly port: number;
+    readonly workspacePath: string;
+}
+export interface TriggerFiredEvent {
+    readonly kind: 'trigger_fired';
+    readonly triggerId: string;
+    readonly workflowId: string;
+}
+export interface SessionQueuedEvent {
+    readonly kind: 'session_queued';
+    readonly triggerId: string;
+    readonly workflowId: string;
+}
+export interface SessionStartedEvent {
+    readonly kind: 'session_started';
+    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';
+    readonly sessionId: string;
+    readonly workflowId: string;
+    readonly outcome: 'success' | 'error' | 'timeout';
+    readonly detail?: string;
+    readonly workrailSessionId?: string;
+}
+export interface DeliveryAttemptedEvent {
+    readonly kind: 'delivery_attempted';
+    readonly callbackUrl: string;
+    readonly outcome: 'success' | 'http_error' | 'network_error';
+    readonly statusCode?: number;
+}
+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;
+}
+export interface LlmTurnStartedEvent {
+    readonly kind: 'llm_turn_started';
+    readonly sessionId: string;
+    readonly messageCount: number;
+}
+export interface LlmTurnCompletedEvent {
+    readonly kind: 'llm_turn_completed';
+    readonly sessionId: string;
+    readonly stopReason: string;
+    readonly outputTokens: number;
+    readonly inputTokens: number;
+    readonly toolNamesRequested: readonly string[];
+}
+export interface ToolCallStartedEvent {
+    readonly kind: 'tool_call_started';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly argsSummary: string;
+}
+export interface ToolCallCompletedEvent {
+    readonly kind: 'tool_call_completed';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly durationMs: number;
+    readonly resultSummary: string;
+}
+export interface ToolCallFailedEvent {
+    readonly kind: 'tool_call_failed';
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly durationMs: number;
+    readonly errorMessage: string;
+}
+export type DaemonEvent = DaemonStartedEvent | TriggerFiredEvent | SessionQueuedEvent | SessionStartedEvent | ToolCalledEvent | ToolErrorEvent | StepAdvancedEvent | SessionCompletedEvent | DeliveryAttemptedEvent | IssueReportedEvent | LlmTurnStartedEvent | LlmTurnCompletedEvent | ToolCallStartedEvent | ToolCallCompletedEvent | ToolCallFailedEvent;
+export declare class DaemonEventEmitter {
+    private readonly _dir;
+    constructor(dirOverride?: string);
+    emit(event: DaemonEvent): void;
+    private _append;
+}

package/dist/daemon/daemon-events.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonEventEmitter = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+class DaemonEventEmitter {
+    constructor(dirOverride) {
+        this._dir = dirOverride ?? path.join(os.homedir(), '.workrail', 'events', 'daemon');
+    }
+    emit(event) {
+        void this._append(event).catch(() => {
+        });
+    }
+    async _append(event) {
+        const date = new Date().toISOString().slice(0, 10);
+        const filePath = path.join(this._dir, `${date}.jsonl`);
+        await fs.mkdir(this._dir, { recursive: true });
+        const line = JSON.stringify({ ...event, ts: Date.now() }) + '\n';
+        await fs.appendFile(filePath, line, 'utf8');
+    }
+}
+exports.DaemonEventEmitter = DaemonEventEmitter;

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

@@ -4,6 +4,7 @@ import type { V2ToolContext } from '../mcp/types.js';
 import { executeContinueWorkflow } from '../mcp/handlers/v2-execution/index.js';
 import type { DaemonRegistry } from '../v2/infra/in-memory/daemon-registry/index.js';
 import type { V2StartWorkflowOutputSchema } from '../mcp/output-schemas.js';
+import type { DaemonEventEmitter } from './daemon-events.js';
 export declare const DAEMON_SESSIONS_DIR: string;
 export { DAEMON_SOUL_DEFAULT, DAEMON_SOUL_TEMPLATE } from './soul-template.js';
 export interface WorkflowTrigger {
@@ -31,6 +32,7 @@ export interface WorkflowRunError {
     readonly workflowId: string;
     readonly message: string;
     readonly stopReason: string;
+    readonly lastStepNotes?: string;
 }
 export interface WorkflowRunTimeout {
     readonly _tag: 'timeout';
@@ -58,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): AgentTool;
-export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>): 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, issuesDirOverride?: string): 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): Promise<WorkflowRunResult>;
+export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter): Promise<WorkflowRunResult>;