@agent-relay/sdk 4.0.4 → 4.0.6

package/dist/workflows/runner.js

@@ -103,6 +103,20 @@ function resolveCursorCli() {
     const resolved = resolveCliSync('cursor');
     return resolved?.binary ?? 'agent';
 }
+function getWorkflowSdkSpawner(relay, cli) {
+    switch (cli) {
+        case 'claude':
+            return relay.claude;
+        case 'codex':
+            return relay.codex;
+        case 'gemini':
+            return relay.gemini;
+        case 'opencode':
+            return relay.opencode;
+        default:
+            return null;
+    }
+}
 // ── WorkflowRunner ──────────────────────────────────────────────────────────
 export class WorkflowRunner {
     db;
@@ -1070,12 +1084,13 @@ export class WorkflowRunner {
         });
     }
     getRelayEnv() {
-        if (!this.relayApiKey) {
-            return this.relayOptions.env;
+        if (!this.relayApiKey && !this.relayOptions.env) {
+            return undefined;
         }
         return {
-            ...(this.relayOptions.env ?? filteredEnv()),
-            RELAY_API_KEY: this.relayApiKey,
+            ...process.env,
+            ...(this.relayOptions.env ?? {}),
+            ...(this.relayApiKey ? { RELAY_API_KEY: this.relayApiKey } : {}),
         };
     }
     async provisionAgents(config) {
@@ -2048,7 +2063,7 @@ export class WorkflowRunner {
                     this.log('API key resolved');
                     if (this.relayApiKeyAutoCreated && this.relayApiKey) {
                         this.log(`Workspace created — follow this run in Relaycast:`);
-                        this.log(`  Observer: https://agentrelay.dev/observer?key=${this.relayApiKey}`);
+                        this.log(`  Observer: https://agentrelay.com/observer?key=${this.relayApiKey}`);
                         this.log(`  Channel: ${channel}`);
                     }
                 }
@@ -3115,7 +3130,7 @@ export class WorkflowRunner {
                 let completionReason;
                 let promptTaskText;
                 if (usesDedicatedOwner) {
-                    const result = await this.executeSupervisedAgentStep(step, { specialist: effectiveSpecialist, owner: effectiveOwner, reviewer: reviewDef }, resolvedTask, timeoutMs);
+                    const result = await this.executeSupervisedAgentStep(step, { specialist: effectiveSpecialist, owner: effectiveOwner, reviewer: reviewDef }, resolvedTask, timeoutMs, attempt);
                     specialistOutput = result.specialistOutput;
                     ownerOutput = result.ownerOutput;
                     ownerElapsed = result.ownerElapsed;
@@ -3133,6 +3148,7 @@ export class WorkflowRunner {
                     const spawnResult = this.executor
                         ? await this.executor.executeAgentStep(resolvedStep, effectiveOwner, ownerTask, timeoutMs)
                         : await this.spawnAndWait(effectiveOwner, resolvedStep, timeoutMs, {
+                            retryAttempt: attempt,
                             evidenceStepName: step.name,
                             evidenceRole: usesOwnerFlow ? 'owner' : 'specialist',
                             preserveOnIdle: !isHubPattern || !this.isLeadLikeAgent(effectiveOwner) ? false : undefined,
@@ -3361,6 +3377,34 @@ export class WorkflowRunner {
             `- Do not rely on terminal output alone for handoff; use the workflow group chat signal above.\n` +
             `- After posting your handoff signal, self-terminate with /exit unless the owner asks for follow-up.`);
     }
+    buildWorkflowRuntimeAgentBaseName(stepName, options) {
+        return `${stepName}${options.agentNameSuffix ? `-${options.agentNameSuffix}` : ''}-${(this.currentRunId ?? this.generateShortId()).slice(0, 8)}`;
+    }
+    async releaseStaleRetryAgents(baseRequestedName, stepName) {
+        if (!this.relay) {
+            return;
+        }
+        const staleAgents = (await this.relay.listAgents()).filter((agent) => agent.name === baseRequestedName || agent.name.startsWith(`${baseRequestedName}-r`));
+        if (staleAgents.length === 0) {
+            return;
+        }
+        const staleNames = [...new Set(staleAgents.map((agent) => agent.name))].sort();
+        this.log(`[${stepName}] Releasing stale retry agent(s): ${staleNames.join(', ')}`);
+        for (const agent of staleAgents) {
+            await agent.release(`workflow retry cleanup for step "${stepName}"`);
+        }
+        const deadline = Date.now() + 5_000;
+        while (Date.now() < deadline) {
+            const remaining = (await this.relay.listAgentsRaw())
+                .map((agent) => agent.name)
+                .filter((name) => staleNames.includes(name));
+            if (remaining.length === 0) {
+                return;
+            }
+            await this.delay(100);
+        }
+        throw new Error(`Failed to clear stale retry agent(s) before respawn: ${staleNames.join(', ')}`);
+    }
     buildSupervisorVerificationGuide(verification) {
         if (!verification)
             return '';
@@ -3377,7 +3421,7 @@ export class WorkflowRunner {
                 return '';
         }
     }
-    async executeSupervisedAgentStep(step, supervised, resolvedTask, timeoutMs) {
+    async executeSupervisedAgentStep(step, supervised, resolvedTask, timeoutMs, retryAttempt = 0) {
         if (this.executor) {
             const specialistTask = this.buildWorkerHandoffTask(step, resolvedTask, supervised);
             const supervisorTask = this.buildOwnerSupervisorTask(step, resolvedTask, supervised, supervised.specialist.name);
@@ -3425,6 +3469,7 @@ export class WorkflowRunner {
         this.log(`[${step.name}] Spawning specialist "${supervised.specialist.name}" (cli: ${supervised.specialist.cli})`);
         const workerPromise = this.spawnAndWait(supervised.specialist, specialistStep, timeoutMs, {
             agentNameSuffix: 'worker',
+            retryAttempt,
             evidenceStepName: step.name,
             evidenceRole: 'worker',
             logicalName: supervised.specialist.name,
@@ -3488,6 +3533,7 @@ export class WorkflowRunner {
         try {
             const ownerResultObj = await this.spawnAndWait(supervised.owner, ownerStep, timeoutMs, {
                 agentNameSuffix: 'owner',
+                retryAttempt,
                 evidenceStepName: step.name,
                 evidenceRole: 'owner',
                 logicalName: supervised.owner.name,
@@ -4411,9 +4457,14 @@ export class WorkflowRunner {
             throw new Error('AgentRelay not initialized');
         }
         const evidenceStepName = options.evidenceStepName ?? step.name;
-        // Deterministic name: step name + optional role suffix + first 8 chars of run ID.
-        const requestedName = `${step.name}${options.agentNameSuffix ? `-${options.agentNameSuffix}` : ''}-${(this.currentRunId ?? this.generateShortId()).slice(0, 8)}`;
+        const baseRequestedName = this.buildWorkflowRuntimeAgentBaseName(step.name, options);
+        const requestedName = (options.retryAttempt ?? 0) > 0
+            ? `${baseRequestedName}-r${(options.retryAttempt ?? 0) + 1}`
+            : baseRequestedName;
         let agentName = requestedName;
+        if ((options.retryAttempt ?? 0) > 0) {
+            await this.releaseStaleRetryAgents(baseRequestedName, step.name);
+        }
         // Only inject delegation guidance for lead/coordinator agents, not spokes/workers.
         // In non-hub patterns (pipeline, dag, etc.) every agent is autonomous so they all get it.
         const role = agentDef.role?.toLowerCase() ?? '';
@@ -4422,20 +4473,28 @@ export class WorkflowRunner {
             [...WorkflowRunner.HUB_ROLES].some((r) => new RegExp(`\\b${r}\\b`).test(role));
         const pattern = this.currentConfig?.swarm.pattern;
         const isHubPattern = pattern && WorkflowRunner.HUB_PATTERNS.has(pattern);
-        const delegationGuidance = isHub || !isHubPattern ? this.buildDelegationGuidance(agentDef.cli, timeoutMs) : '';
+        const usesHeadlessWorkflowSpawner = agentDef.cli === 'opencode';
+        const delegationGuidance = usesHeadlessWorkflowSpawner || (!isHub && isHubPattern)
+            ? ''
+            : this.buildDelegationGuidance(agentDef.cli, timeoutMs);
         // Non-claude CLIs (codex, gemini, etc.) don't auto-register with Relaycast
         // via the MCP system prompt the way claude does. Inject an explicit preamble
         // so they call register() before any other relay tool.
-        const relayRegistrationNote = this.buildRelayRegistrationNote(agentDef.cli, agentName);
-        const taskWithExit = step.task +
-            (relayRegistrationNote ? '\n\n' + relayRegistrationNote : '') +
-            (delegationGuidance ? '\n\n' + delegationGuidance + '\n' : '') +
-            '\n\n---\n' +
-            'IMPORTANT: When you have fully completed this task, you MUST self-terminate by either: ' +
-            '(a) calling remove_agent(name: "<your-agent-name>", reason: "task completed") — preferred, or ' +
-            '(b) outputting the exact text "/exit" on its own line as a fallback. ' +
-            'Do not wait for further input — terminate immediately after finishing. ' +
-            'Do NOT spawn sub-agents unless the task explicitly requires it.';
+        const relayRegistrationNote = usesHeadlessWorkflowSpawner
+            ? ''
+            : this.buildRelayRegistrationNote(agentDef.cli, agentName);
+        const interactiveTaskBase = step.task ?? '';
+        const taskWithExit = usesHeadlessWorkflowSpawner
+            ? interactiveTaskBase
+            : interactiveTaskBase +
+                (relayRegistrationNote ? '\n\n' + relayRegistrationNote : '') +
+                (delegationGuidance ? '\n\n' + delegationGuidance + '\n' : '') +
+                '\n\n---\n' +
+                'IMPORTANT: When you have fully completed this task, you MUST self-terminate by either: ' +
+                '(a) calling remove_agent(name: "<your-agent-name>", reason: "task completed") — preferred, or ' +
+                '(b) outputting the exact text "/exit" on its own line as a fallback. ' +
+                'Do not wait for further input — terminate immediately after finishing. ' +
+                'Do NOT spawn sub-agents unless the task explicitly requires it.';
         const preparedTask = this.prepareInteractiveSpawnTask(agentName, taskWithExit);
         // Register PTY output listener before spawning so we capture everything
         this.ptyOutputBuffers.set(agentName, []);
@@ -4464,9 +4523,8 @@ export class WorkflowRunner {
                 RELAY_API_KEY: this.relayApiKey ?? 'workflow-runner',
                 AGENT_CHANNELS: (agentChannels ?? []).join(','),
             });
-            agent = await this.relay.spawnPty({
+            const spawnOptions = {
                 name: agentName,
-                cli: agentDef.cli,
                 model: agentDef.constraints?.model,
                 args: interactiveSpawnPolicy.args,
                 channels: agentChannels,
@@ -4474,7 +4532,19 @@ export class WorkflowRunner {
                 idleThresholdSecs: agentDef.constraints?.idleThresholdSecs,
                 cwd: agentCwd,
                 agentToken: this.agentTokens.get(agentDef.name),
-            });
+            };
+            const sdkSpawner = getWorkflowSdkSpawner(this.relay, agentDef.cli);
+            if (sdkSpawner) {
+                this.log(`[${step.name}] Using SDK spawner for ${agentDef.cli} (requested runtime: ${agentDef.cli === 'opencode' ? 'headless' : 'pty'})`);
+                agent = await sdkSpawner.spawn(spawnOptions);
+            }
+            else {
+                this.log(`[${step.name}] Using PTY fallback for ${agentDef.cli}`);
+                agent = await this.relay.spawnPty({
+                    ...spawnOptions,
+                    cli: agentDef.cli,
+                });
+            }
             // Re-key PTY maps if broker assigned a different name than requested
             if (agent.name !== agentName) {
                 const oldName = agentName;
@@ -5351,6 +5421,10 @@ export class WorkflowRunner {
         }
         const maxMsg = 2000;
         const preview = scrubbed.length > maxMsg ? scrubbed.slice(-maxMsg) : scrubbed;
+        // Surface the final output preview in the local workflow log immediately.
+        // Some deterministic wrappers grep stdout/stderr for completion sentinels,
+        // and fire-and-forget channel delivery can arrive too late for single-step runs.
+        this.log(`[${stepName}] Output:\n\`\`\`\n${preview}\n\`\`\``);
         this.postToChannel(`**[${stepName}] Output:**\n\`\`\`\n${preview}\n\`\`\``, { stepName });
     }
     async persistAgentReport(runId, stepName, report) {