@moureau/pipeflow 0.0.2 → 0.0.3

package/dist/types/client/client.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Pipeflow client SDK: talk to a Pipeflow server from a browser or Node.
+ */
+import type { AudioChunk, ConversationId, Generation, ToolCall, ToolCallResult, Turn, UserId } from "../conversations/types.js";
+import type { TranscriptEntry } from "../conversations/transcription/transcription.js";
+import type { Protocol } from "./protocol.js";
+/** Track constraints used when opening the mic. */
+export interface CaptureConstraints {
+    echoCancellation?: boolean;
+    noiseSuppression?: boolean;
+    autoGainControl?: boolean;
+}
+/** Optional mic auto-attach on `connect()`. */
+export interface AudioInputOptions {
+    /** Auto-attach `getUserMedia` and stream mic audio into the connection. */
+    input?: boolean;
+    /**
+     * Gate or rewrite captured audio before it hits the wire: return a chunk
+     * to send it, or `null` to drop it (a VAD gate). May be async. Chunks are
+     * sent as the hook resolves and their `sequence` marks capture order, so
+     * the server can reorder them before STT. Applies only to captured
+     * audio; manual `sendAudio()` calls go out untouched.
+     */
+    transform?: (chunk: AudioChunk) => AudioChunk | null | Promise<AudioChunk | null>;
+    /**
+     * Mic track constraints. Each defaults to `true`. Echo cancellation is the
+     * one that matters: without it the mic re-captures the agent's own reply.
+     */
+    constraints?: CaptureConstraints;
+}
+export interface ReconnectOptions {
+    /** Maximum reconnect attempts after an unexpected close. `0` disables it. */
+    maxAttempts?: number;
+    /** Initial backoff in ms; doubled each attempt up to `maxBackoffMs`. */
+    initialBackoffMs?: number;
+    /** Backoff cap in ms. */
+    maxBackoffMs?: number;
+}
+export interface PipeflowClientOptions {
+    /** The wire protocol. */
+    protocol: Protocol;
+    /** Audio capture options. */
+    audio?: AudioInputOptions;
+    /** Auto-reconnect on unexpected close. */
+    reconnect?: ReconnectOptions;
+    /** Default user id for `sendText()` / `sendAudio()` when not provided. */
+    userId?: UserId;
+}
+/**
+ * Payloads emitted by `PipeflowClient` events, mirroring `ConversationEvents`
+ * for the events that travel the wire.
+ */
+export interface PipeflowClientEventMap {
+    start: {
+        conversationId: ConversationId;
+    };
+    stop: {
+        conversationId: ConversationId;
+    };
+    "audio-in": {
+        conversationId: ConversationId;
+        userId: UserId;
+        audio: AudioChunk;
+    };
+    audio: {
+        conversationId: ConversationId;
+        audio: AudioChunk;
+    };
+    "partial-transcript": {
+        conversationId: ConversationId;
+        userId: UserId;
+        text: string;
+    };
+    turn: {
+        conversationId: ConversationId;
+        turn: Turn;
+    };
+    transcript: {
+        conversationId: ConversationId;
+        entry: TranscriptEntry;
+    };
+    generation: {
+        conversationId: ConversationId;
+        generation: Generation;
+    };
+    "tool-call": {
+        conversationId: ConversationId;
+        call: ToolCall;
+    };
+    "tool-call-result": {
+        conversationId: ConversationId;
+        result: ToolCallResult;
+    };
+    interrupt: {
+        conversationId: ConversationId;
+    };
+    error: {
+        conversationId?: ConversationId;
+        error: Error;
+    };
+    state: {
+        conversationId: ConversationId;
+        state: unknown;
+    };
+}
+export type PipeflowClientEvent = keyof PipeflowClientEventMap;
+export type Listener<E extends PipeflowClientEvent> = (event: PipeflowClientEventMap[E]) => void;
+/**
+ * Typed client for a Pipeflow server: `connect()`, then events flow while
+ * you send text and audio, then `disconnect()`.
+ *
+ * ```ts
+ * const client = new PipeflowClient({
+ *   protocol: new WebSocketProtocol({ url: "wss://…/conversations/abc" }),
+ *   audio: { input: true },
+ * });
+ * client.on("turn", (e) => console.log(e.turn.text));
+ * await client.connect();
+ * ```
+ *
+ * Mic capture is opt-in via `audio.input`. Playback is the caller's job:
+ * wire the `audio` event into your own `AudioContext` or `<audio>` queue,
+ * or override `playAudio()`.
+ */
+export declare class PipeflowClient {
+    private readonly protocol;
+    private readonly audio;
+    private readonly reconnect;
+    private readonly defaultUserId;
+    private readonly listeners;
+    private mediaStream;
+    private mediaRecorder;
+    private startMicPromise;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private closedByUser;
+    private nextSequence;
+    constructor(options: PipeflowClientOptions);
+    /**
+     * Open the connection and, if `audio.input` is set, attach the mic.
+     * Subsequent calls are no-ops while the connection is open.
+     */
+    connect(): Promise<void>;
+    /** Close the connection, release the mic, and disable reconnect. */
+    disconnect(): Promise<void>;
+    /**
+     * Send a finalized text turn. Equivalent to `conversation.send({ userId, text })`.
+     */
+    sendText(text: string, options?: {
+        userId?: UserId;
+    }): void;
+    /**
+     * Send a raw audio chunk. `listen()` on the server is synchronous; call
+     * this for every chunk as it arrives. The chunk's `sequence` marks
+     * capture order for the server's reorder buffer.
+     */
+    sendAudio(audio: AudioChunk, options?: {
+        userId?: UserId;
+    }): void;
+    /** Request an interrupt on the server. */
+    interrupt(options?: {
+        conversationId?: ConversationId;
+    }): void;
+    /** Resolve a tool call when `autoExecuteTools` is off on the server. */
+    resolveToolCall(result: ToolCallResult, options?: {
+        conversationId?: ConversationId;
+    }): void;
+    /**
+     * No-op playback hook. Override it, or listen to `audio` directly.
+     */
+    playAudio(_audio: AudioChunk): void;
+    /** Subscribe to an event. Returns an unsubscribe function. */
+    on<E extends PipeflowClientEvent>(event: E, listener: Listener<E>): () => void;
+    /** Remove a previously added listener. */
+    off<E extends PipeflowClientEvent>(event: E, listener: Listener<E>): void;
+    private send;
+    private handleMessage;
+    private handleStatus;
+    private scheduleReconnect;
+    private clearReconnect;
+    /** Attach the mic once, even under concurrent `connect()` calls. */
+    private startMic;
+    private openMic;
+    private stopMic;
+    private emit;
+}

