@iloveagents/foundry-web-voice 0.1.0

package/dist/adapter/speech-queue.js

@@ -0,0 +1,344 @@
+/**
+ * Turning a streaming markdown answer into spoken audio.
+ *
+ * Three separate problems, kept separate:
+ *
+ * 1. **What to say.** The agent writes markdown for a reader. Read aloud
+ *    verbatim it becomes "asterisk asterisk important asterisk asterisk",
+ *    and foundry's `[1]` citation markers become "bracket one". `toSpeakableText`
+ *    strips the notation and keeps the prose.
+ *
+ * 2. **When to say it.** Waiting for the whole answer wastes the seconds the
+ *    agent spends writing it. `SentenceStream` takes cumulative text and
+ *    hands back complete sentences as they finish, so speech starts on the
+ *    first full sentence.
+ *
+ * 3. **One at a time.** Voice Live rejects overlapping responses. The SDK's
+ *    own `ResponseGate` serializes them, but it deliberately collapses
+ *    everything queued during one response into a *single* follow-up — the
+ *    right behaviour for turns, fatal for a sentence queue, where
+ *    collapsing three pending sentences into one would drop two of them.
+ *    `SpeechQueue` therefore keeps its own FIFO and releases the next
+ *    utterance only once the previous response is done.
+ */
+/** Longest run of text spoken without a sentence end, before flushing at a word boundary. */
+const MAX_UTTERANCE_CHARS = 240;
+/**
+ * Shortest utterance worth sending on its own.
+ *
+ * Every utterance is a separate synthesis: the player's queue drains to
+ * empty between them, and the seam is audible as a click — with an avatar,
+ * a visible restart too. Speaking each sentence the instant it lands turns a
+ * four-sentence answer into four seams. Complete sentences are therefore
+ * grouped until they are worth the seam, which still starts the audio well
+ * before the answer has finished streaming.
+ */
+const MIN_UTTERANCE_CHARS = 140;
+/** A sentence end: `.`, `!`, `?`, `…` (optionally closed by a quote/bracket) then whitespace. */
+const SENTENCE_END = /([.!?…]["'”’)\]]*)(\s+)/;
+const FENCED_CODE = /```[\s\S]*?(?:```|$)/g;
+const IMAGE = /!\[([^\]]*)\]\([^)]*\)/g;
+const LINK = /\[([^\]]*)\]\([^)]*\)/g;
+/**
+ * foundry citation markers — `[1]`, `[12]`, `[1, 3]` — are for the eye only.
+ * The leading space goes with them: "net 30 [3]." must not be read as
+ * "net 30 <pause> ." once the marker is gone.
+ */
+const CITATION = /[ \t]*\[\d+(?:\s*,\s*\d+)*\]/g;
+/**
+ * A bracketed run at the very end of the text — "[", "[2", "[2, 3", "[label]".
+ *
+ * The closing "]" is optional on purpose. A finished "[label]" sitting at the
+ * end is not finished at all if the next character turns out to be "(", which
+ * makes it a link and reduces it to "label" — four characters shorter. Waiting
+ * for the next delta costs nothing, and speaking early costs a re-read.
+ *
+ * Anything still missing its "]" is unfinished by definition, since nothing
+ * has arrived after it yet. Dropping it keeps normalisation MONOTONIC: a
+ * half-arrived citation and the complete one reduce to the same text, so the
+ * closing bracket changes nothing. Were only the complete form stripped, the
+ * speakable text would SHORTEN as the raw answer grew, and any span already
+ * voiced across it would have to be read a second time.
+ *
+ * Text that later turns out not to be a citation — "[note]", a markdown link —
+ * simply reappears once it closes. Growth is harmless; only shrinkage forces
+ * a rewind.
+ */
+const UNCLOSED_BRACKET = /[ \t]*\[[^\]]*\]?\s*$/;
+/**
+ * A markdown link whose target is still arriving: "[label](http://ex" .
+ *
+ * The bracket is closed, so `UNCLOSED_BRACKET` does not apply, and `LINK`
+ * needs the ")" before it can reduce the whole thing to its label — so in
+ * between, the raw target leaks into the speakable text and then vanishes.
+ * That is a shrink, and a shrink after the span has been voiced is a re-read.
+ * Reduced to the label immediately instead, which is what it will become.
+ *
+ * The leading `!` is part of the match because an image is the same shape:
+ * `IMAGE` reduces the finished `![alt](url)` to `alt`, so an incomplete one
+ * that kept its `!` would shrink by that one character when the `)` landed.
+ * One character is enough — the rewind is by utterance, not by character.
+ */
+const UNCLOSED_LINK = /!?\[([^\]]*)\]\([^)]*$/;
+/** Matches nothing, so a rule can be switched off without branching the chain. */
+const NOTHING = /(?!)/;
+/**
+ * A bracketed run at the end of a SETTLED answer: keep the words, lose the
+ * brackets. Replaced with a LEADING SPACE, because the bracket may be doing
+ * the work of a separator — "array[index]" spoken as "arrayindex" is worse
+ * than the delimiters it was meant to remove. The whitespace collapse and
+ * `trim()` further down tidy up the doubled or leading space.
+ */
+const TRAILING_BRACKETED = /\[([^\]]*)\]?\s*$/;
+const HEADING = /^\s{0,3}#{1,6}\s+/gm;
+const BLOCKQUOTE = /^\s{0,3}>\s?/gm;
+const LIST_BULLET = /^\s{0,3}([-*+]|\d+[.)])\s+/gm;
+const RULE = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/gm;
+const EMPHASIS = /(\*\*|__|\*|_|~~)/g;
+const INLINE_CODE = /`([^`]*)`/g;
+const TABLE_PIPES = /^\s*\|(.+)\|\s*$/gm;
+const TABLE_DIVIDER = /^\s*\|?[\s:|-]{3,}\|?\s*$/gm;
+/**
+ * Markdown → text a voice can read.
+ *
+ * Deliberately lossy: code blocks and table rules are dropped rather than
+ * spelled out, because hearing punctuation read aloud is worse than not
+ * hearing it at all. What survives is the prose.
+ */
+export function toSpeakableText(markdown, options = {}) {
+    // `final` means the answer has settled, so nothing can arrive to change what
+    // a trailing bracket turns out to be. Holding it back THEN does not defer
+    // speech, it drops it: "…and then choose [yes/no]" was spoken without the
+    // options, because `flush()` only ever sees this already-shortened text.
+    const settled = options.final === true;
+    return (markdown
+        .replace(FENCED_CODE, " ")
+        .replace(IMAGE, "$1")
+        .replace(LINK, "$1")
+        .replace(CITATION, "")
+        .replace(TABLE_DIVIDER, " ")
+        .replace(TABLE_PIPES, "$1")
+        .replace(RULE, " ")
+        .replace(HEADING, "")
+        .replace(BLOCKQUOTE, "")
+        .replace(LIST_BULLET, "")
+        .replace(INLINE_CODE, "$1")
+        // Whatever backtick is left is unmatched — an inline-code span whose
+        // closing tick has not arrived. Dropping it now means the arrival of that
+        // tick changes nothing, which is the same monotonicity argument as above.
+        .replace(/`/g, "")
+        .replace(EMPHASIS, "")
+        .replace(UNCLOSED_LINK, "$1")
+        .replace(settled ? NOTHING : UNCLOSED_BRACKET, "")
+        // Settled: keep the words, drop the delimiters. A voice reads "[yes/no]"
+        // as "open bracket yes slash no close bracket", which is the reason
+        // citations are stripped in the first place.
+        .replace(settled ? TRAILING_BRACKETED : NOTHING, " $1")
+        .replace(/[ \t]+/g, " ")
+        .replace(/\s*\n\s*/g, "\n")
+        .trim());
+}
+/**
+ * Cuts cumulative streaming text into speakable utterances.
+ *
+ * Fed the *whole* answer so far on each call (which is what assistant-ui
+ * exposes — parts carry cumulative text, not deltas) and returns only what
+ * has not been emitted yet.
+ */
+export class SentenceStream {
+    constructor() {
+        /** How much of the answer has been turned into emitted utterances. */
+        this.consumed = 0;
+        /** Exactly that prefix, kept so a rewrite of it can be detected. */
+        this.consumedText = "";
+        /**
+         * Every position an utterance has ended at, 0 first.
+         *
+         * A rewrite inside already-spoken text can only be repaired at one of these.
+         * Rewinding to the raw point of divergence resumes mid-word — "…ly different
+         * answer" — because the divergence lands wherever the two strings happen to
+         * part, which is usually inside a word.
+         */
+        this.boundaries = [0];
+        /** The last cumulative answer seen, kept so `flush()` can finish it. */
+        this.text = "";
+    }
+    /**
+     * @param cumulative the full answer so far, already run through `toSpeakableText`
+     * @returns complete utterances that became available with this update
+     */
+    push(cumulative) {
+        this.text = cumulative;
+        // If the region already spoken has itself changed, rewind to where it
+        // stopped matching — no further. A wholesale replacement diverges at the
+        // start and rewinds to zero; a small edit re-speaks only from the edit.
+        let same = 0;
+        const limit = Math.min(this.consumedText.length, cumulative.length);
+        while (same < limit && this.consumedText[same] === cumulative[same])
+            same++;
+        if (same < this.consumed) {
+            // Back to the last utterance that ended at or before the divergence, so
+            // speech resumes on a seam the listener already heard end. A wholesale
+            // replacement parts company almost immediately and finds only 0, which
+            // is the whole answer again — correct, since none of it still stands.
+            let at = 0;
+            for (const b of this.boundaries)
+                if (b <= same)
+                    at = b;
+            this.boundaries = this.boundaries.filter((b) => b <= at);
+            this.advanceTo(cumulative, at);
+        }
+        return this.take(segment(cumulative.slice(this.consumed), false), cumulative);
+    }
+    /** Emit whatever is left, complete sentence or not. Call when the answer ends. */
+    flush() {
+        return this.take(segment(this.text.slice(this.consumed), true), this.text);
+    }
+    reset() {
+        this.consumed = 0;
+        this.consumedText = "";
+        this.text = "";
+        this.boundaries = [0];
+    }
+    take({ utterances, ends }, source) {
+        if (ends.length === 0)
+            return utterances;
+        const base = this.consumed;
+        for (const end of ends)
+            this.boundaries.push(base + end);
+        this.advanceTo(source, base + ends[ends.length - 1]);
+        return utterances;
+    }
+    advanceTo(source, position) {
+        this.consumed = position;
+        this.consumedText = source.slice(0, position);
+    }
+}
+/**
+ * Split the UNSPOKEN remainder of an answer into utterances, reporting how
+ * much of it was used.
+ *
+ * The reporting is the point. An earlier version re-segmented the whole answer
+ * on every update and diffed the resulting lists, on the assumption that
+ * segmentation is prefix-stable. It is not, and a property test over 3,000
+ * randomised answers put the failure rate at roughly two in three for long
+ * unpunctuated text. The `MAX_UTTERANCE_CHARS` cut below is a *speculative*
+ * decision: it fires only because no sentence end is in sight yet. When the
+ * period finally arrives, that same span re-segments as one long sentence
+ * instead of the chunk that was already spoken, every later utterance shifts,
+ * and the whole answer is said again.
+ *
+ * So nothing already spoken is ever reconsidered. The caller advances a
+ * watermark by `consumed` and passes only what lies beyond it, which makes a
+ * speculative cut permanent the moment it is voiced — as it must be, the audio
+ * having already left.
+ *
+ * `final` means nothing more is coming, so the trailing fragment joins the last
+ * group rather than becoming an utterance of its own.
+ */
+function segment(text, final) {
+    const utterances = [];
+    const ends = [];
+    let pos = 0;
+    // Complete sentences waiting to be grouped into one utterance.
+    let group = "";
+    const flushGroup = (end) => {
+        if (!group)
+            return;
+        utterances.push(group);
+        group = "";
+        ends.push(end);
+    };
+    for (;;) {
+        const rest = text.slice(pos);
+        const match = SENTENCE_END.exec(rest);
+        if (match) {
+            const end = match.index + match[1].length;
+            const utterance = rest.slice(0, end).trim();
+            const next = pos + end + match[2].length;
+            if (utterance) {
+                group = group ? `${group} ${utterance}` : utterance;
+                if (group.length >= MIN_UTTERANCE_CHARS)
+                    flushGroup(next);
+            }
+            pos = next;
+            continue;
+        }
+        // No sentence end in sight. Once the remainder is long enough that waiting
+        // would be a noticeable silence, cut at the last word boundary — a long
+        // bulleted answer can run for a paragraph without a single period.
+        if (!final && text.length - pos > MAX_UTTERANCE_CHARS) {
+            const cut = text.lastIndexOf(" ", pos + MAX_UTTERANCE_CHARS);
+            if (cut <= pos)
+                break;
+            const utterance = text.slice(pos, cut).trim();
+            if (utterance) {
+                group = group ? `${group} ${utterance}` : utterance;
+                flushGroup(cut + 1);
+            }
+            pos = cut + 1;
+            continue;
+        }
+        break;
+    }
+    if (final) {
+        const tail = text.slice(pos).trim();
+        if (tail)
+            group = group ? `${group} ${tail}` : tail;
+        flushGroup(text.length);
+    }
+    return { utterances, ends };
+}
+/**
+ * A strict FIFO of utterances, one on the wire at a time.
+ *
+ * `send` puts one utterance on the wire. `onResponseDone` must be called
+ * when the service reports that response finished — that is the only thing
+ * that releases the next one.
+ */
+export class SpeechQueue {
+    constructor(send) {
+        this.send = send;
+        this.pending = [];
+        this.speaking = false;
+    }
+    get isSpeaking() {
+        return this.speaking;
+    }
+    get pendingCount() {
+        return this.pending.length;
+    }
+    enqueue(text) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        this.pending.push(trimmed);
+        this.pump();
+    }
+    /** The in-flight response finished; release the next utterance. */
+    onResponseDone() {
+        this.speaking = false;
+        this.pump();
+    }
+    /**
+     * Barge-in or a new turn: forget everything still queued.
+     *
+     * `speaking` is cleared too. The caller cancels the in-flight response on
+     * the wire, and a cancelled response may never produce the `response.done`
+     * that would otherwise release the queue — leaving it wedged shut for the
+     * rest of the session.
+     */
+    cancel() {
+        this.pending.length = 0;
+        this.speaking = false;
+    }
+    pump() {
+        if (this.speaking)
+            return;
+        const next = this.pending.shift();
+        if (next === undefined)
+            return;
+        this.speaking = true;
+        this.send(next);
+    }
+}

