agent-relay 3.2.15 → 3.2.16

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

@@ -16,6 +16,7 @@ import { getCliDefinition } from '../cli-registry.js';
 import { resolveCliSync } from '../cli-resolver.js';
 import { loadCustomSteps, resolveAllCustomSteps, validateCustomStepsUsage, CustomStepsParseError, CustomStepResolutionError, } from './custom-steps.js';
 import { collectCliSession } from './cli-session-collector.js';
+import { executeApiStep } from './api-executor.js';
 import { InMemoryWorkflowDb } from './memory-db.js';
 import { formatRunSummaryTable } from './run-summary-table.js';
 import { WorkflowTrajectory } from './trajectory.js';
@@ -60,6 +61,7 @@ export class WorkflowRunner {
     cwd;
     summaryDir;
     executor;
+    envSecrets;
     /** @internal exposed for CLI signal-handler shutdown only */
     relay;
     relaycast;
@@ -120,6 +122,7 @@ export class WorkflowRunner {
         this.summaryDir = options.summaryDir ?? path.join(this.cwd, '.relay', 'summaries');
         this.workersPath = path.join(this.cwd, '.agent-relay', 'team', 'workers.json');
         this.executor = options.executor;
+        this.envSecrets = options.envSecrets;
     }
     // ── Path resolution ─────────────────────────────────────────────────────
     /** Expand environment variables like $HOME or $VAR in a path string. */
@@ -1089,7 +1092,7 @@ export class WorkflowRunner {
         }
         // 6. Resource estimation
         const peakConcurrency = Math.max(...waves.map((w) => w.steps.length), 0);
-        const totalAgentSteps = resolvedSteps.filter((s) => s.type !== 'deterministic' && s.type !== 'worktree').length;
+        const totalAgentSteps = resolvedSteps.filter((s) => s.type !== 'deterministic' && s.type !== 'worktree' && s.type !== 'integration').length;
         // 7. Check maxConcurrency against wave widths
         const maxConcurrency = resolved.swarm.maxConcurrency;
         if (maxConcurrency !== undefined) {
@@ -1140,6 +1143,15 @@ export class WorkflowRunner {
                     throw new Error(`${source}: deterministic step "${s.name}" must have a "command" field`);
                 }
             }
+            else if (s.type === 'integration') {
+                // Integration steps require integration and action
+                if (typeof s.integration !== 'string') {
+                    throw new Error(`${source}: integration step "${s.name}" must have an "integration" string field`);
+                }
+                if (typeof s.action !== 'string') {
+                    throw new Error(`${source}: integration step "${s.name}" must have an "action" string field`);
+                }
+            }
             else {
                 // Agent steps (type undefined or 'agent') require agent and task
                 if (typeof s.agent !== 'string' || typeof s.task !== 'string') {
@@ -1162,7 +1174,7 @@ export class WorkflowRunner {
         this.detectLeadWorkerDeadlock(w.steps, agents, source, w.name);
         // Warn if non-interactive agent task is excessively large before interpolation
         for (const step of w.steps) {
-            if (step.type === 'deterministic' || step.type === 'worktree')
+            if (step.type === 'deterministic' || step.type === 'worktree' || step.type === 'integration')
                 continue;
             const agentDef = agents.find((a) => a.name === step.agent);
             const isNonInteractive = agentDef?.interactive === false || ['worker', 'reviewer', 'analyst'].includes(agentDef?.preset ?? '');
@@ -1208,7 +1220,7 @@ export class WorkflowRunner {
         }
         for (const step of steps) {
             // Only check interactive agent steps (leads)
-            if (step.type === 'deterministic' || step.type === 'worktree')
+            if (step.type === 'deterministic' || step.type === 'worktree' || step.type === 'integration')
                 continue;
             const agentDef = agents.find((a) => a.name === step.agent);
             // Skip non-interactive agents — they can't wait for channel signals
@@ -1255,6 +1267,15 @@ export class WorkflowRunner {
                     if (step.command) {
                         step.command = this.interpolate(step.command, vars);
                     }
+                    // Resolve variables in integration step params
+                    if (step.params && typeof step.params === 'object') {
+                        for (const key of Object.keys(step.params)) {
+                            const val = step.params[key];
+                            if (typeof val === 'string') {
+                                step.params[key] = this.interpolate(val, vars);
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -1372,8 +1393,8 @@ export class WorkflowRunner {
         // Build step rows
         const stepStates = new Map();
         for (const step of resolvedWorkflow.steps) {
-            // Handle agent, deterministic, and worktree steps
-            const isNonAgent = step.type === 'deterministic' || step.type === 'worktree';
+            // Handle agent, deterministic, worktree, and integration steps
+            const isNonAgent = step.type === 'deterministic' || step.type === 'worktree' || step.type === 'integration';
             const stepRow = {
                 id: this.generateId(),
                 runId,
@@ -1385,7 +1406,9 @@ export class WorkflowRunner {
                     ? (step.command ?? '')
                     : step.type === 'worktree'
                         ? (step.branch ?? '')
-                        : (step.task ?? ''),
+                        : step.type === 'integration'
+                            ? (`${step.integration}.${step.action}`)
+                            : (step.task ?? ''),
                 dependsOn: step.dependsOn ?? [],
                 retryCount: 0,
                 createdAt: now,
@@ -1525,7 +1548,7 @@ export class WorkflowRunner {
             }
             const relaycastDisabled = this.relayOptions.env?.AGENT_RELAY_WORKFLOW_DISABLE_RELAYCAST === '1';
             const requiresBroker = !this.executor &&
-                workflow.steps.some((step) => step.type !== 'deterministic' && step.type !== 'worktree');
+                workflow.steps.some((step) => step.type !== 'deterministic' && step.type !== 'worktree' && step.type !== 'integration');
             // Skip broker/relay init when an external executor handles agent spawning
             if (requiresBroker) {
                 if (!relaycastDisabled) {
@@ -1710,8 +1733,16 @@ export class WorkflowRunner {
                 };
                 this.relaycast = undefined;
                 this.relaycastAgent = undefined;
-                // Wire broker stderr to console for observability
+                // Wire broker stderr to console for observability — skip empty and
+                // JSON event lines (already surfaced via the broker:event emitter).
                 this.unsubBrokerStderr = this.relay.onBrokerStderr((line) => {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        return;
+                    // JSON event lines from the Rust EventEmitter are already parsed
+                    // and emitted as broker:event — no need to double-log them.
+                    if (trimmed.startsWith('{') && trimmed.endsWith('}'))
+                        return;
                     console.log(`${chalk.dim.yellow('[broker]')} ${line}`);
                 });
                 if (!relaycastDisabled) {
@@ -2086,6 +2117,10 @@ export class WorkflowRunner {
     isWorktreeStep(step) {
         return step.type === 'worktree';
     }
+    /** Check if a step is an integration (external service) step. */
+    isIntegrationStep(step) {
+        return step.type === 'integration';
+    }
     async executeStep(step, stepStates, agentMap, errorHandling, runId) {
         // Branch: deterministic steps execute shell commands
         if (this.isDeterministicStep(step)) {
@@ -2095,6 +2130,10 @@ export class WorkflowRunner {
         if (this.isWorktreeStep(step)) {
             return this.executeWorktreeStep(step, stepStates, runId);
         }
+        // Branch: integration steps interact with external services
+        if (this.isIntegrationStep(step)) {
+            return this.executeIntegrationStep(step, stepStates, runId);
+        }
         // Agent step execution
         return this.executeAgentStep(step, stepStates, agentMap, errorHandling, runId);
     }
@@ -2489,6 +2528,64 @@ export class WorkflowRunner {
             throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
         }
     }
+    /**
+     * Execute an integration step (external service interaction via executor).
+     */
+    async executeIntegrationStep(step, stepStates, runId) {
+        const state = stepStates.get(step.name);
+        if (!state)
+            throw new Error(`Step state not found: ${step.name}`);
+        this.checkAborted();
+        // Mark step as running
+        state.row.status = 'running';
+        state.row.error = undefined;
+        state.row.completionReason = undefined;
+        state.row.startedAt = new Date().toISOString();
+        await this.db.updateStep(state.row.id, {
+            status: 'running',
+            error: undefined,
+            completionReason: undefined,
+            startedAt: state.row.startedAt,
+            updatedAt: new Date().toISOString(),
+        });
+        this.emit({ type: 'step:started', runId, stepName: step.name });
+        this.postToChannel(`**[${step.name}]** Started (integration: ${step.integration}.${step.action})`);
+        // Resolve {{steps.X.output}} in params
+        const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
+        const resolvedParams = {};
+        for (const [key, value] of Object.entries(step.params ?? {})) {
+            resolvedParams[key] = this.interpolateStepTask(value, stepOutputContext);
+        }
+        try {
+            if (!this.executor?.executeIntegrationStep) {
+                throw new Error(`Integration steps require a cloud executor. Step "${step.name}" cannot run locally. ` +
+                    `Use "cloud run" to execute workflows with integration steps.`);
+            }
+            const result = await this.executor.executeIntegrationStep(step, resolvedParams, { workspaceId: this.workspaceId });
+            if (!result.success) {
+                throw new Error(`Integration step "${step.name}" failed: ${result.output}`);
+            }
+            // Mark completed
+            state.row.status = 'completed';
+            state.row.output = result.output;
+            state.row.completedAt = new Date().toISOString();
+            await this.db.updateStep(state.row.id, {
+                status: 'completed',
+                output: result.output,
+                completedAt: state.row.completedAt,
+                updatedAt: new Date().toISOString(),
+            });
+            await this.persistStepOutput(runId, step.name, result.output);
+            this.emit({ type: 'step:completed', runId, stepName: step.name, output: result.output });
+            this.postToChannel(`**[${step.name}]** Completed (integration: ${step.integration}.${step.action})`);
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            this.postToChannel(`**[${step.name}]** Failed: ${errorMsg}`);
+            await this.markStepFailed(state, errorMsg, runId);
+            throw new Error(`Step "${step.name}" failed: ${errorMsg}`);
+        }
+    }
     /**
      * Execute an agent step (LLM-powered).
      */
@@ -2505,6 +2602,50 @@ export class WorkflowRunner {
             throw new Error(`Agent "${agentName}" not found in config`);
         }
         const specialistDef = WorkflowRunner.resolveAgentDef(rawAgentDef);
+        // API-mode agents: execute via direct API call instead of spawning a PTY/subprocess.
+        if (specialistDef.cli === 'api') {
+            const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
+            const resolvedTask = this.interpolateStepTask(step.task ?? '', stepOutputContext);
+            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 });
+            this.postToChannel(`**[${step.name}]** Started (api)`);
+            try {
+                const output = await executeApiStep(specialistDef.constraints?.model ?? 'claude-sonnet-4-20250514', resolvedTask, { envSecrets: this.envSecrets, skills: specialistDef.skills, defaultMaxTokens: specialistDef.constraints?.maxTokens });
+                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(),
+                });
+                await this.persistStepOutput(runId, step.name, output);
+                this.emit({ type: 'step:completed', runId, stepName: step.name, output });
+            }
+            catch (apiError) {
+                const errorMessage = apiError instanceof Error ? apiError.message : String(apiError);
+                state.row.status = 'failed';
+                state.row.error = errorMessage;
+                state.row.completedAt = new Date().toISOString();
+                await this.db.updateStep(state.row.id, {
+                    status: 'failed',
+                    error: errorMessage,
+                    completedAt: state.row.completedAt,
+                    updatedAt: new Date().toISOString(),
+                });
+                this.emit({ type: 'step:failed', runId, stepName: step.name, error: errorMessage });
+                this.postToChannel(`**[${step.name}]** Failed (api): ${errorMessage}`);
+                throw apiError;
+            }
+            return;
+        }
         const usesOwnerFlow = specialistDef.interactive !== false;
         const currentPattern = this.currentConfig?.swarm?.pattern ?? '';
         const isHubPattern = WorkflowRunner.HUB_PATTERNS.has(currentPattern);
@@ -3649,10 +3790,13 @@ export class WorkflowRunner {
      * Delegates to the consolidated CLI registry for per-CLI arg formats.
      */
     static buildNonInteractiveCommand(cli, task, extraArgs = []) {
+        if (cli === 'api') {
+            throw new Error('cli "api" uses direct API calls, not a subprocess command');
+        }
         const resolvedCli = cli === 'cursor' ? resolveCursorCli() : cli;
         const def = getCliDefinition(resolvedCli);
-        if (!def) {
-            throw new Error(`Unknown CLI: ${resolvedCli}`);
+        if (!def || def.binaries.length === 0) {
+            throw new Error(`Unknown or non-executable CLI: ${resolvedCli}`);
         }
         return {
             cmd: def.binaries[0],