@relayflows/sdk 2.0.26 → 2.0.28

package/src/cloud-transcript-types.ts

@@ -0,0 +1,214 @@
+// The entry vocabulary `flows logs --step` renders, and the pure helpers both
+// provider parsers need.
+//
+// This module is a leaf: it imports nothing, so `cloud-transcript.ts` (the
+// public entry point and the Claude vocabulary) and `cloud-transcript-codex.ts`
+// can both depend on it without either depending on the other.
+//
+// The entry union is a public TypeScript API — `index.ts` re-exports it and
+// `flows logs --json` emits it. Everything added for Codex is either a new
+// member of the union or an optional field, so a Claude entry serializes to
+// exactly the bytes it serialized to before. A consumer switching
+// exhaustively over `kind` must still add the new members.
+
+export interface TranscriptAttempt {
+  kind: 'attempt';
+  attempt: number | null;
+  bytes: number | null;
+  truncated: boolean;
+}
+
+export interface TranscriptAttemptOmitted {
+  kind: 'attempt_omitted';
+  attempt: number | null;
+  bytes: number | null;
+}
+
+export interface TranscriptInit {
+  kind: 'init';
+  model: string | null;
+  version: string | null;
+  permission_mode: string | null;
+  tools: number | null;
+  mcp_servers: number | null;
+  session_id: string | null;
+}
+
+export interface TranscriptMessage {
+  kind: 'message';
+  role: 'assistant' | 'user';
+  text: string;
+  /** A frame carrying `parent_tool_use_id`: a subagent's turn, not the main one. */
+  nested: boolean;
+  /**
+   * Codex only, and only when false: the message was read off an
+   * `item.started`/`item.updated` snapshot that never completed, so the text
+   * is what had been written so far and not the whole of it.
+   */
+  complete?: boolean;
+}
+
+export interface TranscriptThinking {
+  kind: 'thinking';
+  /** The count only. A thinking block's text and signature never reach the page. */
+  chars: number;
+  nested: boolean;
+}
+
+/**
+ * The Codex half of a tool call. Present on an entry parsed from a Codex
+ * `command_execution` or `mcp_tool_call` item and absent on every Claude
+ * entry, which is what the renderer discriminates on: a Codex failure has to
+ * keep its exit code, its status and its result size on the same line, where
+ * Claude's renderer replaces the size with `ERROR`.
+ */
+export interface TranscriptToolCodex {
+  /** The call's position among the calls of its attempt, counted from 1. */
+  seq: number;
+  /** `in_progress`, `completed` or `failed`, as the item reported it. */
+  status: string | null;
+  /** Null when the item carried no exit code — not the same fact as exit 0. */
+  exit_code: number | null;
+  /** Redacted, then bounded. Null when the item carried no output field at all. */
+  output_excerpt: string | null;
+  /** True when a character or line bound cut the excerpt. */
+  output_truncated: boolean;
+  /** False when no `item.completed` ever arrived for this call. */
+  complete: boolean;
+  /** Redacted, then bounded. The item's own failure text. */
+  error: string | null;
+}
+
+export interface TranscriptTool {
+  kind: 'tool';
+  name: string;
+  /** What the call was aimed at: a path, a command, a pattern. Null when the input had no string. */
+  target: string | null;
+  /** Null when no `tool_result` answered it -- not the same fact as a zero-byte result. */
+  result_chars: number | null;
+  is_error: boolean;
+  nested: boolean;
+  /** Codex only. Its presence is what tells the renderer which shape to print. */
+  codex?: TranscriptToolCodex;
+}
+
+/** One `apply_patch` item: file activity, not a tool call, so it is not numbered. */
+export interface TranscriptFileChange {
+  kind: 'file_change';
+  changes: Array<{ path: string | null; change: string | null }>;
+  /** Change elements that were not objects. Counted rather than dropped. */
+  malformed: number;
+  status: string | null;
+  complete: boolean;
+}
+
+export interface TranscriptThread {
+  kind: 'thread';
+  thread_id: string | null;
+}
+
+export interface TranscriptTurn {
+  kind: 'turn';
+  phase: 'started' | 'completed' | 'failed';
+  tokens_in: number | null;
+  tokens_out: number | null;
+  cache_read: number | null;
+  cache_creation: number | null;
+  reasoning_out: number | null;
+}
+
+/** A `turn.failed`, a top-level `error` frame, or an `error` item. */
+export interface TranscriptError {
+  kind: 'error';
+  /** The frame this came from, so the reader knows what failed. */
+  source: string;
+  message: string;
+}
+
+export interface TranscriptResult {
+  kind: 'result';
+  is_error: boolean;
+  subtype: string | null;
+  duration_ms: number | null;
+  num_turns: number | null;
+  total_cost_usd: number | null;
+  tokens_in: number | null;
+  tokens_out: number | null;
+  cache_read: number | null;
+  cache_creation: number | null;
+}
+
+export interface TranscriptUnknown {
+  kind: 'unknown';
+  type: string;
+  chars: number;
+}
+
+export interface TranscriptUnparsed {
+  kind: 'unparsed';
+  text: string;
+}
+
+export type TranscriptEntry =
+  | TranscriptAttempt | TranscriptAttemptOmitted | TranscriptInit | TranscriptMessage
+  | TranscriptThinking | TranscriptTool | TranscriptFileChange | TranscriptThread
+  | TranscriptTurn | TranscriptError | TranscriptResult | TranscriptUnknown | TranscriptUnparsed;
+
+export interface ParsedTranscript {
+  entries: TranscriptEntry[];
+  /** How many attempts said their head was cut to fit the log cap. */
+  truncated_attempts: number;
+  /** How many attempts were dropped whole to fit the log cap. */
+  omitted_attempts: number;
+  /**
+   * False when the log carried no frame either vocabulary this module knows --
+   * a v1 plain-terminal sandbox log, say. The caller prints it raw rather than
+   * claiming an empty transcript.
+   */
+  stream_json: boolean;
+}
+
+/** A command, an argument list or a `server/tool` pair on one line. */
+export const TARGET_MAX_CHARS = 160;
+
+/** A command's or a tool's output excerpt: enough to read, bounded either way. */
+export const OUTPUT_MAX_CHARS = 1000;
+export const OUTPUT_MAX_LINES = 10;
+
+/** Provider-supplied failure text. Prose from the agent is the only uncapped string. */
+export const ERROR_MAX_CHARS = 1000;
+
+/** A path stays identifiable, so it is bounded far above a one-line target. */
+export const PATH_MAX_CHARS = 200;
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function str(value: unknown): string | null {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+export function num(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+/** Collapse to one line and bound it; a tool input can be a whole file body. */
+export function oneLine(text: string, limit = TARGET_MAX_CHARS): string {
+  const flat = text.replace(/\s+/gu, ' ').trim();
+  return flat.length <= limit ? flat : `${flat.slice(0, limit)}…`;
+}
+
+export function thousands(value: number): string {
+  return String(value).replace(/\B(?=(\d{3})+(?!\d))/gu, ',');
+}
+
+/** Terminal control characters never reach the page, wherever the text came from. */
+export function safe(text: string): string {
+  return text.replace(/[\u0000-\u0009\u000B-\u001F\u007F-\u009F]/gu, '?');
+}
+
+/** One rule with a label, the way an attempt boundary reads. */
+export function separator(label: string): string {
+  return `── ${label} ${'─'.repeat(Math.max(2, 68 - label.length))}`;
+}

package/src/cloud-transcript.ts

@@ -1,13 +1,16 @@
 // Rendering an agent step's transcript JSONL for a terminal.
 //
-// The frames are what the harness wrote (Claude Code's `stream-json`), wrapped
-// by the `relayflow.attempt` markers the v2 executor interleaves when it
-// assembles one log out of several attempts. The frame vocabulary read here is
-// the one Cloud's dashboard renderer reads (cloud#3847,
-// `packages/web/lib/workflows/agent-transcript.ts`) -- the same shapes, so the
-// CLI and the dashboard agree about what a run did. The implementation is not
-// shared: this package cannot import from the Cloud app, and a CLI that had to
-// be deployed in step with a dashboard would be worse than one that does not.
+// The frames are what the harness wrote -- Claude Code's `stream-json`, or
+// `codex exec --json` -- wrapped by the `relayflow.attempt` markers the v2
+// executor interleaves when it assembles one log out of several attempts.
+// The Claude frame vocabulary read here is the one Cloud's dashboard renderer
+// reads (cloud#3847, `packages/web/lib/workflows/agent-transcript.ts`) -- the
+// same shapes, so the CLI and the dashboard agree about what a run did. The
+// implementation is not shared: this package cannot import from the Cloud app,
+// and a CLI that had to be deployed in step with a dashboard would be worse
+// than one that does not. The Codex vocabulary lives in
+// `cloud-transcript-codex.ts`; dispatch is per frame, not per provider, so a
+// log that mixes them stays honest rather than being forced into a guess.
 //
 // Two rules the shapes do not give you:
 //
@@ -19,98 +22,21 @@
 //    the redactor `flows status` uses. Transcript text is whatever the agent
 //    printed, including anything it read out of its own environment.
 
+import {
+  CODEX_FRAME_TYPES, codexFrame, indexCodexItems, renderCodexEntry, type CodexState,
+} from './cloud-transcript-codex.js';
+import {
+  TARGET_MAX_CHARS, isRecord, num, oneLine, safe, separator, str, thousands,
+  type ParsedTranscript, type TranscriptEntry,
+} from './cloud-transcript-types.js';
 import { redact } from './redact.js';
 
-export interface TranscriptAttempt {
-  kind: 'attempt';
-  attempt: number | null;
-  bytes: number | null;
-  truncated: boolean;
-}
-
-export interface TranscriptAttemptOmitted {
-  kind: 'attempt_omitted';
-  attempt: number | null;
-  bytes: number | null;
-}
-
-export interface TranscriptInit {
-  kind: 'init';
-  model: string | null;
-  version: string | null;
-  permission_mode: string | null;
-  tools: number | null;
-  mcp_servers: number | null;
-  session_id: string | null;
-}
-
-export interface TranscriptMessage {
-  kind: 'message';
-  role: 'assistant' | 'user';
-  text: string;
-  /** A frame carrying `parent_tool_use_id`: a subagent's turn, not the main one. */
-  nested: boolean;
-}
-
-export interface TranscriptThinking {
-  kind: 'thinking';
-  /** The count only. A thinking block's text and signature never reach the page. */
-  chars: number;
-  nested: boolean;
-}
-
-export interface TranscriptTool {
-  kind: 'tool';
-  name: string;
-  /** What the call was aimed at: a path, a command, a pattern. Null when the input had no string. */
-  target: string | null;
-  /** Null when no `tool_result` answered it -- not the same fact as a zero-byte result. */
-  result_chars: number | null;
-  is_error: boolean;
-  nested: boolean;
-}
-
-export interface TranscriptResult {
-  kind: 'result';
-  is_error: boolean;
-  subtype: string | null;
-  duration_ms: number | null;
-  num_turns: number | null;
-  total_cost_usd: number | null;
-  tokens_in: number | null;
-  tokens_out: number | null;
-  cache_read: number | null;
-  cache_creation: number | null;
-}
-
-export interface TranscriptUnknown {
-  kind: 'unknown';
-  type: string;
-  chars: number;
-}
-
-export interface TranscriptUnparsed {
-  kind: 'unparsed';
-  text: string;
-}
-
-export type TranscriptEntry =
-  | TranscriptAttempt | TranscriptAttemptOmitted | TranscriptInit | TranscriptMessage
-  | TranscriptThinking | TranscriptTool | TranscriptResult | TranscriptUnknown | TranscriptUnparsed;
-
-export interface ParsedTranscript {
-  entries: TranscriptEntry[];
-  /** How many attempts said their head was cut to fit the log cap. */
-  truncated_attempts: number;
-  /** How many attempts were dropped whole to fit the log cap. */
-  omitted_attempts: number;
-  /**
-   * False when the log carried no frame this vocabulary knows -- a v1
-   * plain-terminal sandbox log, say. The caller prints it raw rather than
-   * claiming an empty transcript.
-   */
-  stream_json: boolean;
-}
+export type {
+  ParsedTranscript, TranscriptEntry, TranscriptAttempt, TranscriptAttemptOmitted, TranscriptError,
+  TranscriptFileChange, TranscriptInit, TranscriptMessage, TranscriptResult, TranscriptThinking,
+  TranscriptThread, TranscriptTool, TranscriptToolCodex, TranscriptTurn, TranscriptUnknown,
+  TranscriptUnparsed,
+} from './cloud-transcript-types.js';
 
 /**
  * Which input field names a tool call. Order matters: the first present
@@ -122,26 +48,6 @@ const TARGET_KEYS = [
   'prompt', 'description', 'subagent_type',
 ] as const;
 
-const TARGET_MAX_CHARS = 160;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function str(value: unknown): string | null {
-  return typeof value === 'string' && value.length > 0 ? value : null;
-}
-
-function num(value: unknown): number | null {
-  return typeof value === 'number' && Number.isFinite(value) ? value : null;
-}
-
-/** Collapse to one line and bound it; a tool input can be a whole file body. */
-function oneLine(text: string, limit = TARGET_MAX_CHARS): string {
-  const flat = text.replace(/\s+/gu, ' ').trim();
-  return flat.length <= limit ? flat : `${flat.slice(0, limit)}…`;
-}
-
 /**
  * `clean` runs before `oneLine`, not after, and the order is load-bearing.
  *
@@ -154,12 +60,12 @@ function toolTarget(input: unknown, clean: (text: string) => string): string | n
   if (!isRecord(input)) return null;
   for (const key of TARGET_KEYS) {
     const value = str(input[key]);
-    if (value !== null) return oneLine(clean(value));
+    if (value !== null) return oneLine(clean(value), TARGET_MAX_CHARS);
   }
   // An unfamiliar tool still shows something rather than nothing.
   for (const value of Object.values(input)) {
     const text = str(value);
-    if (text !== null) return oneLine(clean(text));
+    if (text !== null) return oneLine(clean(text), TARGET_MAX_CHARS);
   }
   return null;
 }
@@ -219,13 +125,15 @@ export function parseAgentTranscript(content: string, env: NodeJS.ProcessEnv = p
     }
   }
   const results = indexToolResults(frames);
+  const codexIndex = indexCodexItems(raw);
+  const codexState: CodexState = { seq: 0 };
   const entries: TranscriptEntry[] = [];
   let truncatedAttempts = 0;
   let omittedAttempts = 0;
   let streamJson = false;
   const clean = (text: string): string => redact(text, env);
 
-  for (const { frame, line } of raw) {
+  for (const [index, { frame, line }] of raw.entries()) {
     if (frame === undefined || !isRecord(frame)) {
       entries.push({ kind: 'unparsed', text: clean(line) });
       continue;
@@ -233,6 +141,8 @@ export function parseAgentTranscript(content: string, env: NodeJS.ProcessEnv = p
     const type = str(frame['type']);
     if (type === 'relayflow.attempt') {
       streamJson = true;
+      // Calls are numbered within an attempt, so a second attempt starts over.
+      codexState.seq = 0;
       const truncated = frame['truncated'] === true;
       if (truncated) truncatedAttempts += 1;
       entries.push({ kind: 'attempt', attempt: num(frame['attempt']), bytes: num(frame['bytes']), truncated });
@@ -240,10 +150,16 @@ export function parseAgentTranscript(content: string, env: NodeJS.ProcessEnv = p
     }
     if (type === 'relayflow.attempt.omitted') {
       streamJson = true;
+      codexState.seq = 0;
       omittedAttempts += 1;
       entries.push({ kind: 'attempt_omitted', attempt: num(frame['attempt']), bytes: num(frame['bytes']) });
       continue;
     }
+    if (type !== null && CODEX_FRAME_TYPES.has(type)) {
+      streamJson = true;
+      entries.push(...(codexFrame(frame, type, index, codexIndex, codexState, clean, line) ?? []));
+      continue;
+    }
     if (type === 'system' && frame['subtype'] === 'init') {
       streamJson = true;
       const tools = frame['tools'];
@@ -327,28 +243,14 @@ export function parseAgentTranscript(content: string, env: NodeJS.ProcessEnv = p
   return { entries, truncated_attempts: truncatedAttempts, omitted_attempts: omittedAttempts, stream_json: streamJson };
 }
 
-function thousands(value: number): string {
-  return String(value).replace(/\B(?=(\d{3})+(?!\d))/gu, ',');
-}
-
 function seconds(ms: number): string {
   return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
 }
 
-/** Terminal control characters never reach the page, wherever the text came from. */
-function safe(text: string): string {
-  return text.replace(/[\u0000-\u0009\u000B-\u001F\u007F-\u009F]/gu, '?');
-}
-
 function dollars(value: number): string {
   return `$${value.toFixed(6).replace(/0+$/u, '').replace(/\.$/u, '')}`;
 }
 
-/** One rule with a label, the way an attempt boundary reads. */
-function separator(label: string): string {
-  return `── ${label} ${'─'.repeat(Math.max(2, 68 - label.length))}`;
-}
-
 /**
  * Render a parsed transcript as terminal lines.
  *
@@ -359,6 +261,11 @@ function separator(label: string): string {
 export function renderAgentTranscript(parsed: ParsedTranscript): string[] {
   const lines: string[] = [];
   for (const entry of parsed.entries) {
+    // A Codex tool call carries its exit code, its status and its result size
+    // on one line, which the Claude shape below has no room for; everything
+    // the Codex vocabulary owns is rendered there.
+    const codex = renderCodexEntry(entry);
+    if (codex !== undefined) { lines.push(...codex); continue; }
     switch (entry.kind) {
       case 'attempt': {
         const size = entry.bytes === null ? '' : ` · ${thousands(entry.bytes)} bytes`;
@@ -380,7 +287,8 @@ export function renderAgentTranscript(parsed: ParsedTranscript): string[] {
         break;
       }
       case 'message': {
-        const who = `${entry.role}${entry.nested ? ' (subagent)' : ''}`;
+        const state = entry.complete === false ? ' (incomplete)' : '';
+        const who = `${entry.role}${entry.nested ? ' (subagent)' : ''}${state}`;
         const body = entry.text.split('\n');
         lines.push(`${who}:`);
         for (const line of body) lines.push(`  ${safe(line)}`);

package/src/failure-kinds.ts

@@ -177,9 +177,17 @@ export interface StepFailedDetails {
    */
   maxIterations?: number;
   exitCode?: number;
-  /** Terminal-safe UTF-8 excerpt, at most 1,024 bytes. */
+  /**
+   * Terminal-safe UTF-8 excerpt of the captured stdout, at most
+   * `EXCERPT_BYTES` (cli/step-excerpt.ts). The field name is kept for
+   * compatibility; it is no longer a plain tail. When the captured field did
+   * not fit, the excerpt keeps a head, the lines from the elided middle that
+   * match a failure marker, and a tail, and states the elision in band. The
+   * absence of an elision marker means the field the journal carried fit
+   * whole — not that the command printed no more than this.
+   */
   stdoutTail?: string;
-  /** Terminal-safe UTF-8 excerpt, at most 1,024 bytes. */
+  /** Terminal-safe UTF-8 excerpt of the captured stderr; see `stdoutTail`. */
   stderrTail?: string;
   /**
    * The daemon's own account when it was not a render of the fields above, or

package/src/journal-client.ts

@@ -61,6 +61,8 @@ export class JournalProtocolError extends Error {
 
 export class JournalClient extends EventEmitter {
   private socket: Socket | null = null;
+  /** Why the connection ended, so a later "not connected" names its cause rather than hiding it. */
+  private disconnectCause: Error | undefined;
   private buffer = '';
   private readonly pending = new Map<string, Pending>();
   private readonly requestTimeoutMs: number;
@@ -103,18 +105,31 @@ export class JournalClient extends EventEmitter {
       socket.once('connect', () => {
         clearTimeout(timer);
         socket.removeListener('error', onError);
-        socket.on('error', (err) => this.failAll(err));
+        socket.on('error', (err) => { this.disconnectCause ??= err; this.failAll(err); });
         socket.on('data', (chunk) => this.onData(chunk));
-        socket.on('close', () => this.failAll(new Error('journal client: connection closed')));
+        socket.on('close', () => {
+          const closed = new Error('journal client: connection closed');
+          this.disconnectCause ??= closed;
+          this.failAll(closed);
+        });
+        this.disconnectCause = undefined;
         this.socket = socket;
         resolve();
       });
     });
   }
 