package/dist/adapter/tool-bridge.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Client-side tools, callable by voice.
+ *
+ * The tools the typed chat can call (`ui_navigate`, `ui_open_panel`, the
+ * page-scoped `page_*` set) live in `clientToolRegistry`. In `realtime` mode
+ * the Voice Live model is the one deciding to call them, so it needs both
+ * the schemas (see `session-config.ts`) and an executor.
+ *
+ * The SDK owns the wire half: an executor that returns a value has it sent
+ * as the `function_call_output` for that `call_id`, and a follow-up response
+ * triggered — serialized against any response already running. So all that
+ * is left here is dispatch, with the *same* failure semantics as
+ * `AGUIRunner`'s tool interception, so a tool that misbehaves reports
+ * identically whether it was called by voice or by typing.
+ */
+import type { ToolRegistry } from "@iloveagents/foundry-agent";
+import type { ToolExecutor } from "@iloveagents/foundry-voice-live-react";
+/**
+ * A `ToolExecutor` that dispatches into the client tool registry.
+ *
+ * Always resolves to a JSON string, never rejects: an unanswered function
+ * call makes the model re-issue the tool and then report that it did not
+ * complete, so an error result is strictly better than no result.
+ */
+export declare function createRegistryToolExecutor(registry: ToolRegistry): ToolExecutor;