package/dist/types/client/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Browser/client SDK for talking to a Pipeflow server.
+ *
+ * The client is intentionally tiny: a typed event surface that mirrors
+ * `Conversation`, backed by a swappable wire protocol. It knows nothing about
+ * STT/LLM/TTS: it forwards your input and surfaces what comes back.
+ *
+ * ```ts
+ * import { PipeflowClient, WebSocketProtocol } from "@moureau/pipeflow/client";
+ *
+ * const client = new PipeflowClient({
+ *   protocol: new WebSocketProtocol({
+ *     url: "wss://api.example.com/conversations/abc",
+ *     token: () => localStorage.getItem("jwt"),
+ *   }),
+ *   audio: { input: true },
+ * });
+ *
+ * client.on("transcript", (e) => render(e.entry.text));
+ * client.on("audio", (e) => client.playAudio(e.audio));
+ * await client.connect();
+ * await client.sendText("hello", { userId: "alice" });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { PipeflowClient } from "./client.js";
+export type { PipeflowClientOptions, PipeflowClientEvent, PipeflowClientEventMap, Listener, ReconnectOptions, AudioInputOptions, CaptureConstraints, } from "./client.js";
+export type { Protocol, ProtocolStatus, ProtocolMessage, ProtocolListener, StatusListener, } from "./protocol.js";
+export { WebSocketProtocol } from "./protocol/websocket.js";
+export type { WebSocketProtocolOptions, TokenProvider, } from "./protocol/websocket.js";

package/dist/types/client/json.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Minimal JSON value guard for outbound messages.
+ *
+ * Kept narrow on purpose: server payloads carry domain types (turns,
+ * transcripts, audio chunks) that aren't structurally typed as JSON values,
+ * so the wire uses `unknown`. Outbound payloads, however, must serialize;
+ * this guard catches values that JSON.stringify would silently drop
+ * (functions, `undefined`, `bigint`).
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function isJsonSerializable(value: unknown): boolean;

package/dist/types/client/protocol/websocket.d.ts

@@ -0,0 +1,56 @@
+/**
+ * WebSocket-backed implementation of the `Protocol` contract.
+ *
+ * The URL, auth token, and subprotocols are passed through to the underlying
+ * `WebSocket`. The token is resolved lazily on each `connect()` and appended
+ * to the URL as a `token` query parameter so the server can authenticate the
+ * upgrade (WebSocket has no `Authorization` header mechanism).
+ *
+ * ```ts
+ * const protocol = new WebSocketProtocol({
+ *   url: "wss://api.example.com/conversations/abc",
+ *   token: () => localStorage.getItem("jwt"),
+ * });
+ * ```
+ */
+import type { Protocol, ProtocolListener, ProtocolMessage, ProtocolStatus, StatusListener } from "../protocol.js";
+/**
+ * Resolves the connection token. Called on every `connect()` so the caller
+ * can rotate credentials without rebuilding the client. The resolved value
+ * is appended to the URL as `?token=…` (overwriting any existing value).
+ */
+export type TokenProvider = () => string | null | Promise<string | null>;
+export interface WebSocketProtocolOptions {
+    /** Fully-qualified WebSocket URL, e.g. `wss://api.example.com/conversations/abc`. */
+    url: string;
+    /** Optional token resolver; the resolved value is appended as `?token=…`. */
+    token?: TokenProvider;
+    /** Subprotocols passed to the WebSocket constructor. */
+    protocols?: string | string[];
+    /**
+     * Inject a custom WebSocket constructor (for tests, polyfills, or tracing).
+     * Defaults to the global `WebSocket`.
+     */
+    socketFactory?: (url: string, protocols?: string | string[]) => WebSocket;
+}
+export declare class WebSocketProtocol implements Protocol {
+    readonly url: string;
+    private readonly token?;
+    private readonly protocols?;
+    private readonly socketFactory;
+    private socket;
+    private _status;
+    private readonly messageListeners;
+    private readonly statusListeners;
+    constructor(options: WebSocketProtocolOptions);
+    get status(): ProtocolStatus;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    send(message: ProtocolMessage): void;
+    onMessage(listener: ProtocolListener): () => void;
+    onStatus(listener: StatusListener): () => void;
+    private readonly handleMessage;
+    private readonly handleClose;
+    private teardownSocket;
+    private setStatus;
+}

