@moureau/pipeflow 0.0.1 → 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

@@ -1,12 +1,45 @@
 import type { Agent } from "../../agents/agent.js";
 import type { Persistence } from "../../persistence/persistence.js";
+import type { STT } from "../../providers/stt/types.js";
+import type { TTS } from "../../providers/tts/types.js";
 import type { AudioChunk, ConversationId, ConversationState, ConversationStatus, Generation, Participant, ParticipantInput, Turn, UserId } from "../types.js";
 import { Transcription, type TranscriptEntry, type TranscriptEntryInput } from "../transcription/transcription.js";
 import type { ToolCall, ToolCallResult } from "../types.js";
+/** Timing points a generation can record, keyed by the stream event. */
+type TimingPoint = "firstToken" | "firstTtsText" | "firstTtsRequest" | "firstTtsAudio";
 export interface ConversationOptions {
     id: ConversationId;
     agents?: Agent[];
     persistence?: Persistence;
+    /**
+     * STT provider used to attach realtime processing automatically on
+     * `start()`.
+     */
+    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: {
@@ -25,6 +58,12 @@ export interface ConversationEvents {
         userId: UserId;
         audio: AudioChunk;
     };
+    /** A finalized text turn via `send()`. Consumed by the orchestrator. */
+    "text-in": {
+        conversationId: ConversationId;
+        userId: UserId;
+        text: string;
+    };
     /** Generated audio to be played by the application. */
     audio: {
         conversationId: ConversationId;
@@ -42,6 +81,20 @@ export interface ConversationEvents {
         conversationId: ConversationId;
         generation: Generation;
     };
+    /**
+     * The current generation's text, streamed as LLM deltas arrive. Emitted by
+     * the orchestrator; the agent name is included when the generation is known.
+     */
+    "text-delta": {
+        conversationId: ConversationId;
+        text: string;
+        agentName?: string;
+    };
+    /** The current (top-level) generation finished generating. */
+    "generation-complete": {
+        conversationId: ConversationId;
+        generation: Generation;
+    };
     /** Live STT partials, for captions and fast UX. Not persisted. */
     "partial-transcript": {
         conversationId: ConversationId;
@@ -75,10 +128,11 @@ export interface ConversationEvents {
  * The public realtime conversation API.
  *
  * A `Conversation` is a runtime handle to a persistent conversation:
- * lifecycle (`start`/`stop`), participants, audio intake (`listen`), and
- * events. The orchestrator (added later) subscribes to `audio-in` and
- * pushes generated audio, turns, transcripts, and tool calls back through
- * the `push*`/`requestToolCall` methods.
+ * lifecycle (`start`/`stop`), participants, audio intake (`listen`), text
+ * turns (`send`), and events. When an STT provider or agents are configured,
+ * `start()` automatically attaches the orchestrator, which runs the
+ * STT/LLM/TTS pipeline (or routes text turns) and pushes generated audio,
+ * turns, transcripts, and tool calls back through conversation events.
  */
 export declare class Conversation {
     readonly id: ConversationId;
@@ -86,24 +140,69 @@ export declare class Conversation {
     readonly transcription: Transcription;
     readonly state: ConversationState;
     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;
     get participants(): Participant[];
-    start(): void;
+    /**
+     * Move the conversation into the started state. This attaches the
+     * orchestrator whenever there is realtime work: an STT provider (voice
+     * pipeline) or agents to route text turns to (`send()`).
+     */
+    start(): Promise<void>;
     stop(): Promise<void>;
     participate(input: ParticipantInput | ParticipantInput[]): Promise<Participant[]>;
     /**
      * 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) —
+     * useful for text-first integrations such as chat or Discord text channels.
+     */
+    send(input: {
+        userId: UserId;
+        text: string;
     }): void;
-    /** Interrupt the current agent output (stop TTS, cancel the generation). */
+    /**
+     * Stop the currently active generation and prevent any further generated
+     * audio from reaching the conversation. The orchestrator cancels the LLM
+     * and TTS streams, force-resolves pending tool calls, and discards queued
+     * audio; the next participant turn starts fresh. Interrupt responsiveness
+     * is a tested invariant — audio stops within ~100ms of this call.
+     */
     interrupt(): void;
     on<K extends keyof ConversationEvents>(event: K, listener: (payload: ConversationEvents[K]) => void): () => void;
     /**
@@ -117,8 +216,20 @@ export declare class Conversation {
     pushTurn(turn: Turn): Promise<void>;
     /** Append a transcript entry and notify listeners. */
     pushTranscript(input: Omit<TranscriptEntryInput, "conversationId">): Promise<TranscriptEntry>;
+    /**
+     * Stream the current generation's text, as produced by the orchestrator
+     * from LLM deltas. Emits the `text-delta` event so applications can render
+     * or act on partial replies.
+     */
+    pushTextDelta(text: string): void;
     /** Push an agent generation into the conversation. */
     pushGeneration(generation: Generation): Promise<void>;
+    /**
+     * Record a timing point on a generation. Without an id this targets the
+     * current generation; with one, a dispatched sub-generation. Each point is
+     * recorded at most once.
+     */
+    noteTiming(point: TimingPoint, generationId?: string): void;
     /** Tool calls requested by the model that are awaiting resolution. */
     get pendingToolCalls(): ToolCall[];
     /**
@@ -131,8 +242,21 @@ export declare class Conversation {
     resolveToolCall(result: ToolCallResult): void;
     /** Mark the current generation as completed, recording its final text. */
     completeGeneration(text?: string): Promise<void>;
+    /**
+     * Push a sub-generation: a task the coordinator dispatched to another
+     * agent. Unlike `pushGeneration`, it does not become the conversation's
+     * current generation, so parallel tasks don't clobber the coordinator's
+     * own in-flight generation.
+     */
+    pushSubGeneration(generation: Generation): Promise<void>;
+    /** Mark a dispatched sub-generation as completed with its final text. */
+    completeSubGeneration(id: string, text?: string): Promise<void>;
+    /** Mark a dispatched sub-generation as cancelled (e.g. barge-in). */
+    cancelSubGeneration(id: string): Promise<void>;
     /** The live in-memory transcript. */
     transcript(): TranscriptEntry[];
     private cancelCurrentGeneration;
+    private buildRealtime;
     private emitState;
 }
+export {};

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

@@ -1,10 +1,41 @@
 import type { Agent } from "../agents/agent.js";
 import type { Persistence } from "../persistence/persistence.js";
+import type { STT } from "../providers/stt/types.js";
+import type { TTS } from "../providers/tts/types.js";
 import type { ConversationId } from "./types.js";
 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
@@ -12,7 +43,10 @@ export interface CreateConversationOptions {
  */
 export declare class Conversations {
     private readonly persistence;
-    constructor(persistence: 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>;
     /** Retrieve the persisted transcript of a conversation. */

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

@@ -1,4 +1,4 @@
-export type { AudioChunk, ConversationId, ConversationState, ConversationStatus, Generation, GenerationStatus, Participant, ParticipantInput, ToolCall, ToolCallResult, Turn, TurnId, UserId, } from "./types.js";
+export type { AudioChunk, ConversationId, ConversationState, ConversationStatus, Generation, GenerationStatus, GenerationTiming, Participant, ParticipantInput, ToolCall, ToolCallResult, Turn, TurnId, UserId, } from "./types.js";
 export { createConversationState } from "./types.js";
 export { Conversation } from "./conversation/index.js";
 export type { ConversationEvents, ConversationOptions, } from "./conversation/index.js";
@@ -6,5 +6,6 @@ export { Conversations } from "./conversations.js";
 export type { CreateConversationOptions } from "./conversations.js";
 export { Orchestrator } from "./orchestration/orchestrator/index.js";
 export type { OrchestratorOptions } from "./orchestration/orchestrator/index.js";
+export { ConversationStream } from "./stream/index.js";
 export { Transcription, TranscriptEntry } from "./transcription/index.js";
 export type { TranscriptEntryInput, TranscriptSpeakerKind, } from "./transcription/index.js";