package/dist/adapter/tool-bridge.js

@@ -0,0 +1,37 @@
+/**
+ * Client-side tools, callable by voice.
+ *
+ * The tools the typed chat can call (`ui_navigate`, `ui_open_panel`, the
+ * page-scoped `page_*` set) live in `clientToolRegistry`. In `realtime` mode
+ * the Voice Live model is the one deciding to call them, so it needs both
+ * the schemas (see `session-config.ts`) and an executor.
+ *
+ * The SDK owns the wire half: an executor that returns a value has it sent
+ * as the `function_call_output` for that `call_id`, and a follow-up response
+ * triggered — serialized against any response already running. So all that
+ * is left here is dispatch, with the *same* failure semantics as
+ * `AGUIRunner`'s tool interception, so a tool that misbehaves reports
+ * identically whether it was called by voice or by typing.
+ */
+/**
+ * A `ToolExecutor` that dispatches into the client tool registry.
+ *
+ * Always resolves to a JSON string, never rejects: an unanswered function
+ * call makes the model re-issue the tool and then report that it did not
+ * complete, so an error result is strictly better than no result.
+ */
+export function createRegistryToolExecutor(registry) {
+    return async (name, args) => {
+        if (!registry.isRegistered(name)) {
+            return JSON.stringify({ error: `Unknown client tool: ${name}` });
+        }
+        try {
+            return await registry.executeTool(name, args);
+        }
+        catch (err) {
+            return JSON.stringify({
+                error: err instanceof Error ? err.message : "Client-side tool failed",
+            });
+        }
+    };
+}

