@exaudeus/workrail 3.72.0 → 3.72.1

package/dist/daemon/tools/spawn-agent.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSpawnAgentTool = makeSpawnAgentTool;
+const start_js_1 = require("../../mcp/handlers/v2-execution/start.js");
+const v2_token_ops_js_1 = require("../../mcp/handlers/v2-token-ops.js");
+const assert_never_js_1 = require("../../runtime/assert-never.js");
+const _shared_js_1 = require("./_shared.js");
+function makeSpawnAgentTool(sessionId, ctx, apiKey, thisWorkrailSessionId, currentDepth, maxDepth, runWorkflowFn, schemas, emitter, activeSessionSet) {
+    return {
+        name: 'spawn_agent',
+        description: 'Spawn a child WorkRail session to handle a delegated sub-task. ' +
+            'Blocks until the child session completes, then returns the child\'s outcome and notes. ' +
+            'Use this when a step requires delegating a well-defined sub-task to a separate workflow. ' +
+            'IMPORTANT: The parent session\'s time limit (maxSessionMinutes) keeps ticking while the child runs. ' +
+            'Configure the parent with enough time to cover both its own work and the child\'s work. ' +
+            'Per-trigger limits (maxOutputTokens, maxTurns, maxSessionMinutes) are NOT inherited by child sessions spawned via spawn_agent -- each child uses its own trigger\'s agentConfig. ' +
+            'Returns: { childSessionId, outcome: "success"|"error"|"timeout", notes: string, artifacts?: readonly unknown[] }. ' +
+            'On success, artifacts contains the child session\'s final step artifacts if any were produced. ' +
+            'Check outcome before using notes -- on error/timeout, notes contains the error message.',
+        inputSchema: schemas['SpawnAgentParams'],
+        label: 'Spawn Agent',
+        execute: async (_toolCallId, params) => {
+            if (typeof params.workflowId !== 'string' || !params.workflowId)
+                throw new Error('spawn_agent: workflowId must be a non-empty string');
+            if (typeof params.goal !== 'string' || !params.goal)
+                throw new Error('spawn_agent: goal must be a non-empty string');
+            if (typeof params.workspacePath !== 'string' || !params.workspacePath)
+                throw new Error('spawn_agent: workspacePath must be a non-empty string');
+            console.log(`[WorkflowRunner] Tool: spawn_agent sessionId=${sessionId} workflowId=${String(params.workflowId)} depth=${currentDepth}/${maxDepth}`);
+            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'spawn_agent', summary: `${String(params.workflowId)} depth=${currentDepth}`, ...(0, _shared_js_1.withWorkrailSession)(thisWorkrailSessionId) });
+            if (currentDepth >= maxDepth) {
+                const limitResult = {
+                    childSessionId: null,
+                    outcome: 'error',
+                    notes: `Max spawn depth exceeded (currentDepth=${currentDepth}, maxDepth=${maxDepth}). ` +
+                        `Cannot spawn a child session from this depth. ` +
+                        `Increase agentConfig.maxSubagentDepth if deeper delegation is intentional.`,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(limitResult) }],
+                    details: limitResult,
+                };
+            }
+            const startInput = {
+                workflowId: String(params.workflowId),
+                workspacePath: String(params.workspacePath),
+                goal: String(params.goal),
+            };
+            const startResult = await (0, start_js_1.executeStartWorkflow)(startInput, ctx, { is_autonomous: 'true', workspacePath: String(params.workspacePath), parentSessionId: thisWorkrailSessionId });
+            if (startResult.isErr()) {
+                const errResult = {
+                    childSessionId: null,
+                    outcome: 'error',
+                    notes: `Failed to start child workflow: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errResult) }],
+                    details: errResult,
+                };
+            }
+            let childSessionId = null;
+            const childContinueToken = startResult.value.response.continueToken ?? '';
+            if (childContinueToken) {
+                const decoded = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(childContinueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
+                if (decoded.isOk()) {
+                    childSessionId = decoded.value.sessionId;
+                }
+                else {
+                    console.warn(`[WorkflowRunner] spawn_agent: could not decode childSessionId from continueToken -- ` +
+                        `childSessionId will be null in result. Reason: ${decoded.error.message}`);
+                }
+            }
+            const childTrigger = {
+                workflowId: String(params.workflowId),
+                goal: String(params.goal),
+                workspacePath: String(params.workspacePath),
+                context: params.context,
+                spawnDepth: currentDepth + 1,
+                parentSessionId: thisWorkrailSessionId,
+            };
+            const r = startResult.value.response;
+            const childAllocatedSession = {
+                continueToken: r.continueToken ?? '',
+                checkpointToken: r.checkpointToken,
+                firstStepPrompt: r.pending?.prompt ?? '',
+                isComplete: r.isComplete,
+                triggerSource: 'daemon',
+            };
+            const childSource = { kind: 'pre_allocated', trigger: childTrigger, session: childAllocatedSession };
+            const childResult = await runWorkflowFn(childTrigger, ctx, apiKey, undefined, emitter, activeSessionSet, undefined, undefined, childSource);
+            let resultObj;
+            if (childResult._tag === 'success') {
+                resultObj = {
+                    childSessionId,
+                    outcome: 'success',
+                    notes: childResult.lastStepNotes ?? '(no notes from child session)',
+                    ...(childResult.lastStepArtifacts !== undefined ? { artifacts: childResult.lastStepArtifacts } : {}),
+                };
+            }
+            else if (childResult._tag === 'error') {
+                resultObj = {
+                    childSessionId,
+                    outcome: 'error',
+                    notes: childResult.message,
+                };
+            }
+            else if (childResult._tag === 'timeout') {
+                resultObj = {
+                    childSessionId,
+                    outcome: 'timeout',
+                    notes: childResult.message,
+                };
+            }
+            else if (childResult._tag === 'stuck') {
+                resultObj = {
+                    childSessionId,
+                    outcome: 'stuck',
+                    notes: childResult.message,
+                    ...(childResult.issueSummaries !== undefined
+                        ? { issueSummaries: childResult.issueSummaries }
+                        : {}),
+                };
+            }
+            else {
+                (0, assert_never_js_1.assertNever)(childResult);
+            }
+            console.log(`[WorkflowRunner] spawn_agent completed: sessionId=${sessionId} childSessionId=${childSessionId ?? 'null'} outcome=${resultObj.outcome}`);
+            emitter?.emit({ kind: 'tool_called', sessionId, toolName: 'spawn_agent_complete', summary: `outcome=${resultObj.outcome} child=${childSessionId ?? 'null'}`, ...(0, _shared_js_1.withWorkrailSession)(thisWorkrailSessionId) });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(resultObj) }],
+                details: resultObj,
+            };
+        },
+    };
+}

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

@@ -6,15 +6,26 @@ import type { AgentTool, AgentEvent, AgentLoopCallbacks } from "./agent-loop.js"
 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 { ContinueTokenResolved } from '../mcp/handlers/v2-token-ops.js';
 import type { SessionEventLogReadonlyStorePortV2 } from '../v2/ports/session-event-log-store.port.js';
 import type { ToolFailure } from '../mcp/handlers/v2-execution-helpers.js';
 import type { ResultAsync } from 'neverthrow';
 import type { DaemonEventEmitter } from './daemon-events.js';
+import { type SessionScope } from './session-scope.js';
+import { ActiveSessionSet } from './active-sessions.js';
+import type { SessionHandle } from './active-sessions.js';
+import { makeContinueWorkflowTool, makeCompleteStepTool } from './tools/continue-workflow.js';
+import { makeBashTool } from './tools/bash.js';
+import { makeReadTool, makeWriteTool, makeEditTool } from './tools/file-tools.js';
+import { makeGlobTool, makeGrepTool } from './tools/glob-grep.js';
+import { makeSpawnAgentTool } from './tools/spawn-agent.js';
+import { makeReportIssueTool } from './tools/report-issue.js';
+import { makeSignalCoordinatorTool } from './tools/signal-coordinator.js';
+export { DAEMON_SESSIONS_DIR, type PersistTokensError } from './tools/_shared.js';
+export { DAEMON_SIGNALS_DIR } from './tools/signal-coordinator.js';
+export { makeContinueWorkflowTool, makeCompleteStepTool, makeBashTool, makeReadTool, makeWriteTool, makeEditTool, makeGlobTool, makeGrepTool, makeSpawnAgentTool, makeReportIssueTool, makeSignalCoordinatorTool, };
 export declare const DEFAULT_SESSION_TIMEOUT_MINUTES = 30;
 export declare const DEFAULT_MAX_TURNS = 200;
-export declare const DAEMON_SESSIONS_DIR: string;
 export declare const WORKTREES_DIR: string;
 export { DAEMON_SOUL_DEFAULT, DAEMON_SOUL_TEMPLATE } from './soul-template.js';
 export type ReadFileState = {
@@ -37,7 +48,6 @@ export interface WorkflowTrigger {
         readonly stuckAbortPolicy?: 'abort' | 'notify_only';
         readonly noProgressAbortEnabled?: boolean;
     };
-    readonly _preAllocatedStartResponse?: import('zod').infer<typeof V2StartWorkflowOutputSchema>;
     readonly parentSessionId?: string;
     readonly spawnDepth?: number;
     readonly soulFile?: string;
@@ -49,6 +59,21 @@ export interface WorkflowTrigger {
     readonly baseBranch?: string;
     readonly branchPrefix?: string;
 }
+export interface AllocatedSession {
+    readonly continueToken: string;
+    readonly checkpointToken?: string | null;
+    readonly firstStepPrompt: string;
+    readonly isComplete: boolean;
+    readonly triggerSource: 'daemon' | 'mcp';
+}
+export type SessionSource = {
+    readonly kind: 'allocate';
+    readonly trigger: WorkflowTrigger;
+} | {
+    readonly kind: 'pre_allocated';
+    readonly trigger: WorkflowTrigger;
+    readonly session: AllocatedSession;
+};
 export interface WorkflowRunSuccess {
     readonly _tag: 'success';
     readonly workflowId: string;
@@ -104,10 +129,6 @@ export interface OrphanedSession {
     readonly goal?: string;
     readonly workspacePath?: string;
 }
-export interface PersistTokensError {
-    readonly code: string;
-    readonly message: string;
-}
 export declare function readDaemonSessionState(sessionId: string): Promise<{
     continueToken: string;
     checkpointToken: string | null;
@@ -122,18 +143,6 @@ export declare function clearQueueIssueSidecars(sessionsDir: string): Promise<vo
 export declare function stripFrontmatter(content: string): string;
 export declare function loadWorkspaceContext(workspacePath: string): Promise<string | null>;
 export declare function loadSessionNotes(continueToken: string, ctx: V2ToolContext): Promise<readonly string[]>;
-export declare function makeContinueWorkflowTool(sessionId: string, ctx: V2ToolContext, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined, artifacts?: readonly unknown[]) => void, schemas: Record<string, any>, _executeContinueWorkflowFn?: typeof executeContinueWorkflow, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
-export declare function makeCompleteStepTool(sessionId: string, ctx: V2ToolContext, getCurrentToken: () => string, onAdvance: (nextStepText: string, continueToken: string) => void, onComplete: (notes: string | undefined, artifacts?: readonly unknown[]) => void, onTokenUpdate: (t: string) => 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 makeReadTool(readFileState: Map<string, ReadFileState>, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
-export declare function makeWriteTool(readFileState: Map<string, ReadFileState>, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
-export declare function makeGlobTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
-export declare function makeGrepTool(workspacePath: string, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
-export declare function makeEditTool(workspacePath: string, readFileState: Map<string, ReadFileState>, schemas: Record<string, any>, sessionId?: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null): AgentTool;
-export declare function makeSpawnAgentTool(sessionId: string, ctx: V2ToolContext, apiKey: string, thisWorkrailSessionId: string, currentDepth: number, maxDepth: number, runWorkflowFn: typeof runWorkflow, schemas: Record<string, any>, emitter?: DaemonEventEmitter, abortRegistry?: AbortRegistry): AgentTool;
-export declare function makeReportIssueTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, issuesDirOverride?: string, onIssueSummary?: (summary: string) => void): AgentTool;
-export declare const DAEMON_SIGNALS_DIR: string;
-export declare function makeSignalCoordinatorTool(sessionId: string, emitter?: DaemonEventEmitter, workrailSessionId?: string | null, signalsDirOverride?: 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 tagToStatsOutcome(tag: WorkflowRunResult['_tag']): 'success' | 'error' | 'timeout' | 'stuck';
@@ -193,7 +202,7 @@ export interface PreAgentSession {
     readonly checkpointToken: string | null;
     readonly sessionWorkspacePath: string;
     readonly sessionWorktreePath: string | undefined;
-    readonly firstStep: import('zod').infer<typeof V2StartWorkflowOutputSchema>;
+    readonly firstStepPrompt: string;
     readonly state: SessionState;
     readonly spawnCurrentDepth: number;
     readonly spawnMaxDepth: number;
@@ -201,6 +210,7 @@ export interface PreAgentSession {
     readonly agentClient: Anthropic | AnthropicBedrock;
     readonly modelId: string;
     readonly startMs: number;
+    readonly handle?: SessionHandle;
 }
 export type PreAgentSessionResult = {
     readonly kind: 'ready';
@@ -209,6 +219,27 @@ export type PreAgentSessionResult = {
     readonly kind: 'complete';
     readonly result: WorkflowRunResult;
 };
+export interface AgentReadySession {
+    readonly preAgentSession: PreAgentSession;
+    readonly contextBundle: import('./context-loader.js').ContextBundle;
+    readonly scope: SessionScope;
+    readonly tools: readonly AgentTool[];
+    readonly sessionCtx: SessionContext;
+    readonly handle: import('./active-sessions.js').SessionHandle | undefined;
+    readonly sessionId: string;
+    readonly workflowId: string;
+    readonly worktreePath: string | undefined;
+    readonly agent: AgentLoop;
+    readonly stuckRepeatThreshold: number;
+}
+export type SessionOutcome = {
+    readonly kind: 'completed';
+    readonly stopReason: string;
+    readonly errorMessage?: string;
+} | {
+    readonly kind: 'aborted';
+    readonly errorMessage?: string;
+};
 export interface FinalizationContext {
     readonly sessionId: string;
     readonly workrailSessionId: string | null;
@@ -223,20 +254,14 @@ export interface FinalizationContext {
     readonly workflowId: string;
 }
 export declare function finalizeSession(result: WorkflowRunResult, ctx: FinalizationContext): Promise<void>;
-export interface SessionContextInputs {
-    readonly soulContent: string;
-    readonly workspaceContext: string | null;
-    readonly sessionNotes: readonly string[];
-    readonly firstStepPrompt: string;
-}
 export interface SessionContext {
     readonly systemPrompt: string;
     readonly initialPrompt: string;
     readonly sessionTimeoutMs: number;
     readonly maxTurns: number;
 }
-export declare function buildSessionContext(trigger: WorkflowTrigger, inputs: SessionContextInputs): SessionContext;
-export declare function buildPreAgentSession(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, sessionId: string, startMs: number, statsDir: string, sessionsDir: string, emitter: DaemonEventEmitter | undefined, daemonRegistry: DaemonRegistry | undefined, steerRegistry: SteerRegistry | undefined): Promise<PreAgentSessionResult>;
+export declare function buildSessionContext(trigger: WorkflowTrigger, context: import('./context-loader.js').ContextBundle, firstStepPrompt: string): SessionContext;
+export declare function buildPreAgentSession(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, sessionId: string, startMs: number, statsDir: string, sessionsDir: string, emitter: DaemonEventEmitter | undefined, daemonRegistry: DaemonRegistry | undefined, activeSessionSet: ActiveSessionSet | undefined, source?: SessionSource): Promise<PreAgentSessionResult>;
 export interface TurnEndSubscriberContext {
     readonly agent: AgentLoop;
     readonly state: SessionState;
@@ -253,4 +278,4 @@ export interface TurnEndSubscriberContext {
 export declare function buildTurnEndSubscriber(ctx: TurnEndSubscriberContext): (event: AgentEvent) => Promise<void>;
 export declare function buildAgentCallbacks(sessionId: string, state: SessionState, modelId: string, emitter: DaemonEventEmitter | undefined, stuckRepeatThreshold: number): AgentLoopCallbacks;
 export declare function buildSessionResult(state: Readonly<SessionState>, stopReason: string, errorMessage: string | undefined, trigger: WorkflowTrigger, sessionId: string, sessionWorktreePath: string | undefined): WorkflowRunResult;
-export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter, steerRegistry?: SteerRegistry, abortRegistry?: AbortRegistry, _statsDir?: string, _sessionsDir?: string): Promise<WorkflowRunResult>;
+export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry, emitter?: DaemonEventEmitter, activeSessionSet?: ActiveSessionSet, _statsDir?: string, _sessionsDir?: string, source?: SessionSource): Promise<WorkflowRunResult>;