@relayflows/sdk 2.0.10 → 2.0.11

package/src/agent-relay-transport.ts

@@ -1,187 +1,273 @@
-/**
- * Agent-relay HTTP transport for f.agent step dispatch (flows#385).
- *
- * The SDK's default agent path is a direct `child_process.spawn(cli, ...)`
- * in worker-cli.ts. That is unobservable — you cannot DM the spawned agent
- * mid-flight, and every ecosystem tool that wants to steer or watch it
- * ends up shelling out to the `agent-relay` CLI, which is fragile.
- *
- * This module speaks to agent-relay via structured HTTP: the same call
- * shape the `mcp__agent-relay__spawn` MCP tool posts. The SDK becomes a
- * first-class agent-relay participant, registered under a derived agent
- * name a caller can DM against.
- *
- * Scope: spawn + close. Streaming inbox and observation are follow-ups.
- */
+import { createHash } from "node:crypto";
+import { isIP } from "node:net";
+import { setTimeout as delay } from "node:timers/promises";
+import { claimRelayTask } from "./agent-relay-state.js";
+import { canonicalize } from "./canonical.js";
+import {
+  isRecord,
+  nonempty,
+  readTaskReceipt,
+  type RelayTaskReceipt,
+} from "./agent-relay-receipt.js";
 