package/dist/adapter/tool-sync.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Keeps the live session's tool catalogue in step with the page's.
+ *
+ * Two things this has to get right, and an inline callback got both wrong:
+ *
+ * - **Nothing may be dropped while the session is still connecting.** Page
+ *   tools are registered and cleared on navigation, so the catalogue can
+ *   change between mount and `session.created`. A callback that returns
+ *   early when the session is not ready loses that change permanently —
+ *   nothing replays it — and the model is left unable to act on the page
+ *   the user is looking at, or calling a tool that no longer exists. The
+ *   fix is not inside this class: the caller must `sync()` again the moment
+ *   the session becomes ready, which the dedupe below makes free.
+ *
+ * - **Not every registry notification is a tool change.** `clientToolRegistry`
+ *   is a zustand store, so subscribers fire on *any* state write. Sending a
+ *   `session.update` for each one is pointless traffic on a live socket.
+ *   Comparing the serialized catalogue collapses those to nothing.
+ */
+import type { ToolRegistry } from "@iloveagents/foundry-agent";
+import type { Tool } from "@iloveagents/foundry-voice-live-react";
+export declare class ToolSync {
+    private readonly send;
+    /** Serialized catalogue last put on the wire, or null if none has been. */
+    private lastSent;
+    constructor(send: (tools: Tool[]) => void);
+    /**
+     * Push the session's current catalogue, unless it is already on the wire.
+     *
+     * `hostTools` is not optional decoration: `session.update` replaces the
+     * catalogue outright, so sending the registry's tools alone withdraws every
+     * MCP server and Foundry agent tool the host configured, and any host
+     * override of a registry tool. It has to be the same merge the session was
+     * built with, which is why both go through `sessionTools`.
+     */
+    sync(registry: ToolRegistry, hostTools: Tool[] | undefined): void;
+    /**
+     * Forget what was sent.
+     *
+     * A new session starts with whatever catalogue its own `session.update`
+     * carried, but this object cannot know that — so after a disconnect it
+     * must assume nothing, or the first sync of the next session is skipped
+     * as a duplicate and that session runs with a catalogue nobody sent.
+     */
+    reset(): void;
+}