-  /** Close the connection and reject any pending requests. */
-  close(): void {
-    this.failAll(new Error('journal client: closed by caller'));
+  /**
+   * Close the connection and reject any pending requests. A `cause` (for
+   * example the worker failure that forced the close) is carried into every
+   * later "not connected" rejection.
+   */
+  close(cause?: unknown): void {
+    const closed = cause === undefined
+      ? new Error('journal client: closed by caller')
+      : new Error(`journal client: closed after ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.disconnectCause ??= closed;
+    this.failAll(closed);
     this.socket?.destroy();
     this.socket = null;
     this.buffer = '';
@@ -170,7 +185,11 @@ export class JournalClient extends EventEmitter {
   ): Promise<VerbContract[V]['result']> {
     return new Promise((resolve, reject) => {
       if (!this.socket || this.socket.destroyed) {
-        reject(new Error(`journal client: not connected (${verb})`));
+        const cause = this.disconnectCause;
+        reject(new Error(
+          `journal client: not connected (${verb})${cause === undefined ? '' : `: ${cause.message}`}`,
+          cause === undefined ? undefined : { cause },
+        ));
         return;
       }
       const id = randomUUID();

package/src/llm-worker.ts

@@ -1,4 +1,5 @@
 import { workerSpend } from './worker-spend.js';
+import { DEFAULT_LOCAL_AGENT_CAPACITY } from './worker-slots.js';
 import type { WorkerCliResult } from './worker-cli.js';
 import { EventEmitter } from 'node:events';
 import type { JournalClient } from './journal-client.js';
@@ -17,7 +18,11 @@ export class LlmWorker extends EventEmitter {
   private closing = false;
   private readonly inFlight = new Set<Promise<void>>();
 
-  constructor(private readonly client: JournalClient, private readonly workerId: string) {
+  constructor(
+    private readonly client: JournalClient,
+    private readonly workerId: string,
+    private readonly capacity: number = DEFAULT_LOCAL_AGENT_CAPACITY,
+  ) {
     super();
   }
 
@@ -25,7 +30,7 @@ export class LlmWorker extends EventEmitter {
     if (this.attached || this.closing) throw new Error('llm worker: cannot attach twice or after close');
     this.client.on('step.dispatch', this.onDispatch);
     try {
-      await this.client.workerAttach(this.workerId, ['llm'], { workspace: [], streams: [] }, 1);
+      await this.client.workerAttach(this.workerId, ['llm'], { workspace: [], streams: [] }, this.capacity);
       this.attached = true;
     } catch (error) {
       this.client.off('step.dispatch', this.onDispatch);

package/src/local-agent.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import type { JournalClient } from './journal-client.js';
 import { AgentWorker } from './worker.js';
+import { DEFAULT_LOCAL_AGENT_CAPACITY } from './worker-slots.js';
 
 /** A local worker for stream-only steps; no workspace recovery is claimed. */
 export async function attachLocalAgent(
@@ -8,6 +9,7 @@ export async function attachLocalAgent(
   dataDir?: string,
   onPtyReady?: (path: string) => void,
   requestedStream?: string,
+  capacity: number = DEFAULT_LOCAL_AGENT_CAPACITY,
 ): Promise<{
   stream: string;
   readonly failure: unknown;
@@ -18,12 +20,16 @@ export async function attachLocalAgent(
   const stream = requestedStream ?? `local-agent-${randomUUID()}`;
   const worker = new AgentWorker(client, {
     workerId: stream,
-    capacity: 1,
+    // More than one: independent agent steps run side by side instead of the
+    // second parking behind the first. Authored bodies size their admission to
+    // this same number (worker-slots.ts), so they never ask for more.
+    capacity,
     dataDir, onPtyReady,
     pins: { workspace: [], streams: [{ stream, read_offset: 0 }] },
   });
   let failure: unknown;
-  worker.on('error', error => { failure = error; client.close(); });
+  // The cause travels with the close, so the flow's next request names it.
+  worker.on('error', error => { failure = error; client.close(error); });
   await worker.attach();
   return {
     stream,