package/dist/types/client/protocol.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Wire-level contract between a `PipeflowClient` and a Pipeflow server.
+ *
+ * A `Protocol` is responsible only for transport: it opens a connection,
+ * delivers `ProtocolMessage`s, and reports its status. The client sits on
+ * top and turns those messages into typed events.
+ *
+ * Swap protocols to change the wire (WebSocket today; SSE, HTTP, or an
+ * in-memory pair for tests tomorrow) without touching application code.
+ */
+/** Lifecycle status of a protocol connection. */
+export type ProtocolStatus = "idle" | "connecting" | "open" | "closing" | "closed";
+/**
+ * A message exchanged over a `Protocol`. Symmetric: both sides send and
+ * receive. `payload` is intentionally `unknown`: payloads are JSON-shaped
+ * server domain types (turns, transcripts, audio chunks, …) that the client
+ * decodes against its event map at the boundary.
+ */
+export interface ProtocolMessage {
+    type: string;
+    payload: unknown;
+}
+export type ProtocolListener = (message: ProtocolMessage) => void;
+export type StatusListener = (status: ProtocolStatus) => void;
+/**
+ * A bidirectional wire between a Pipeflow client and server.
+ *
+ * Implementations must be safe to subscribe to before `connect()`: messages
+ * received before the listener is attached are buffered or dropped per the
+ * implementation's policy, and a listener attached after `connect()` only sees
+ * subsequent messages. This mirrors the WebSocket contract.
+ */
+export interface Protocol {
+    /** Current lifecycle status. */
+    readonly status: ProtocolStatus;
+    /** Open the underlying connection. Idempotent: a second call is a no-op. */
+    connect(): Promise<void>;
+    /** Close the connection. Safe to call from any state. */
+    close(): Promise<void>;
+    /** Send a message. Throws if the connection is not `open`. */
+    send(message: ProtocolMessage): void;
+    /** Subscribe to incoming messages. Returns an unsubscribe function. */
+    onMessage(listener: ProtocolListener): () => void;
+    /** Subscribe to status transitions. Returns an unsubscribe function. */
+    onStatus(listener: StatusListener): () => void;
+}