package/dist/adapter/tool-sync.js

@@ -0,0 +1,55 @@
+/**
+ * Keeps the live session's tool catalogue in step with the page's.
+ *
+ * Two things this has to get right, and an inline callback got both wrong:
+ *
+ * - **Nothing may be dropped while the session is still connecting.** Page
+ *   tools are registered and cleared on navigation, so the catalogue can
+ *   change between mount and `session.created`. A callback that returns
+ *   early when the session is not ready loses that change permanently —
+ *   nothing replays it — and the model is left unable to act on the page
+ *   the user is looking at, or calling a tool that no longer exists. The
+ *   fix is not inside this class: the caller must `sync()` again the moment
+ *   the session becomes ready, which the dedupe below makes free.
+ *
+ * - **Not every registry notification is a tool change.** `clientToolRegistry`
+ *   is a zustand store, so subscribers fire on *any* state write. Sending a
+ *   `session.update` for each one is pointless traffic on a live socket.
+ *   Comparing the serialized catalogue collapses those to nothing.
+ */
+import { sessionTools } from "./session-config.js";
+export class ToolSync {
+    constructor(send) {
+        this.send = send;
+        /** Serialized catalogue last put on the wire, or null if none has been. */
+        this.lastSent = null;
+    }
+    /**
+     * Push the session's current catalogue, unless it is already on the wire.
+     *
+     * `hostTools` is not optional decoration: `session.update` replaces the
+     * catalogue outright, so sending the registry's tools alone withdraws every
+     * MCP server and Foundry agent tool the host configured, and any host
+     * override of a registry tool. It has to be the same merge the session was
+     * built with, which is why both go through `sessionTools`.
+     */
+    sync(registry, hostTools) {
+        const tools = sessionTools(registry, hostTools) ?? [];
+        const key = JSON.stringify(tools);
+        if (key === this.lastSent)
+            return;
+        this.lastSent = key;
+        this.send(tools);
+    }
+    /**
+     * Forget what was sent.
+     *
+     * A new session starts with whatever catalogue its own `session.update`
+     * carried, but this object cannot know that — so after a disconnect it
+     * must assume nothing, or the first sync of the next session is skipped
+     * as a duplicate and that session runs with a catalogue nobody sent.
+     */
+    reset() {
+        this.lastSent = null;
+    }
+}

