agent-relay 2.3.2 → 2.3.5

package/packages/sdk-ts/dist/workflows/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/workflows/runner.ts"],"names":[],"mappings":"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"}

package/packages/sdk-ts/dist/workflows/runner.js

@@ -0,0 +1,650 @@
+/**
+ * WorkflowRunner — parses relay.yaml, validates config, resolves templates,
+ * executes steps (sequential/parallel/DAG), runs verification checks,
+ * persists state to DB, and supports pause/resume/abort with retries.
+ */
+import { randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { InMemoryWorkflowDb } from './memory-db.js';
+// ── AgentRelay SDK imports ──────────────────────────────────────────────────
+// Import from sub-paths to avoid pulling in the full @relaycast/sdk dependency.
+import { AgentRelay } from '../relay.js';
+// ── WorkflowRunner ──────────────────────────────────────────────────────────
+export class WorkflowRunner {
+    db;
+    workspaceId;
+    relayOptions;
+    cwd;
+    summaryDir;
+    relay;
+    abortController;
+    paused = false;
+    pauseResolver;
+    listeners = [];
+    constructor(options = {}) {
+        this.db = options.db ?? new InMemoryWorkflowDb();
+        this.workspaceId = options.workspaceId ?? 'local';
+        this.relayOptions = options.relay ?? {};
+        this.cwd = options.cwd ?? process.cwd();
+        this.summaryDir = options.summaryDir ?? path.join(this.cwd, '.relay', 'summaries');
+    }
+    // ── Event subscription ──────────────────────────────────────────────────
+    on(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter((l) => l !== listener);
+        };
+    }
+    emit(event) {
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+    }
+    // ── Parsing & validation ────────────────────────────────────────────────
+    /** Parse a relay.yaml file from disk. */
+    async parseYamlFile(filePath) {
+        const absPath = path.resolve(this.cwd, filePath);
+        const raw = await readFile(absPath, 'utf-8');
+        return this.parseYamlString(raw, absPath);
+    }
+    /** Parse a relay.yaml string. */
+    parseYamlString(raw, source = '<string>') {
+        const parsed = parseYaml(raw);
+        this.validateConfig(parsed, source);
+        return parsed;
+    }
+    /** Validate a config object against the RelayYamlConfig shape. */
+    validateConfig(config, source = '<config>') {
+        if (typeof config !== 'object' || config === null) {
+            throw new Error(`${source}: config must be a non-null object`);
+        }
+        const c = config;
+        if (typeof c.version !== 'string') {
+            throw new Error(`${source}: missing required field "version"`);
+        }
+        if (typeof c.name !== 'string') {
+            throw new Error(`${source}: missing required field "name"`);
+        }
+        if (typeof c.swarm !== 'object' || c.swarm === null) {
+            throw new Error(`${source}: missing required field "swarm"`);
+        }
+        const swarm = c.swarm;
+        if (typeof swarm.pattern !== 'string') {
+            throw new Error(`${source}: missing required field "swarm.pattern"`);
+        }
+        if (!Array.isArray(c.agents) || c.agents.length === 0) {
+            throw new Error(`${source}: "agents" must be a non-empty array`);
+        }
+        for (const agent of c.agents) {
+            if (typeof agent !== 'object' || agent === null) {
+                throw new Error(`${source}: each agent must be an object`);
+            }
+            const a = agent;
+            if (typeof a.name !== 'string') {
+                throw new Error(`${source}: each agent must have a string "name"`);
+            }
+            if (typeof a.cli !== 'string') {
+                throw new Error(`${source}: each agent must have a string "cli"`);
+            }
+        }
+        if (c.workflows !== undefined) {
+            if (!Array.isArray(c.workflows)) {
+                throw new Error(`${source}: "workflows" must be an array`);
+            }
+            for (const wf of c.workflows) {
+                this.validateWorkflow(wf, source);
+            }
+        }
+    }
+    validateWorkflow(wf, source) {
+        if (typeof wf !== 'object' || wf === null) {
+            throw new Error(`${source}: each workflow must be an object`);
+        }
+        const w = wf;
+        if (typeof w.name !== 'string') {
+            throw new Error(`${source}: each workflow must have a string "name"`);
+        }
+        if (!Array.isArray(w.steps) || w.steps.length === 0) {
+            throw new Error(`${source}: workflow "${w.name}" must have a non-empty "steps" array`);
+        }
+        for (const step of w.steps) {
+            if (typeof step !== 'object' || step === null) {
+                throw new Error(`${source}: each step must be an object`);
+            }
+            const s = step;
+            if (typeof s.name !== 'string' || typeof s.agent !== 'string' || typeof s.task !== 'string') {
+                throw new Error(`${source}: each step must have "name", "agent", and "task" string fields`);
+            }
+        }
+        // Validate DAG: check for unknown dependencies and cycles
+        const stepNames = new Set(w.steps.map((s) => s.name));
+        for (const step of w.steps) {
+            if (step.dependsOn) {
+                for (const dep of step.dependsOn) {
+                    if (!stepNames.has(dep)) {
+                        throw new Error(`${source}: step "${step.name}" depends on unknown step "${dep}"`);
+                    }
+                }
+            }
+        }
+        this.detectCycles(w.steps, source, w.name);
+    }
+    detectCycles(steps, source, workflowName) {
+        const adj = new Map();
+        for (const step of steps) {
+            adj.set(step.name, step.dependsOn ?? []);
+        }
+        const visited = new Set();
+        const inStack = new Set();
+        const dfs = (node) => {
+            if (inStack.has(node)) {
+                throw new Error(`${source}: workflow "${workflowName}" contains a dependency cycle involving "${node}"`);
+            }
+            if (visited.has(node))
+                return;
+            inStack.add(node);
+            for (const dep of adj.get(node) ?? []) {
+                dfs(dep);
+            }
+            inStack.delete(node);
+            visited.add(node);
+        };
+        for (const step of steps) {
+            dfs(step.name);
+        }
+    }
+    // ── Template variable resolution ────────────────────────────────────────
+    /** Resolve {{variable}} placeholders in all task strings. */
+    resolveVariables(config, vars) {
+        const resolved = structuredClone(config);
+        for (const agent of resolved.agents) {
+            if (agent.task) {
+                agent.task = this.interpolate(agent.task, vars);
+            }
+        }
+        if (resolved.workflows) {
+            for (const wf of resolved.workflows) {
+                for (const step of wf.steps) {
+                    step.task = this.interpolate(step.task, vars);
+                }
+            }
+        }
+        return resolved;
+    }
+    interpolate(template, vars) {
+        return template.replace(/\{\{([\w][\w.\-]*)\}\}/g, (_match, key) => {
+            // Skip step-output placeholders — they are resolved at execution time by interpolateStepTask()
+            if (key.startsWith('steps.')) {
+                return _match;
+            }
+            // Resolve dot-path variables like steps.plan.output
+            const value = this.resolveDotPath(key, vars);
+            if (value === undefined) {
+                throw new Error(`Unresolved variable: {{${key}}}`);
+            }
+            return String(value);
+        });
+    }
+    resolveDotPath(key, vars) {
+        // Simple key — direct lookup
+        if (!key.includes('.')) {
+            return vars[key];
+        }
+        // Dot-path — walk into nested context
+        const parts = key.split('.');
+        let current = vars;
+        for (const part of parts) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return undefined;
+            }
+            current = current[part];
+        }
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        if (typeof current === 'string' || typeof current === 'number' || typeof current === 'boolean') {
+            return current;
+        }
+        return String(current);
+    }
+    /** Build a nested context from completed step outputs for {{steps.X.output}} resolution. */
+    buildStepOutputContext(stepStates) {
+        const steps = {};
+        for (const [name, state] of stepStates) {
+            if (state.row.status === 'completed' && state.row.output !== undefined) {
+                steps[name] = { output: state.row.output };
+            }
+        }
+        return { steps };
+    }
+    /** Interpolate step-output variables, silently skipping unresolved ones (they may be user vars). */
+    interpolateStepTask(template, context) {
+        return template.replace(/\{\{(steps\.[\w\-]+\.output)\}\}/g, (_match, key) => {
+            const value = this.resolveDotPath(key, context);
+            if (value === undefined) {
+                // Leave unresolved — may not be an error if the template doesn't depend on prior steps
+                return _match;
+            }
+            return String(value);
+        });
+    }
+    // ── Execution ───────────────────────────────────────────────────────────
+    /** Execute a named workflow from a validated config. */
+    async execute(config, workflowName, vars) {
+        const resolved = vars ? this.resolveVariables(config, vars) : config;
+        const workflows = resolved.workflows ?? [];
+        const workflow = workflowName
+            ? workflows.find((w) => w.name === workflowName)
+            : workflows[0];
+        if (!workflow) {
+            throw new Error(workflowName
+                ? `Workflow "${workflowName}" not found in config`
+                : 'No workflows defined in config');
+        }
+        const runId = this.generateId();
+        const now = new Date().toISOString();
+        const run = {
+            id: runId,
+            workspaceId: this.workspaceId,
+            workflowName: workflow.name,
+            pattern: resolved.swarm.pattern,
+            status: 'pending',
+            config: resolved,
+            startedAt: now,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insertRun(run);
+        // Build step rows
+        const stepStates = new Map();
+        for (const step of workflow.steps) {
+            const stepRow = {
+                id: this.generateId(),
+                runId,
+                stepName: step.name,
+                agentName: step.agent,
+                status: 'pending',
+                task: step.task,
+                dependsOn: step.dependsOn ?? [],
+                retryCount: 0,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await this.db.insertStep(stepRow);
+            stepStates.set(step.name, { row: stepRow });
+        }
+        // Start execution
+        this.abortController = new AbortController();
+        this.paused = false;
+        try {
+            await this.updateRunStatus(runId, 'running');
+            this.emit({ type: 'run:started', runId });
+            this.relay = new AgentRelay({
+                ...this.relayOptions,
+                channels: [resolved.swarm.channel ?? 'general'],
+            });
+            const agentMap = new Map();
+            for (const agent of resolved.agents) {
+                agentMap.set(agent.name, agent);
+            }
+            await this.executeSteps(workflow, stepStates, agentMap, resolved.errorHandling, runId);
+            // Check if all steps completed
+            const allCompleted = [...stepStates.values()].every((s) => s.row.status === 'completed' || s.row.status === 'skipped');
+            if (allCompleted) {
+                await this.updateRunStatus(runId, 'completed');
+                this.emit({ type: 'run:completed', runId });
+            }
+            else {
+                const failedStep = [...stepStates.values()].find((s) => s.row.status === 'failed');
+                const errorMsg = failedStep?.row.error ?? 'One or more steps failed';
+                await this.updateRunStatus(runId, 'failed', errorMsg);
+                this.emit({ type: 'run:failed', runId, error: errorMsg });
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            const status = this.abortController?.signal.aborted ? 'cancelled' : 'failed';
+            await this.updateRunStatus(runId, status, errorMsg);
+            if (status === 'cancelled') {
+                this.emit({ type: 'run:cancelled', runId });
+            }
+            else {
+                this.emit({ type: 'run:failed', runId, error: errorMsg });
+            }
+        }
+        finally {
+            await this.relay?.shutdown();
+            this.relay = undefined;
+            this.abortController = undefined;
+        }
+        const finalRun = await this.db.getRun(runId);
+        return finalRun ?? run;
+    }
+    /** Resume a previously paused or partially completed run. */
+    async resume(runId, vars) {
+        const run = await this.db.getRun(runId);
+        if (!run) {
+            throw new Error(`Run "${runId}" not found`);
+        }
+        if (run.status !== 'running' && run.status !== 'failed') {
+            throw new Error(`Run "${runId}" is in status "${run.status}" and cannot be resumed`);
+        }
+        const config = vars ? this.resolveVariables(run.config, vars) : run.config;
+        const workflows = config.workflows ?? [];
+        const workflow = workflows.find((w) => w.name === run.workflowName);
+        if (!workflow) {
+            throw new Error(`Workflow "${run.workflowName}" not found in stored config`);
+        }
+        const existingSteps = await this.db.getStepsByRunId(runId);
+        const stepStates = new Map();
+        for (const stepRow of existingSteps) {
+            stepStates.set(stepRow.stepName, { row: stepRow });
+        }
+        // Reset failed steps to pending for retry
+        for (const [, state] of stepStates) {
+            if (state.row.status === 'failed') {
+                state.row.status = 'pending';
+                state.row.error = undefined;
+                await this.db.updateStep(state.row.id, {
+                    status: 'pending',
+                    error: undefined,
+                    updatedAt: new Date().toISOString(),
+                });
+            }
+        }
+        this.abortController = new AbortController();
+        this.paused = false;
+        try {
+            await this.updateRunStatus(runId, 'running');
+            this.relay = new AgentRelay({
+                ...this.relayOptions,
+                channels: [config.swarm.channel ?? 'general'],
+            });
+            const agentMap = new Map();
+            for (const agent of config.agents) {
+                agentMap.set(agent.name, agent);
+            }
+            await this.executeSteps(workflow, stepStates, agentMap, config.errorHandling, runId);
+            const allCompleted = [...stepStates.values()].every((s) => s.row.status === 'completed' || s.row.status === 'skipped');
+            if (allCompleted) {
+                await this.updateRunStatus(runId, 'completed');
+                this.emit({ type: 'run:completed', runId });
+            }
+            else {
+                const failedStep = [...stepStates.values()].find((s) => s.row.status === 'failed');
+                const errorMsg = failedStep?.row.error ?? 'One or more steps failed';
+                await this.updateRunStatus(runId, 'failed', errorMsg);
+                this.emit({ type: 'run:failed', runId, error: errorMsg });
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            await this.updateRunStatus(runId, 'failed', errorMsg);
+            this.emit({ type: 'run:failed', runId, error: errorMsg });
+        }
+        finally {
+            await this.relay?.shutdown();
+            this.relay = undefined;
+            this.abortController = undefined;
+        }
+        const finalRun = await this.db.getRun(runId);
+        return finalRun ?? run;
+    }
+    /** Pause execution. Currently-running steps will finish but no new steps start. */
+    pause() {
+        this.paused = true;
+    }
+    /** Resume after a pause(). */
+    unpause() {
+        this.paused = false;
+        this.pauseResolver?.();
+        this.pauseResolver = undefined;
+    }
+    /** Abort the current run. Running agents are released. */
+    abort() {
+        // Unblock waitIfPaused() so the run loop can exit
+        this.pauseResolver?.();
+        this.pauseResolver = undefined;
+        this.abortController?.abort();
+    }
+    // ── Step execution engine ─────────────────────────────────────────────
+    async executeSteps(workflow, stepStates, agentMap, errorHandling, runId) {
+        const rawStrategy = errorHandling?.strategy ?? workflow.onError ?? 'fail-fast';
+        // Map shorthand onError values to canonical strategy names.
+        // 'retry' maps to 'fail-fast' so downstream steps are properly skipped after retries exhaust.
+        const strategy = rawStrategy === 'fail' ? 'fail-fast'
+            : rawStrategy === 'skip' ? 'continue'
+                : rawStrategy === 'retry' ? 'fail-fast'
+                    : rawStrategy;
+        // DAG-based execution: repeatedly find ready steps and run them in parallel
+        while (true) {
+            this.checkAborted();
+            await this.waitIfPaused();
+            const readySteps = this.findReadySteps(workflow.steps, stepStates);
+            if (readySteps.length === 0) {
+                // No steps ready — either all done or blocked
+                break;
+            }
+            const results = await Promise.allSettled(readySteps.map((step) => this.executeStep(step, stepStates, agentMap, errorHandling, runId)));
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                const step = readySteps[i];
+                if (result.status === 'rejected') {
+                    const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
+                    const state = stepStates.get(step.name);
+                    if (state && state.row.status !== 'failed') {
+                        await this.markStepFailed(state, error, runId);
+                    }
+                    if (strategy === 'fail-fast') {
+                        // Mark all pending downstream steps as skipped
+                        await this.markDownstreamSkipped(step.name, workflow.steps, stepStates, runId);
+                        throw new Error(`Step "${step.name}" failed: ${error}`);
+                    }
+                    if (strategy === 'continue') {
+                        await this.markDownstreamSkipped(step.name, workflow.steps, stepStates, runId);
+                    }
+                }
+            }
+        }
+    }
+    findReadySteps(steps, stepStates) {
+        return steps.filter((step) => {
+            const state = stepStates.get(step.name);
+            if (!state || state.row.status !== 'pending')
+                return false;
+            const deps = step.dependsOn ?? [];
+            return deps.every((dep) => {
+                const depState = stepStates.get(dep);
+                return depState && (depState.row.status === 'completed' || depState.row.status === 'skipped');
+            });
+        });
+    }
+    async executeStep(step, stepStates, agentMap, errorHandling, runId) {
+        const state = stepStates.get(step.name);
+        if (!state)
+            throw new Error(`Step state not found: ${step.name}`);
+        const agentDef = agentMap.get(step.agent);
+        if (!agentDef) {
+            throw new Error(`Agent "${step.agent}" not found in config`);
+        }
+        const maxRetries = step.retries ?? agentDef.constraints?.retries ?? errorHandling?.maxRetries ?? 0;
+        const retryDelay = errorHandling?.retryDelayMs ?? 1000;
+        const timeoutMs = step.timeoutMs ?? agentDef.constraints?.timeoutMs;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            this.checkAborted();
+            if (attempt > 0) {
+                this.emit({ type: 'step:retrying', runId, stepName: step.name, attempt });
+                state.row.retryCount = attempt;
+                await this.db.updateStep(state.row.id, {
+                    retryCount: attempt,
+                    updatedAt: new Date().toISOString(),
+                });
+                await this.delay(retryDelay);
+            }
+            try {
+                // Mark step as running
+                state.row.status = 'running';
+                state.row.startedAt = new Date().toISOString();
+                await this.db.updateStep(state.row.id, {
+                    status: 'running',
+                    startedAt: state.row.startedAt,
+                    updatedAt: new Date().toISOString(),
+                });
+                this.emit({ type: 'step:started', runId, stepName: step.name });
+                // Resolve step-output variables (e.g. {{steps.plan.output}}) at execution time
+                const stepOutputContext = this.buildStepOutputContext(stepStates);
+                const resolvedTask = this.interpolateStepTask(step.task, stepOutputContext);
+                // Spawn agent via AgentRelay
+                const resolvedStep = { ...step, task: resolvedTask };
+                const output = await this.spawnAndWait(agentDef, resolvedStep, timeoutMs);
+                // Run verification if configured
+                if (step.verification) {
+                    this.runVerification(step.verification, output, step.name);
+                }
+                // Mark completed
+                state.row.status = 'completed';
+                state.row.output = output;
+                state.row.completedAt = new Date().toISOString();
+                await this.db.updateStep(state.row.id, {
+                    status: 'completed',
+                    output,
+                    completedAt: state.row.completedAt,
+                    updatedAt: new Date().toISOString(),
+                });
+                this.emit({ type: 'step:completed', runId, stepName: step.name, output });
+                return;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+            }
+        }
+        // All retries exhausted — mark failed and throw so callers can apply error strategy
+        await this.markStepFailed(state, lastError ?? 'Unknown error', runId);
+        throw new Error(`Step "${step.name}" failed after ${maxRetries} retries: ${lastError ?? 'Unknown error'}`);
+    }
+    async spawnAndWait(agentDef, step, timeoutMs) {
+        if (!this.relay) {
+            throw new Error('AgentRelay not initialized');
+        }
+        const agent = await this.relay.spawnPty({
+            name: `${step.name}-${this.generateShortId()}`,
+            cli: agentDef.cli,
+            args: agentDef.constraints?.model ? ['--model', agentDef.constraints.model] : [],
+            channels: agentDef.channels,
+        });
+        // Send the task as a message to the agent
+        const system = this.relay.human({ name: 'WorkflowRunner' });
+        await system.sendMessage({ to: agent.name, text: step.task });
+        // Wait for agent to exit
+        const exitResult = await agent.waitForExit(timeoutMs);
+        if (exitResult === 'timeout') {
+            await agent.release();
+            throw new Error(`Step "${step.name}" timed out after ${timeoutMs}ms`);
+        }
+        // Read output from summary file if it exists
+        const summaryPath = path.join(this.summaryDir, `${step.name}.md`);
+        if (existsSync(summaryPath)) {
+            return await readFile(summaryPath, 'utf-8');
+        }
+        return `Agent exited (${exitResult})`;
+    }
+    // ── Verification ────────────────────────────────────────────────────────
+    runVerification(check, output, stepName) {
+        switch (check.type) {
+            case 'output_contains':
+                if (!output.includes(check.value)) {
+                    throw new Error(`Verification failed for "${stepName}": output does not contain "${check.value}"`);
+                }
+                break;
+            case 'exit_code':
+                // exit_code verification is implicitly satisfied if the agent exited successfully
+                break;
+            case 'file_exists':
+                if (!existsSync(path.resolve(this.cwd, check.value))) {
+                    throw new Error(`Verification failed for "${stepName}": file "${check.value}" does not exist`);
+                }
+                break;
+            case 'custom':
+                // Custom verifications are evaluated by callers; no-op here
+                break;
+        }
+    }
+    // ── State helpers ─────────────────────────────────────────────────────
+    async updateRunStatus(runId, status, error) {
+        const patch = {
+            status,
+            updatedAt: new Date().toISOString(),
+        };
+        if (status === 'completed' || status === 'failed' || status === 'cancelled') {
+            patch.completedAt = new Date().toISOString();
+        }
+        if (error) {
+            patch.error = error;
+        }
+        await this.db.updateRun(runId, patch);
+    }
+    async markStepFailed(state, error, runId) {
+        state.row.status = 'failed';
+        state.row.error = error;
+        state.row.completedAt = new Date().toISOString();
+        await this.db.updateStep(state.row.id, {
+            status: 'failed',
+            error,
+            completedAt: state.row.completedAt,
+            updatedAt: new Date().toISOString(),
+        });
+        this.emit({ type: 'step:failed', runId, stepName: state.row.stepName, error });
+    }
+    async markDownstreamSkipped(failedStepName, allSteps, stepStates, runId) {
+        const queue = [failedStepName];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            for (const step of allSteps) {
+                if (step.dependsOn?.includes(current)) {
+                    const state = stepStates.get(step.name);
+                    if (state && state.row.status === 'pending') {
+                        state.row.status = 'skipped';
+                        await this.db.updateStep(state.row.id, {
+                            status: 'skipped',
+                            updatedAt: new Date().toISOString(),
+                        });
+                        this.emit({ type: 'step:skipped', runId, stepName: step.name });
+                        queue.push(step.name);
+                    }
+                }
+            }
+        }
+    }
+    // ── Control flow helpers ──────────────────────────────────────────────
+    checkAborted() {
+        if (this.abortController?.signal.aborted) {
+            throw new Error('Workflow aborted');
+        }
+    }
+    async waitIfPaused() {
+        if (!this.paused)
+            return;
+        await new Promise((resolve) => {
+            this.pauseResolver = resolve;
+        });
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // ── ID generation ─────────────────────────────────────────────────────
+    generateId() {
+        return randomBytes(12).toString('hex');
+    }
+    generateShortId() {
+        return randomBytes(4).toString('hex');
+    }
+}
+//# sourceMappingURL=runner.js.map