package/dist/types/conversations/conversation/conversation.d.ts

@@ -17,6 +17,29 @@ export interface ConversationOptions {
      */
     stt?: STT;
     tts?: TTS;
+    /**
+     * Execute the agents' tools automatically (default `true`), feeding each
+     * tool's result back into the model loop. Set `false` to resolve tool
+     * calls from your own backend via `resolveToolCall()`.
+     */
+    autoExecuteTools?: boolean;
+    /**
+     * TTS synthesis concurrency (default 2): more in-flight requests let a
+     * multi-sentence reply synthesize in parallel, removing the gaps between
+     * sentences, at the cost of provider concurrency. See
+     * `SpeechPipelineOptions.maxConcurrentRequests`.
+     */
+    maxConcurrentTtsRequests?: number;
+    /**
+     * Hold window (ms) for out-of-order audio (default 100). When `listen()`
+     * receives a chunk whose `sequence` skips ahead of the expected one, the
+     * chunk is held briefly so a packet still in flight can fill the gap —
+     * netcode-style reordering, like client-side prediction in multiplayer
+     * games. When the window expires the gap is skipped and the buffered
+     * chunks are released in order. In-order audio (the common case) is
+     * emitted immediately, with no added latency.
+     */
+    audioReorderMs?: number;
 }
 export interface ConversationEvents {
     start: {
@@ -119,9 +142,13 @@ export declare class Conversation {
     private readonly persistence;
     private readonly stt;
     private readonly tts;
+    private readonly autoExecuteTools;
+    private readonly maxConcurrentTtsRequests;
     private readonly listeners;
     private readonly pendingToolCallsById;
     private readonly subGenerations;
+    private readonly audioReorderMs;
+    private readonly audioReorder;
     private nextAudioSequence;
     constructor(options: ConversationOptions);
     get status(): ConversationStatus;
@@ -137,11 +164,29 @@ export declare class Conversation {
     /**
      * Send an audio packet. Intentionally synchronous: it means "send this
      * packet", not "wait for this utterance to finish".
+     *
+     * Pass the sender's `sequence` number to enable netcode-style reordering:
+     * chunks arriving ahead of a gap are held for `audioReorderMs` so an
+     * earlier packet still in flight can fill it, then released in order
+     * (gaps are skipped when the window expires). The orchestrator and STT
+     * always see the participant's audio in sequence order. Without a
+     * `sequence`, the chunk is emitted on arrival, as-is.
      */
     listen(input: {
         userId: UserId;
         audio: Uint8Array;
+        sequence?: number;
     }): void;
+    /** Emit an audio-in event with the conversation's own sequence numbering. */
+    private emitAudioIn;
+    /** Hold/drain logic for sequenced audio, keyed per participant. */
+    private reorderAudio;
+    /**
+     * Release everything a participant has buffered, in sequence order,
+     * skipping the gap that never filled.
+     */
+    private releaseReorderBuffer;
+    private clearReorderTimer;
     /**
      * Send a finalized text turn, bypassing STT. Triggers the same pipeline as
      * a transcribed utterance (routing, coordination, generation, resume) —

package/dist/types/conversations/conversations.d.ts

@@ -7,12 +7,35 @@ import type { TranscriptEntry } from "./transcription/transcription.js";
 import { Conversation } from "./conversation/conversation.js";
 export interface CreateConversationOptions {
     agents?: Agent[];
+    /**
+     * Execute the agents' tools automatically (default `true`). Set `false`
+     * for this conversation to resolve tool calls from your own backend via
+     * `resolveToolCall()`. Overrides the `Conversations`-level default.
+     */
+    autoExecuteTools?: boolean;
+    /**
+     * TTS synthesis concurrency (default 2). More in-flight requests let a
+     * multi-sentence reply synthesize in parallel, removing the gaps between
+     * sentences, at the cost of provider concurrency — some free TTS variants
+     * rate-limit concurrent requests.
+     */
+    maxConcurrentTtsRequests?: number;
+    /**
+     * Hold window (ms) for out-of-order audio (default 100). See
+     * `ConversationOptions.audioReorderMs`.
+     */
+    audioReorderMs?: number;
 }
 export interface ConversationsOptions {
     persistence: Persistence;
     /** Passed to conversations so `start()` can attach realtime processing. */
     stt?: STT;
     tts?: TTS;
+    /**
+     * Default for created conversations: auto-execute the agents' tools
+     * (default `true`). See `CreateConversationOptions.autoExecuteTools`.
+     */
+    autoExecuteTools?: boolean;
 }
 /**
  * The conversations API surface of a Pipeflow instance: create persistent
@@ -22,6 +45,7 @@ export declare class Conversations {
     private readonly persistence;
     private readonly stt;
     private readonly tts;
+    private readonly autoExecuteTools;
     constructor(options: ConversationsOptions);
     /** Create a persistent conversation. Realtime execution is separate. */
     create(options?: CreateConversationOptions): Promise<Conversation>;

package/dist/types/conversations/orchestration/orchestrator/generation/generation.d.ts

@@ -16,6 +16,16 @@ export interface GenerationRequest {
     maxToolIterations: number;
     /** False once the run is stale (interrupt/stop); aborts the loop. */
     isCurrent(): boolean;
+    /**
+     * Whether outgoing messages keep per-agent `name` fields on system and
+     * assistant messages. Multi-agent conversations need them so the model can
+     * tell which agent said what in the shared history. Single-agent
+     * conversations drop them: with one agent the names carry no information,
+     * and some providers render a message `name` as a role header ("Scout:")
+     * that weaker models imitate — every reply then starts by speaking the
+     * agent's name. Default true.
+     */
+    agentNames?: boolean;
     /** Streamed text; `textBefore` is the running text prior to this delta. */
     onDelta?(delta: string, textBefore: string): void;
     /** Hand tool calls to the application and resolve their results. */
@@ -28,6 +38,13 @@ export interface GenerationOutcome {
     status: GenerationStatus;
     /** The provider error, when `status` is "error". */
     error?: unknown;
+    /**
+     * How many tool rounds were resolved before the run ended (only present
+     * when at least one). Lets callers retry a no-output failure safely:
+     * re-running a generation whose tools already executed would repeat their
+     * side effects.
+     */
+    toolRounds?: number;
 }
 /**
  * Owns the LLM tool loop shared by top-level generations and delegated

package/dist/types/conversations/orchestration/orchestrator/orchestrator.d.ts

@@ -24,10 +24,19 @@ export interface OrchestratorOptions {
     tts?: TTS;
     /** Used to rehydrate conversation history on start. */
     persistence?: Persistence;
-    /** How long to wait for the application to resolve a tool call. */
+    /** How long to wait for a tool call to resolve (auto-executed or app-managed). */
     toolTimeoutMs?: number;
     /** Safety bound on tool-call round trips per generation. */
     maxToolIterations?: number;
+    /**
+     * Execute the agents' tools automatically (default `true`), feeding each
+     * tool's result — or a caught error — back into the model loop, like
+     * `Agent.run()` does. Set `false` for the application-managed contract:
+     * listen for `tool-call` events and resolve each call yourself with
+     * `conversation.resolveToolCall()`. The `tool-call` event fires in both
+     * modes, so apps can observe every call.
+     */
+    autoExecuteTools?: boolean;
     /**
      * Additional coordinations the runtime can delegate to, registered by
      * name (the key is the coordination's name).
@@ -38,12 +47,20 @@ export interface OrchestratorOptions {
     temperature?: number;
     maxTokens?: number;
     /**
-     * Bounds how much conversation history each LLM request carries (default
+     * How much conversation history each LLM request carries (default
      * `{ maxTurns: 5, maxChars: 4000 }` — provider TTFT grows with input size,
      * and a bounded window keeps requests in the fast regime). Pass `false` to
      * always send the full history.
      */
     historyWindow?: HistoryWindow | false;
+    /**
+     * How many TTS synthesis requests may be in flight at once (default 2).
+     * More lets the sentences of a multi-sentence reply synthesize in parallel
+     * (kills the gaps between them) at the cost of provider concurrency — some
+     * free TTS variants rate-limit concurrent requests. Passed through to the
+     * speech pipeline; see `SpeechPipelineOptions.maxConcurrentRequests`.
+     */
+    maxConcurrentTtsRequests?: number;
 }
 /**
  * The realtime conversation state machine and multi-agent coordinator.
@@ -56,13 +73,15 @@ export interface OrchestratorOptions {
  * ```text
  * audio-in ──► STT ──► turn ──► coordinator ──► agent ──► LLM ──► TTS ──► audio-out
  *                                    │
- *                                    └─► tool-call ──► app resolves ──► resume
+ *                                    └─► tool-call ──► tool runs ──► resume
  * ```
  *
  * Deltas stream to TTS immediately (so the agent can narrate while a tool
- * runs), tool calls pause the generation until the application resolves
- * them, and interruptions cancel the current generation — discarding any
- * stale tool results or audio via a generation epoch.
+ * runs), tool calls pause the generation while the tool executes — the
+ * framework runs the agent's own tools by default, or the application
+ * resolves them when `autoExecuteTools` is off — and interruptions cancel
+ * the current generation, discarding any stale tool results or audio via a
+ * generation epoch.
  */
 export declare class Orchestrator {
     private readonly conversation;

package/dist/types/conversations/orchestration/orchestrator/speech/speech.d.ts

@@ -10,6 +10,14 @@ export interface SpeechPipelineOptions {
      * bump) or a stop drops queued and in-flight synthesis.
      */
     isCurrent(epoch: number): boolean;
+    /**
+     * How many synthesis requests may be in flight at once. Sentences are
+     * started as soon as a slot is free — the next one synthesizes while the
+     * current one is still streaming — so playback never waits for the whole
+     * reply, but a burst of many sentences can't flood the provider (free TTS
+     * variants rate-limit concurrent requests). Default 2.
+     */
+    maxConcurrentRequests?: number;
 }
 /**
  * Turns the LLM delta stream into speakable audio: expose the text stream
@@ -24,10 +32,15 @@ export declare class SpeechPipeline {
     private readonly tts;
     private readonly conversation;
     private readonly isCurrent;
+    private readonly maxConcurrent;
     private readonly chunker;
     private speechEpoch;
     private chain;
     private audioSequence;
+    /** Flushed sentences still waiting for a synthesis slot. */
+    private readonly queue;
+    /** Synthesis requests started but not yet fully delivered. */
+    private inFlight;
     constructor(options: SpeechPipelineOptions);
     /**
      * Stream an LLM delta to the application and the TTS pipeline. Empty
@@ -37,13 +50,29 @@ export declare class SpeechPipeline {
     feed(delta: string, epoch: number): void;
     /** Speak any remaining buffered text as a final chunk. */
     flush(epoch: number): void;
-    /** Synthesize a sentence and push the audio chunks out to the app. */
+    /**
+     * Queue a sentence for synthesis, starting it if a slot is free. The text
+     * order is preserved end to end: requests start in flush order, and delivery
+     * below is serialized through `chain`, so sentence N never overtakes N-1.
+     */
     speak(sentence: string, epoch: number): void;
+    /**
+     * Start synthesis for queued sentences up to the concurrency bound. A
+     * sentence's request is fired as soon as a slot is free — while the previous
+     * sentence is still streaming/playing — so the first piece is ready first
+     * and later pieces overlap it, without ever flooding the provider with one
+     * request per sentence of a long reply.
+     */
+    private startNext;
     /**
      * Stop the current TTS playback and drop buffered text without cancelling
      * the generation (barge-in, interrupt, stop).
      */
     stop(): void;
-    /** Resolve when queued TTS synthesis has settled. */
+    /**
+     * Resolve when every queued and in-flight sentence has been synthesized and
+     * delivered. Unlike the delivery chain alone, this also waits for sentences
+     * still waiting on a synthesis slot.
+     */
     waitForIdle(): Promise<void>;
 }