package/dist/adapter/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Public configuration for the voice tier.
+ *
+ * Connection and session shapes are re-used from the Voice Live SDK rather
+ * than re-declared, so there is exactly one source of truth for what Azure
+ * accepts and a new SDK field needs no change here.
+ */
+import type { ChromaKeyConfig, LogLevel, ReconnectOptions, VoiceLiveConnectionConfig, VoiceLiveSessionConfig } from "@iloveagents/foundry-voice-live-react";
+/**
+ * Who answers a spoken question.
+ *
+ * - ``relay`` (default) — Voice Live is ears and mouth only. The final
+ *   transcript is submitted to the composer, so the app's own AG-UI agent
+ *   answers with its full tool/retrieval surface, and the answer is spoken
+ *   back. Turns are ordinary thread turns: they render with tool cards and
+ *   citations, and they persist through whatever history adapter the host
+ *   configured.
+ *
+ * - ``realtime`` — the Voice Live model answers directly. Sub-second, and
+ *   it can call the app's client-side tools, but it only knows what those
+ *   tools tell it. Its turns are live-session-scoped: assistant-ui merges
+ *   them into the thread while connected and drops them on disconnect
+ *   (`BaseThreadRuntimeCore.disconnectVoice` clears `_voiceMessages`), so
+ *   they never reach a history adapter. Use `onTranscript` to persist them
+ *   yourself if you need to.
+ */
+export type VoiceMode = "relay" | "realtime";
+/** A transcript line as it arrives; `text` is cumulative for a given turn. */
+export interface VoiceTranscript {
+    role: "user" | "assistant";
+    text: string;
+    isFinal: boolean;
+}
+export interface VoiceConfig {
+    /** @default "relay" */
+    mode?: VoiceMode;
+    /**
+     * How to reach Voice Live. In production this is `{ proxyUrl }`: a
+     * browser cannot set an `Authorization` header on a WebSocket, so the
+     * credential belongs in a proxy, never in the bundle.
+     */
+    connection: VoiceLiveConnectionConfig;
+    /**
+     * Session options — voice, avatar, instructions, VAD tuning. Merged over
+     * the defaults this package derives from `mode`; anything you set here
+     * wins, including the fields the mode would otherwise choose.
+     */
+    session?: VoiceLiveSessionConfig;
+    /**
+     * Expose the app's client-side tools (`ui_*`, `page_*`) to the voice
+     * model. `realtime` only — in `relay` mode the AG-UI agent owns tools and
+     * this is ignored.
+     * @default true
+     */
+    exposeClientTools?: boolean;
+    /**
+     * Mute the microphone while the assistant is speaking.
+     *
+     * On a laptop's speakers the assistant hears itself: its own voice trips
+     * the service's VAD, which commits a turn, which produces another reply —
+     * a conversation the user is no longer part of. Server echo cancellation
+     * removes most of it, not all, and an avatar's audio arrives over WebRTC
+     * where it helps least.
+     *
+     * The cost is barge-in: a muted microphone cannot interrupt. Leave it off
+     * when users wear headsets; turn it on for demos and speakerphone rooms.
+     *
+     * @default false
+     */
+    halfDuplex?: boolean;
+    /**
+     * Chroma-key tuning for the avatar's green-screen removal.
+     *
+     * The default is slightly softer-edged than the SDK's, because the stock
+     * values left a visible green fringe on the avatar's outline against
+     * light and dark surfaces alike. Raise `similarity` if green spill
+     * remains; lower it if the avatar's own dark clothing starts to key out.
+     */
+    chromaKey?: ChromaKeyConfig;
+    /** Console verbosity of the underlying SDK. @default "warn" */
+    logLevel?: LogLevel;
+    /** Auto-reconnect after an unexpected control-channel close. @default false */
+    reconnect?: boolean | Partial<ReconnectOptions>;
+    /**
+     * Every transcript line, both roles. The hook into persistence for
+     * `realtime` turns, which assistant-ui deliberately keeps ephemeral.
+     */
+    onTranscript?: (transcript: VoiceTranscript) => void;
+    /** Session-fatal errors, already surfaced to the runtime as an ended session. */
+    onError?: (message: string) => void;
+}

package/dist/adapter/types.js

@@ -0,0 +1,8 @@
+/**
+ * Public configuration for the voice tier.
+ *
+ * Connection and session shapes are re-used from the Voice Live SDK rather
+ * than re-declared, so there is exactly one source of truth for what Azure
+ * accepts and a new SDK field needs no change here.
+ */
+export {};