-export type AgentTransport = 'direct' | 'relay';
-
-export interface AgentRelaySpawnRequest {
-  /** Registered agent name in the workspace. */
-  name: string;
-  /** CLI to launch. */
-  cli: 'claude' | 'codex' | 'gemini' | 'aider' | 'goose' | 'grok' | 'opencode';
-  /** Initial task instructions. */
+export type AgentTransport = "direct" | "relay";
+export interface AgentRelayTaskRequest {
+  cli: string;
   task: string;
-  /** Optional model powering the worker. */
   model?: string;
-  /** Optional working directory for the spawned worker process. */
   worker_cwd?: string;
-  /** Optional target fleet node name. */
-  target_node?: string;
-  /** Declared objective for workforce reporting. */
-  objective?: string;
-  /** Declared role for workforce reporting. */
-  role?: string;
-  /** Declared project for workforce reporting. */
-  project?: string;
-  /** Declared workstream for workforce reporting. */
-  workstream?: string;
+  result_schema?: unknown;
+  runId: string;
+  stepId: string;
+  idempotencyKey: string;
+  dataDir: string;
+  /** Engine task contract ceiling; bounded independently of the renewing lease. */
+  timeoutMs?: number;
 }
-
 export interface AgentRelayEnv {
-  /** `RELAY_BASE_URL` env; defaults to https://cast.agentrelay.com. */
   baseUrl?: string;
-  /** `RELAY_API_KEY` env (rk_live_...). Required. */
-  apiKey?: string;
-  /** `RELAY_DEFAULT_WORKSPACE` env; workspace scoping for the spawn. */
-  workspaceId?: string;
-  /** Optional bearer token for the individual agent identity, if pre-registered. */
   agentToken?: string;
 }
-
-export interface AgentSpawnHandle {
-  /** Registered agent name in the workspace — DM this to steer. */
-  readonly registeredName: string;
-  /** Invocation id returned by relay; use for status polling. */
-  readonly invocationId: string;
-  /** Best-effort deregistration/notification. */
-  close(): Promise<void>;
-}
-
 export class AgentRelayTransportError extends Error {
-  constructor(message: string, public readonly cause?: unknown) {
+  constructor(
+    message: string,
+    public readonly cause?: unknown,
+  ) {
     super(message);
-    this.name = 'AgentRelayTransportError';
+    this.name = "AgentRelayTransportError";
   }
 }
-
-/**
- * Read the same env the relay MCP already consumes. Explicit override wins.
- * Missing RELAY_API_KEY refuses immediately — the transport cannot proceed
- * unauthenticated and the direct-spawn fallback is a separate decision.
- */
-export function readAgentRelayEnv(env: NodeJS.ProcessEnv = process.env): Required<Pick<AgentRelayEnv, 'baseUrl' | 'apiKey'>> & AgentRelayEnv {
-  const baseUrl = env['RELAY_BASE_URL']?.trim() || 'https://cast.agentrelay.com';
-  const apiKey = env['RELAY_API_KEY']?.trim();
-  if (!apiKey) {
+export function readAgentRelayEnv(
+  env: NodeJS.ProcessEnv = process.env,
+): Required<AgentRelayEnv> {
+  const agentToken = env.RELAY_AGENT_TOKEN?.trim();
+  if (!agentToken)
     throw new AgentRelayTransportError(
-      'agent-relay transport requires RELAY_API_KEY in the environment; falling back to direct transport is the caller\'s responsibility.',
+      "Relay task transport requires a pre-provisioned RELAY_AGENT_TOKEN.",
     );
-  }
   return {
-    baseUrl,
-    apiKey,
-    workspaceId: env['RELAY_DEFAULT_WORKSPACE']?.trim() || undefined,
-    agentToken: env['RELAY_AGENT_TOKEN']?.trim() || undefined,
+    baseUrl: env.RELAY_BASE_URL?.trim() || "https://cast.agentrelay.com",
+    agentToken,
   };
 }
 
-/**
- * Spawn a worker via agent-relay HTTP. The endpoint mirrors what the
- * `mcp__agent-relay__spawn` MCP tool wraps — a POST that requests a fleet
- * node dispatch. Returns a handle keyed on the registered agent name.
- *
- * The `fetch` argument is injected so tests can mock the transport without
- * hitting the network.
- */
-export async function agentRelaySpawn(
-  request: AgentRelaySpawnRequest,
-  env: AgentRelayEnv & { fetch?: typeof fetch } = {},
-): Promise<AgentSpawnHandle> {
-  // Only fall back to process.env if the caller didn't supply the required
-  // fields directly. Tests pass { apiKey, fetch } inline; they shouldn't need
-  // to also set RELAY_API_KEY in the runner env.
-  const fromEnv: Partial<AgentRelayEnv> = env.apiKey
-    ? { baseUrl: env.baseUrl || 'https://cast.agentrelay.com' }
-    : readAgentRelayEnv();
-  const resolved = { ...fromEnv, ...env };
-  const url = new URL('/api/v1/agents/spawn', resolved.baseUrl).toString();
-  const doFetch: typeof fetch = env.fetch ?? (globalThis as typeof globalThis & { fetch: typeof fetch }).fetch;
-  if (typeof doFetch !== 'function') {
-    throw new AgentRelayTransportError('global fetch is unavailable; provide { fetch } explicitly.');
-  }
-  const headers: Record<string, string> = {
-    'content-type': 'application/json',
-    'authorization': `Bearer ${resolved.apiKey}`,
-  };
-  if (resolved.workspaceId !== undefined) headers['x-relay-workspace'] = resolved.workspaceId;
-  if (resolved.agentToken !== undefined) headers['x-relay-agent-token'] = resolved.agentToken;
-
-  let response: Response;
-  try {
-    response = await doFetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(request),
-    });
-  } catch (cause) {
-    throw new AgentRelayTransportError(
-      `agent-relay spawn network error at ${url}: ${(cause as Error).message ?? String(cause)}`,
-      cause,
-    );
-  }
-
-  if (response.status < 200 || response.status >= 300) {
-    let body: string;
-    try { body = (await response.text()).slice(0, 512); } catch { body = '<no body>'; }
-    throw new AgentRelayTransportError(
-      `agent-relay spawn refused with status ${response.status}: ${body}`,
-    );
-  }
-
-  let json: { invocation?: { invocationId?: string; input?: { name?: string } } };
-  try { json = await response.json() as typeof json; } catch (cause) {
+/** Exact Relaycast #436 HTTP contract. Only terminal GET receipts can return. */
+export async function runAgentRelayTask(
+  request: AgentRelayTaskRequest,
+  options: AgentRelayEnv & {
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+    pollMs?: number;
+  } = {},
+): Promise<RelayTaskReceipt> {
+  const env = options.agentToken
+    ? {
+        baseUrl: options.baseUrl || "https://cast.agentrelay.com",
+        agentToken: options.agentToken,
+      }
+    : { ...readAgentRelayEnv(), ...options };
+  const base = new URL(env.baseUrl!);
+  if (
+    base.username ||
+    base.password ||
+    base.search ||
+    base.hash ||
+    base.pathname !== "/" ||
+    !["https:", "http:"].includes(base.protocol)
+  )
+    throw new AgentRelayTransportError("Invalid Relay task base URL");
+  const loopback =
+    base.hostname === "[::1]" ||
+    (isIP(base.hostname) === 4 && base.hostname.startsWith("127."));
+  if (base.protocol !== "https:" && !loopback) {
     throw new AgentRelayTransportError(
-      'agent-relay spawn response was not JSON',
-      cause,
+      "Relay task credentials require HTTPS outside literal loopback addresses",
     );
   }
-  const invocationId = json.invocation?.invocationId;
-  const registeredName = json.invocation?.input?.name ?? request.name;
-  if (typeof invocationId !== 'string' || invocationId.length === 0) {
+  const baseUrl = base.origin;
+  const timeoutMs = request.timeoutMs ?? 86_400_000;
+  if (
+    !Number.isSafeInteger(timeoutMs) ||
+    timeoutMs < 1 ||
+    timeoutMs > 86_400_000 ||
+    ![
+      request.runId,
+      request.stepId,
+      request.idempotencyKey,
+      request.dataDir,
+      request.cli,
+    ].every(nonempty)
+  ) {
     throw new AgentRelayTransportError(
-      'agent-relay spawn response missing invocation.invocationId',
+      "Relay task requires durable dispatch identity and a valid deadline",
     );
   }
-
-  return {
-    registeredName,
-    invocationId,
-    async close(): Promise<void> {
-      // Best-effort: post to /api/v1/invocations/<id>/close if defined server-side;
-      // no throw on error because the invocation may already be terminal.
-      const closeUrl = new URL(`/api/v1/invocations/${encodeURIComponent(invocationId)}/close`, resolved.baseUrl).toString();
+  const pollMs = options.pollMs ?? 1000;
+  if (!Number.isFinite(pollMs) || pollMs < 1)
+    throw new AgentRelayTransportError("Invalid Relay task polling interval");
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const outer = options.signal ?? new AbortController().signal;
+  let deadline = Date.now() + timeoutMs + 30_000;
+  let missingDeadline = Date.now() + 30_000;
+  async function http(
+    path: string,
+    body?: unknown,
+  ): Promise<Record<string, unknown>> {
+    for (;;) {
+      outer.throwIfAborted();
+      if (Date.now() >= deadline)
+        throw new AgentRelayTransportError(
+          "Relay task status unavailable before its reconciliation deadline",
+        );
+      const bounded = AbortSignal.any([
+        outer,
+        AbortSignal.timeout(
+          Math.min(15_000, Math.max(1, deadline - Date.now())),
+        ),
+      ]);
+      let response: Response | undefined;
+      let value: unknown;
       try {
-        await doFetch(closeUrl, {
-          method: 'POST',
-          headers,
-          body: JSON.stringify({ reason: 'sdk_transport_close' }),
+        response = await doFetch(new URL(path, baseUrl), {
+          method: body === undefined ? "GET" : "POST",
+          redirect: "error",
+          signal: bounded,
+          headers: {
+            authorization: `Bearer ${env.agentToken}`,
+            "content-type": "application/json",
+            ...(body === undefined
+              ? {}
+              : { "Idempotency-Key": request.idempotencyKey }),
+          },
+          ...(body === undefined ? {} : { body: canonicalize(body) }),
         });
-      } catch {
-        // Deliberate: close is advisory in this minimum-viable slice.
+        if (
+          response.status === 404 &&
+          body === undefined &&
+          path.includes("/invocations/")
+        ) {
+          if (Date.now() >= missingDeadline)
+            throw new AgentRelayTransportError(
+              "Relay task dispatch remains unconfirmed; no repeat POST is permitted",
+            );
+        } else if (
+          !response.ok &&
+          response.status !== 429 &&
+          response.status < 500
+        ) {
+          // Never copy untrusted response bodies, URLs, or tokens into diagnostics.
+          throw new AgentRelayTransportError(
+            `Relay task request refused with HTTP ${response.status}`,
+          );
+        }
+        if (response.ok) value = await response.json();
+        if (body !== undefined && !response.ok) return {}; // ambiguous POST: GET only below
+      } catch (error) {
+        outer.throwIfAborted();
+        if (error instanceof AgentRelayTransportError) throw error;
+        if (body !== undefined) return {}; // response loss or invalid JSON never causes another POST
+        if (response?.ok && !bounded.aborted)
+          throw new AgentRelayTransportError(
+            "Relay task response was not valid JSON",
+          );
+      }
+      outer.throwIfAborted();
+      if (response?.ok && value !== undefined) {
+        if (!isRecord(value) || value.ok !== true || !isRecord(value.data))
+          throw new AgentRelayTransportError(
+            "Relay task response has an invalid data envelope",
+          );
+        return value.data;
       }
+      await delay(pollMs, undefined, { signal: outer });
+    }
+  }
+  // Resolving the agent is read-only. Pin identity before any invocation so a
+  // restarted runner cannot create a second task using another caller's key.
+  const agent = await http("/v1/agent");
+  if (!nonempty(agent.id))
+    throw new AgentRelayTransportError("Relay task caller identity is missing");
+  if (!nonempty(agent.workspace_id))
+    throw new AgentRelayTransportError(
+      "Relay task workspace identity is missing",
+    );
+  // Pinned action-invoke-v1 identity contract from Relaycast #436.
+  const invocationId =
+    "inv_idem_" +
+    createHash("sha256")
+      .update(
+        [
+          "action-invoke-v1",
+          agent.workspace_id,
+          agent.id,
+          "task.run",
+          request.idempotencyKey,
+        ].join("\0"),
+      )
+      .digest("hex");
+  const input = {
+    cli: request.cli,
+    task: request.task,
+    ...(request.model === undefined ? {} : { model: request.model }),
+    ...(request.worker_cwd === undefined
+      ? {}
+      : { worker_cwd: request.worker_cwd }),
+    ...(request.result_schema === undefined
+      ? {}
+      : { result_schema: request.result_schema }),
+    task_context: {
+      run_id: request.runId,
+      step_id: request.stepId,
+      dispatch_id: request.idempotencyKey,
+      timeout_ms: timeoutMs,
     },
   };
-}
-
-/**
- * Derive a workspace-unique agent name from a run identity + step id. The
- * result is stable across replays of the same step so DMs can be addressed
- * even during retries.
- */
-export function deriveAgentName(runId: string, stepId: string): string {
-  // Keep readable + collision-safe: prefix with 'flow-' and use lower-kebab.
-  const clean = (s: string): string => s.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
-  return `flow-${clean(runId)}-${clean(stepId)}`.slice(0, 96);
+  const { claim, created } = await claimRelayTask(request.dataDir, {
+    version: 1,
+    baseUrl,
+    callerId: agent.id,
+    workspaceId: agent.workspace_id,
+    invocationId,
+    runId: request.runId,
+    stepId: request.stepId,
+    idempotencyKey: request.idempotencyKey,
+    input,
+    startedAt: Date.now(),
+  });
+  // A restarted runner may recover a terminal receipt after the task deadline.
+  // Give that read one bounded window; never reopen or extend the remote task.
+  deadline = Math.max(
+    claim.startedAt + timeoutMs + 30_000,
+    Date.now() + 15_000,
+  );
+  missingDeadline = claim.startedAt + 30_000;
+  if (created) {
+    const ack = await http("/v1/actions/task.run/invoke", { input });
+    if (
+      Object.keys(ack).length &&
+      (ack.invocation_id !== invocationId ||
+        ack.action_name !== "task.run" ||
+        canonicalize(ack.input) !== canonicalize(input))
+    ) {
+      throw new AgentRelayTransportError(
+        "Relay task acknowledgment has mismatched invocation or input",
+      );
+    }
+  }
+  let previous: RelayTaskReceipt | undefined;
+  for (;;) {
+    const value = await http(
+      `/v1/actions/task.run/invocations/${encodeURIComponent(invocationId)}`,
+    );
+    if (value.caller_id !== agent.id)
+      throw new AgentRelayTransportError(
+        "Relay task receipt belongs to another caller",
+      );
+    const receipt = readTaskReceipt(value, invocationId, input, previous);
+    outer.throwIfAborted();
+    if (receipt.status === "completed" || receipt.status === "failed")
+      return receipt;
+    previous = receipt;
+    await delay(pollMs, undefined, { signal: outer });
+  }
 }

package/src/worker-cli.ts

@@ -15,8 +15,7 @@ import {
 } from './wrapper-session.js';
 import { wrapperEnvironment } from './wrapper-runtime.js';
 import {
-  agentRelaySpawn,
-  deriveAgentName,
+  runAgentRelayTask,
   AgentRelayTransportError,
   type AgentTransport,
 } from './agent-relay-transport.js';
@@ -32,6 +31,7 @@ export const WAKE_CONTEXT_ENV = 'RELAYFLOW_WAKE_CONTEXT';
 export const MODEL_ENV = 'RELAYFLOW_MODEL';
 
 export interface WorkerCliResult {
+  relay_task?: import('./agent-relay-receipt.js').RelayTaskReceipt;
   tokens_input?: number;
   tokens_output?: number;
   exit_code: number | null;
@@ -40,12 +40,14 @@ export interface WorkerCliResult {
 }
 
 /**
- * Optional identity threaded through so the relay transport can derive a
- * stable, DM-addressable agent name (flows#385).
+ * Journal identity and durable dispatch storage used by the Relay task transport.
  */
 export interface AgentRelayContext {
   runId: string;
   stepId: string;
+  idempotencyKey: string;
+  dataDir?: string;
+  resultSchema?: unknown;
 }
 
 export async function runAgentCli(
@@ -67,6 +69,10 @@ export async function runAgentCli(
   }
   const kind = cliAdapterKind(cli);
 
+  if (mode === 'agent' && transport === 'relay') {
+    return runViaAgentRelay(kind, instruction, wakeContext, model, relayContext, cwd, signal);
+  }
+
   if (kind === 'relayflows-wrapper-v1') {
     return requirePricedUsage(decodeWrapperResult(await runWrapperSession(
       cli,
@@ -79,10 +85,6 @@ export async function runAgentCli(
     )), model);
   }
 
-  if (mode === 'agent' && transport === 'relay') {
-    return runViaAgentRelay(kind, instruction, model, relayContext, cwd);
-  }
-
   const env: NodeJS.ProcessEnv = { ...process.env };
   delete env[WAKE_CONTEXT_ENV];
   delete env[MODEL_ENV];
@@ -107,54 +109,46 @@ export async function runAgentCli(
   return requirePricedUsage(decodeProviderResult(await spawnInvocation(cli, { ...invocation, args }, env, signal, sidechannel, cwd), kind), model);
 }
 
-/**
- * Relay-transport path (flows#385). Fires an agent-relay spawn HTTP request
- * that registers the CLI as a first-class workspace participant DMs can
- * steer, then reports the spawn outcome as a WorkerCliResult. Streaming
- * completion tracking is a follow-up — this initial slice proves the
- * transport wire and returns quickly with the registered name in stdout.
- */
+/** Wait under the same worker lease for an authoritative task receipt. */
 async function runViaAgentRelay(
-  kind: CliAdapterKind,
-  instruction: string,
-  model: string | undefined,
-  relayContext: AgentRelayContext | undefined,
-  worker_cwd: string | undefined,
+  kind: CliAdapterKind, instruction: string, wakeContext: unknown,
+  model: string | undefined, context: AgentRelayContext | undefined,
+  worker_cwd: string | undefined, signal: AbortSignal | undefined,
 ): Promise<WorkerCliResult> {
-  if (kind === 'relayflows-wrapper-v1') {
-    return {
-      exit_code: null,
-      stdout_tail: '',
-      stderr_tail: 'agent-relay transport does not support the relayflows-wrapper-v1 same-process session.',
-    };
-  }
-  if (relayContext === undefined) {
-    return {
-      exit_code: null,
-      stdout_tail: '',
-      stderr_tail: 'agent-relay transport requires a relayContext (runId, stepId); the caller did not thread it through.',
-    };
-  }
-  const name = deriveAgentName(relayContext.runId, relayContext.stepId);
   try {
-    const handle = await agentRelaySpawn({
-      name,
-      cli: kind,
-      task: instruction,
-      ...(model === undefined ? {} : { model }),
-      ...(worker_cwd === undefined ? {} : { worker_cwd }),
-    });
-    return {
-      exit_code: 0,
-      stdout_tail: JSON.stringify({ registeredName: handle.registeredName, invocationId: handle.invocationId }),
-      stderr_tail: '',
+    if (kind === 'relayflows-wrapper-v1') throw new Error('Relay task transport does not support same-process wrappers.');
+    if (!context?.dataDir) throw new Error('Relay task transport requires a durable data directory and journal dispatch identity.');
+    const task = instruction + (wakeContext === undefined ? '' : `\n\nWake context (journaled):\n${JSON.stringify(wakeContext)}`)
+      + '\n\nReport the final task output with the injected agent_result tool and final=true. Wait for its successful durable acknowledgment before exiting.';
+    const received = await runAgentRelayTask({
+      cli: kind, task, model, worker_cwd, result_schema: context.resultSchema,
+      runId: context.runId, stepId: context.stepId, idempotencyKey: context.idempotencyKey,
+      dataDir: context.dataDir,
+    }, { signal });
+    const receipt = { ...received, error: received.error === null ? null : redactRelayError(received.error) };
+    const accounting = receipt.task_execution.accounting;
+    const result: WorkerCliResult = {
+      relay_task: receipt, exit_code: receipt.status === 'completed' ? 0 : 1,
+      stdout_tail: receipt.status === 'completed' ? JSON.stringify(receipt.output) : '',
+      stderr_tail: receipt.status === 'failed' ? `Relay task failed: ${receipt.error}` : '',
+      ...(accounting?.tokens_input === undefined ? {} : { tokens_input: accounting.tokens_input }),
+      ...(accounting?.tokens_output === undefined ? {} : { tokens_output: accounting.tokens_output }),
     };
+    return requirePricedUsage(result, model);
   } catch (error) {
-    const detail = error instanceof AgentRelayTransportError
-      ? error.message
-      : `agent-relay spawn failed: ${(error as Error).message ?? String(error)}`;
-    return { exit_code: null, stdout_tail: '', stderr_tail: detail };
+    signal?.throwIfAborted();
+    const detail = error instanceof AgentRelayTransportError ? error.message
+      : error instanceof Error ? error.message : 'Relay task transport failed';
+    return { exit_code: null, stdout_tail: '', stderr_tail: redactRelayError(detail) };
+  }
+}
+
+function redactRelayError(message: string): string {
+  for (const key of ['RELAY_AGENT_TOKEN', 'RELAY_API_KEY']) {
+    const secret = process.env[key];
+    if (secret) message = message.replaceAll(secret, '[redacted]');
   }
+  return message.replace(/\b(?:at|rk|nt|ot|br|arr)_(?:live_)?[A-Za-z0-9_-]+/g, '[redacted]');
 }
 
 async function spawnInvocation(

package/src/worker.ts

@@ -112,7 +112,8 @@ export class AgentWorker extends EventEmitter {
           onReady: this.options.onPtyReady, onDrive: () => { humanIntervention = true; },
         }, typeof spec.cwd === 'string' ? spec.cwd : undefined,
           spec.transport === 'relay' ? 'relay' : 'direct',
-          { runId: dispatch.run_id, stepId: dispatch.step_id })
+          { runId: dispatch.run_id, stepId: dispatch.step_id, idempotencyKey: dispatch.idempotency_key,
+            dataDir: this.options.dataDir, resultSchema: spec.verification?.json_schema })
         : Promise.resolve({ exit_code: null, stdout_tail: '', stderr_tail: 'agent step has no declared CLI' }));
     const { result, usage } = workerSpend(completed, spec.model);
     const completionReason = result.exit_code === 0 ? 'success' : 'worker_error';
@@ -130,7 +131,8 @@ export class AgentWorker extends EventEmitter {
     // emitting an error JSON with exit 0. `completionReason` is
     // derived from exit code, so a CLI that exits 0 while emitting
     // `{"error":...}` will report success with an error payload.
-    const output = parseJsonOutput(result.stdout_tail) ?? result;
+    const output = result.relay_task?.status === 'completed' && result.exit_code === 0
+      ? result.relay_task.output : parseJsonOutput(result.stdout_tail) ?? result;
 
     await this.client.stepComplete(
       dispatch.run_id,
@@ -140,6 +142,10 @@ export class AgentWorker extends EventEmitter {
       completionReason,
       {
         output,
+        ...(result.relay_task === undefined ? {} : { trajectory_tail: { relay_task: {
+          invocation_id: result.relay_task.invocation_id, status: result.relay_task.status,
+          task_execution: result.relay_task.task_execution, error: result.relay_task.error,
+        } } }),
         ...(humanIntervention ? { human_intervention: true } : {}),
         ...(usage !== undefined ? { usage } : {}),
         started_pins: dispatch.pins,