@agent-cards/sdk 0.23.28 → 0.24.0

package/dist/languages.d.ts

@@ -1,23 +0,0 @@
-/** A language tag as BCP 47 spells it: `en`, `es`, `pt-BR`. */
-export type Language = string;
-/** One language Agentcard speaks, as the API lists it. */
-export interface LanguageInfo {
-    /** The BCP 47 tag your calls name (`en`). */
-    tag: Language;
-    /** The language's own name for itself (`English`, `Español`). */
-    name: string;
-}
-export declare class Languages {
-    private readonly request;
-    private cached;
-    private inflight;
-    constructor(request: <T>(path: string) => Promise<T>);
-    /**
-     * The languages Agentcard speaks, read once and kept for ten minutes. `null`
-     * when the API does not serve the list (an API older than the route), in
-     * which case tags are passed through unchecked and the API judges them.
-     */
-    list(): Promise<LanguageInfo[] | null>;
-    /** Refuses a tag the API did not list (`unsupported_language`) before any call leaves; a well-formed tag passes when the API serves no list. */
-    check(tag: Language | undefined): Promise<void>;
-}

package/dist/languages.js

@@ -1,76 +0,0 @@
-/**
- * Languages are data, not types. A language is a BCP 47 tag (`en`, `es`,
- * `pt-BR`), and the list Agentcard speaks is read from the API
- * (`GET /api/v2/voice/languages`), so a language added on Agentcard's side
- * needs no release of this package. Every call that names a `lang` asks this
- * guard first and is refused with `unsupported_language` before anything is
- * sent when the tag is not on the list.
- */
-import { AgentcardError } from './voice-types.js';
-/** The list out of either wire shape: `data` on the list envelope, else `languages`; null when neither is a list. */
-function listOf(body) {
-    if (Array.isArray(body?.data))
-        return body.data;
-    if (Array.isArray(body?.languages))
-        return body.languages;
-    return null;
-}
-/** A tag's shape, before the list is consulted: a primary subtag and optional subtags, letters and digits only. */
-const TAG_SHAPE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{1,8})*$/;
-/** How long a read list is trusted before it is read again. */
-const LIST_TTL_MS = 10 * 60_000;
-export class Languages {
-    request;
-    cached = null;
-    inflight = null;
-    constructor(request) {
-        this.request = request;
-    }
-    /**
-     * The languages Agentcard speaks, read once and kept for ten minutes. `null`
-     * when the API does not serve the list (an API older than the route), in
-     * which case tags are passed through unchecked and the API judges them.
-     */
-    async list() {
-        if (this.cached && Date.now() - this.cached.at < LIST_TTL_MS)
-            return this.cached.list;
-        if (this.inflight)
-            return this.inflight;
-        this.inflight = (async () => {
-            let list;
-            try {
-                const body = await this.request('/api/v2/voice/languages');
-                const wire = listOf(body);
-                list = wire
-                    ? wire.flatMap((l) => (l && typeof l === 'object' && typeof l.tag === 'string'
-                        ? [{ tag: l.tag, name: typeof l.name === 'string' ? l.name : l.tag }]
-                        : []))
-                    : null;
-            }
-            catch (err) {
-                // An API that has no list yet answers 404; the tag then travels unchecked. Anything else is the caller's to see.
-                if (err instanceof AgentcardError && (err.status === 404 || err.code === 'not_found'))
-                    list = null;
-                else
-                    throw err;
-            }
-            this.cached = { list, at: Date.now() };
-            return list;
-        })().finally(() => { this.inflight = null; });
-        return this.inflight;
-    }
-    /** Refuses a tag the API did not list (`unsupported_language`) before any call leaves; a well-formed tag passes when the API serves no list. */
-    async check(tag) {
-        if (tag === undefined)
-            return;
-        if (typeof tag !== 'string' || !TAG_SHAPE.test(tag)) {
-            throw new AgentcardError('unsupported_language', `'${String(tag)}' is not a language tag (BCP 47: en, es, pt-BR). Refused before any call.`);
-        }
-        const list = await this.list();
-        if (list === null)
-            return;
-        if (!list.some((l) => l.tag.toLowerCase() === tag.toLowerCase())) {
-            throw new AgentcardError('unsupported_language', `Agentcard does not speak '${tag}' yet. It speaks ${list.map((l) => l.tag).join(', ') || 'no language on this API'}; read voice.languages() for the list. Refused before any call.`, undefined, { tag, languages: list.map((l) => l.tag) });
-        }
-    }
-}

package/dist/voice-pkce.d.ts

@@ -1,49 +0,0 @@
-/**
- * The grant's client half: a PKCE verifier and its S256
- * challenge (RFC 7636), and the opaque `state` the return link carries back.
- * Random bytes come from the platform's WebCrypto; SHA-256 from WebCrypto
- * where it exists (Node, browsers, workers), else from the small
- * implementation below, so the module keeps zero dependencies on a phone
- * runtime with no `crypto.subtle`. A runtime with no secure random source
- * names one through `VoiceOptions.pkce.randomBytes`; nothing here ever
- * falls back to `Math.random`.
- */
-import { type ReturnLink } from './voice-types.js';
-/** Seams for a runtime without WebCrypto (a React Native app running the demo's adapter). */
-export interface PkceCrypto {
-    /** `n` cryptographically random bytes. Default: `crypto.getRandomValues`. */
-    randomBytes?: (n: number) => Uint8Array;
-    /** SHA-256 of the bytes. Default: `crypto.subtle.digest`, else the built-in implementation. */
-    sha256?: (bytes: Uint8Array) => Promise<Uint8Array> | Uint8Array;
-}
-export declare const PKCE_UNAVAILABLE_MESSAGE = "This runtime has no crypto.getRandomValues, so the client cannot mint a PKCE verifier. Name voice: { pkce: { randomBytes } } with a secure source, or pass pkce: false to connect (the polling shape, deprecated).";
-export declare function randomBytes(n: number, seam: PkceCrypto | undefined): Uint8Array;
-export declare function sha256(bytes: Uint8Array, seam: PkceCrypto | undefined): Promise<Uint8Array>;
-/** RFC 4648 §5, no padding: what a verifier, a challenge and a state are made of. */
-export declare function base64url(bytes: Uint8Array): string;
-/** The ASCII bytes of a verifier (it is base64url, so ASCII by construction). */
-export declare function asciiBytes(s: string): Uint8Array;
-export interface PkcePair {
-    /** 43 characters of base64url (32 random bytes): within RFC 7636's 43–128. */
-    code_verifier: string;
-    /** base64url(SHA-256(code_verifier)). */
-    code_challenge: string;
-    code_challenge_method: 'S256';
-    /** 22 characters of base64url (16 random bytes), opaque. */
-    state: string;
-}
-export declare function mintPkce(seam: PkceCrypto | undefined): Promise<PkcePair>;
-/** The `code` and `state` a return link carries, read from its query alone; the scheme may be an app's own. */
-export declare function grantFromReturnLink(url: string): {
-    code: string | null;
-    state: string | null;
-};
-/**
- * A return link, read from its query alone (the scheme may be an app's own, `yourapp://connected?…`): the
- * grant's `code` and `state` (null on a link minted to poll: a reset, an action, `pkce: false`) and the
- * `voice_reset` outcome the Vault appends when the visit reset the person's voice key (`done`, `unchanged`,
- * `failed`; null when the link says nothing about a reset, and for any other word). A pure function with no
- * client behind it: the app half reads the sheet's result with it too.
- */
-export declare function readReturnLink(url: string): ReturnLink;
-export declare function sha256Pure(input: Uint8Array): Uint8Array;

package/dist/voice-pkce.js

@@ -1,147 +0,0 @@
-/**
- * The grant's client half: a PKCE verifier and its S256
- * challenge (RFC 7636), and the opaque `state` the return link carries back.
- * Random bytes come from the platform's WebCrypto; SHA-256 from WebCrypto
- * where it exists (Node, browsers, workers), else from the small
- * implementation below, so the module keeps zero dependencies on a phone
- * runtime with no `crypto.subtle`. A runtime with no secure random source
- * names one through `VoiceOptions.pkce.randomBytes`; nothing here ever
- * falls back to `Math.random`.
- */
-import { AgentcardError } from './voice-types.js';
-export const PKCE_UNAVAILABLE_MESSAGE = 'This runtime has no crypto.getRandomValues, so the client cannot mint a PKCE verifier. Name voice: { pkce: { randomBytes } } with a secure source, or pass pkce: false to connect (the polling shape, deprecated).';
-export function randomBytes(n, seam) {
-    if (seam?.randomBytes) {
-        const out = seam.randomBytes(n);
-        if (!(out instanceof Uint8Array) || out.length !== n)
-            throw new AgentcardError('pkce_unavailable', `voice.pkce.randomBytes must return ${n} bytes.`);
-        return out;
-    }
-    const c = globalThis.crypto;
-    if (!c?.getRandomValues)
-        throw new AgentcardError('pkce_unavailable', PKCE_UNAVAILABLE_MESSAGE);
-    return c.getRandomValues(new Uint8Array(n));
-}
-export async function sha256(bytes, seam) {
-    if (seam?.sha256)
-        return seam.sha256(bytes);
-    const subtle = globalThis.crypto?.subtle;
-    if (subtle?.digest)
-        return new Uint8Array(await subtle.digest('SHA-256', bytes));
-    return sha256Pure(bytes);
-}
-/** RFC 4648 §5, no padding: what a verifier, a challenge and a state are made of. */
-export function base64url(bytes) {
-    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-    let out = '';
-    for (let i = 0; i < bytes.length; i += 3) {
-        const a = bytes[i], b = bytes[i + 1], c = bytes[i + 2];
-        const n = (a << 16) | ((b ?? 0) << 8) | (c ?? 0);
-        out += alphabet[(n >>> 18) & 63] + alphabet[(n >>> 12) & 63];
-        if (b !== undefined)
-            out += alphabet[(n >>> 6) & 63];
-        if (c !== undefined)
-            out += alphabet[n & 63];
-    }
-    return out;
-}
-/** The ASCII bytes of a verifier (it is base64url, so ASCII by construction). */
-export function asciiBytes(s) {
-    const out = new Uint8Array(s.length);
-    for (let i = 0; i < s.length; i++)
-        out[i] = s.charCodeAt(i) & 0x7f;
-    return out;
-}
-export async function mintPkce(seam) {
-    const code_verifier = base64url(randomBytes(32, seam));
-    const code_challenge = base64url(await sha256(asciiBytes(code_verifier), seam));
-    const state = base64url(randomBytes(16, seam));
-    return { code_verifier, code_challenge, code_challenge_method: 'S256', state };
-}
-/** The `code` and `state` a return link carries, read from its query alone; the scheme may be an app's own. */
-export function grantFromReturnLink(url) {
-    const { code, state } = readReturnLink(url);
-    return { code, state };
-}
-/**
- * A return link, read from its query alone (the scheme may be an app's own, `yourapp://connected?…`): the
- * grant's `code` and `state` (null on a link minted to poll: a reset, an action, `pkce: false`) and the
- * `voice_reset` outcome the Vault appends when the visit reset the person's voice key (`done`, `unchanged`,
- * `failed`; null when the link says nothing about a reset, and for any other word). A pure function with no
- * client behind it: the app half reads the sheet's result with it too.
- */
-export function readReturnLink(url) {
-    const q = url.indexOf('?');
-    if (q < 0)
-        return { code: null, state: null, voice_reset: null };
-    const hash = url.indexOf('#', q);
-    const params = new URLSearchParams(url.slice(q + 1, hash < 0 ? undefined : hash));
-    const reset = params.get('voice_reset');
-    return {
-        code: params.get('code'),
-        state: params.get('state'),
-        voice_reset: reset === 'done' || reset === 'unchanged' || reset === 'failed' ? reset : null,
-    };
-}
-// ─── SHA-256, FIPS 180-4, for a runtime without crypto.subtle ───────────────
-const K = new Uint32Array([
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-]);
-export function sha256Pure(input) {
-    const bitLength = input.length * 8;
-    const padded = new Uint8Array(((input.length + 9 + 63) >> 6) << 6);
-    padded.set(input);
-    padded[input.length] = 0x80;
-    const view = new DataView(padded.buffer);
-    view.setUint32(padded.length - 8, Math.floor(bitLength / 0x100000000));
-    view.setUint32(padded.length - 4, bitLength >>> 0);
-    const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
-    const w = new Uint32Array(64);
-    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
-    for (let off = 0; off < padded.length; off += 64) {
-        for (let i = 0; i < 16; i++)
-            w[i] = view.getUint32(off + i * 4);
-        for (let i = 16; i < 64; i++) {
-            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
-            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
-            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
-        }
-        let [a, b, c, d, e, f, g, hh] = h;
-        for (let i = 0; i < 64; i++) {
-            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-            const ch = (e & f) ^ (~e & g);
-            const t1 = (hh + S1 + ch + K[i] + w[i]) >>> 0;
-            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
-            const maj = (a & b) ^ (a & c) ^ (b & c);
-            const t2 = (S0 + maj) >>> 0;
-            hh = g;
-            g = f;
-            f = e;
-            e = (d + t1) >>> 0;
-            d = c;
-            c = b;
-            b = a;
-            a = (t1 + t2) >>> 0;
-        }
-        h[0] = (h[0] + a) >>> 0;
-        h[1] = (h[1] + b) >>> 0;
-        h[2] = (h[2] + c) >>> 0;
-        h[3] = (h[3] + d) >>> 0;
-        h[4] = (h[4] + e) >>> 0;
-        h[5] = (h[5] + f) >>> 0;
-        h[6] = (h[6] + g) >>> 0;
-        h[7] = (h[7] + hh) >>> 0;
-    }
-    const out = new Uint8Array(32);
-    const ov = new DataView(out.buffer);
-    for (let i = 0; i < 8; i++)
-        ov.setUint32(i * 4, h[i]);
-    return out;
-}

package/dist/voice-stream.generated.d.ts

@@ -1,118 +0,0 @@
-/**
- * The streaming door, from either side: the person's
- * answer goes to the verifier as it is spoken, over one WebSocket, and the
- * verifier says `hearing` the moment the key word is out and `verdict` when it
- * has closed the span. One call serves a live microphone and a finished
- * recording alike: a buffer pushed in one go and ended is a short stream.
- *
- * Uses the platform's WebSocket (Node 22, React Native, the browser). The
- * credential rides in the first frame, never in a header, so every platform
- * behaves the same.
- */
-import { AgentcardError, type Lang, type Verdict } from './voice-types.js';
-/**
- * How the bytes are encoded. `pcm16-16k`: little-endian 16-bit mono at
- * 16 kHz, judged live. `mulaw-8k`: a telephone band, judged on the words
- * only. `opus`: an Ogg or WebM Opus stream, judged live. A media type such
- * as `audio/m4a` or `audio/wav`: a finished recording pushed in one go, held
- * until `end`, then judged exactly as an upload of the same bytes.
- */
-export type StreamFormat = 'pcm16-16k' | 'mulaw-8k' | 'opus' | `audio/${string}`;
-/**
- * How the take is heard: the phone's own microphone, a wired headset, a Bluetooth one, or
- * unknown when the platform says nothing. The verifier scores the voice on that route's cohort when it has one
- * and records a change from the enrolment's route as evidence; only the kind travels, never a device name.
- */
-export type ChannelKind = 'builtin' | 'wired' | 'bluetooth' | 'unknown';
-export declare const CHANNEL_KINDS: readonly ChannelKind[];
-/** The key word (and, on a phone's stream, the price) is out: a bot may start its next line now. `heard_count` is how many words landed; the words themselves never cross (WP115). */
-export interface Hearing {
-    heard_count: number;
-}
-/** The verifier's verdict on the stream: the upload verdict plus what the live door knows. */
-/**
- * The verifier's signed word on a take (WP182): `payload` is the exact JSON string the signature covers (the challenge
- * id, `accepted`, the template hash it matched, `z`, `cos`, `spoof_bits`, `issued_at`), `signature` the raw ECDSA
- * `r || s` bytes base64url under the receipt key the Vault's page stamped on the listen, `kid` that key's name. The
- * host relays it to the frame as `host-judged` once the proof landed; the frame checks the signature itself.
- */
-export interface VerdictReceipt {
-    payload: string;
-    signature: string;
-    alg: string;
-    kid: string;
-}
-export interface StreamVerdict extends Verdict {
-    reason: string;
-    bits: {
-        words: number;
-        voice: number;
-        total: number;
-    };
-    cos: number | null;
-    z: number | null;
-    speech_s: number;
-    /** From the first byte to the verdict. */
-    ms: number;
-    /** From the caller's last byte (or `end`) to the verdict: what streaming saves. */
-    since_end_ms: number;
-    /** Why the verifier closed the span: `all_words`, `quiet`, `ended`, `stalled`, `span_cap`, `wall_cap`. */
-    closed_by: string;
-    /** The verifier's signed receipt for this take (WP182), when it sent one. */
-    receipt?: VerdictReceipt;
-}
-export interface StreamInput {
-    /** The verifier's streaming address, `wss://…/v1/stream` (`ws://` against a local verifier). */
-    stream_url: string;
-    authorization_id: string;
-    challenge_id: string;
-    lang: Lang;
-    format: StreamFormat;
-    /** The credential for this answer: the challenge's `answer_token` on the app side, the business's bearer on the server side. */
-    token: string;
-    /** The channel the take is heard on, when known at the open; `handle.channel(kind)` names it later. */
-    channel?: ChannelKind;
-    /** Test seam: the WebSocket constructor; defaults to the platform's. */
-    WebSocket?: typeof WebSocket;
-}
-type Listener<T> = (value: T) => void;
-export interface StreamHandle {
-    readonly format: StreamFormat;
-    /** Queue bytes; they go the moment the socket is open. */
-    push(chunk: ArrayBuffer | Uint8Array): void;
-    /** Nothing more is coming: the verifier closes the span with what it has. */
-    end(): void;
-    /** How the take is heard, once the microphone is open and the device is known; before the verdict. */
-    channel(kind: ChannelKind): void;
-    /**
-     * The audio that follows is sealed (WP115): the take's ephemeral key goes ahead of it as the stream's `sealed`
-     * frame, once, before the first push. The verifier opens every later chunk with it; this side reads none of them.
-     * `kid` names the verifier key the take was sealed to (the first sixteen hex characters of SHA-256 over its SPKI,
-     * as the frame computes it): after a key rotation the verifier opens the take under the key it names, inside the
-     * previous key's grace window, instead of assuming the current one and refusing. A head with no `kid` means the
-     * current key, as a frame from before the field sealed to it.
-     */
-    seal(head: {
-        alg: string;
-        eph: string;
-        kid?: string;
-    }): void;
-    on(event: 'hearing', fn: Listener<Hearing>): StreamHandle;
-    on(event: 'verdict', fn: Listener<StreamVerdict>): StreamHandle;
-    on(event: 'error', fn: Listener<AgentcardError>): StreamHandle;
-    /** Resolves with the verdict; rejects with an `AgentcardError` carrying the verifier's code. */
-    verdict(): Promise<StreamVerdict>;
-    /** Drops the socket without a verdict (the person walked away). */
-    close(): void;
-}
-/** Opens the door and hands back the handle. The first frame names the challenge; bytes follow. */
-export declare function openStream(input: StreamInput): StreamHandle;
-/**
- * A finished recording through the same door. For `pcm16-16k` with `chunkMs`
- * the bytes go in timed chunks, as a microphone would send them; otherwise
- * the whole buffer goes at once. Ends the stream and resolves the verdict.
- */
-export declare function streamBuffer(handle: StreamHandle, bytes: ArrayBuffer | Uint8Array, chunkMs?: number): Promise<StreamVerdict>;
-/** The verifier's streaming address from its origin (`/v1/stream` appended) or a full address, as given. */
-export declare function streamAddress(verifierUrl: string): string;
-export {};

package/dist/voice-stream.generated.js

@@ -1,170 +0,0 @@
-// GENERATED by scripts/generate-voice-stream.mjs from packages/voice/src/core/stream.ts. Do not edit; edit the source and rebuild.
-/**
- * The streaming door, from either side: the person's
- * answer goes to the verifier as it is spoken, over one WebSocket, and the
- * verifier says `hearing` the moment the key word is out and `verdict` when it
- * has closed the span. One call serves a live microphone and a finished
- * recording alike: a buffer pushed in one go and ended is a short stream.
- *
- * Uses the platform's WebSocket (Node 22, React Native, the browser). The
- * credential rides in the first frame, never in a header, so every platform
- * behaves the same.
- */
-import { AgentcardError } from './voice-types.js';
-export const CHANNEL_KINDS = ['builtin', 'wired', 'bluetooth', 'unknown'];
-/** The receipt as the verifier sends it, every field a string, or null for anything else: a receipt with a piece missing cannot be checked, so it is not carried. */
-function receiptOf(r) {
-    if (!r || typeof r !== 'object')
-        return null;
-    const { payload, signature, alg, kid } = r;
-    return typeof payload === 'string' && typeof signature === 'string' && typeof alg === 'string' && typeof kid === 'string' ? { payload, signature, alg, kid } : null;
-}
-function toArrayBuffer(chunk) {
-    if (chunk instanceof ArrayBuffer)
-        return chunk;
-    return chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
-}
-/** Opens the door and hands back the handle. The first frame names the challenge; bytes follow. */
-export function openStream(input) {
-    const WS = input.WebSocket ?? globalThis.WebSocket;
-    if (!WS)
-        throw new AgentcardError('no_websocket', 'This runtime has no WebSocket; the streaming door needs one.');
-    const ws = new WS(input.stream_url);
-    ws.binaryType = 'arraybuffer';
-    const listeners = { hearing: [], verdict: [], error: [] };
-    // Audio chunks and, ahead of the first sealed chunk, the `sealed` text frame: sent in the order they were queued.
-    const queue = [];
-    let open = false, ended = false, settled = false, sealed = false;
-    let channelKind = input.channel && CHANNEL_KINDS.includes(input.channel) ? input.channel : undefined;
-    // A channel named after the open goes as its own text frame; one named before rides the first frame.
-    let channelPending = null;
-    let resolveVerdict, rejectVerdict;
-    const verdictPromise = new Promise((resolve, reject) => { resolveVerdict = resolve; rejectVerdict = reject; });
-    verdictPromise.catch(() => { });
-    const fail = (err) => {
-        if (settled)
-            return;
-        settled = true;
-        for (const fn of listeners.error)
-            fn(err);
-        rejectVerdict(err);
-    };
-    const flush = () => { while (open && queue.length)
-        ws.send(queue.shift()); };
-    ws.onopen = () => {
-        // No token on the frame when the caller has none: a fronting door may carry the credential on the upgrade instead.
-        ws.send(JSON.stringify({ authorization_id: input.authorization_id, challenge_id: input.challenge_id, lang: input.lang, format: input.format, ...(input.token ? { token: input.token } : {}), ...(channelKind ? { channel: channelKind } : {}) }));
-        open = true;
-        if (channelPending) {
-            ws.send(JSON.stringify({ type: 'channel', kind: channelPending }));
-            channelPending = null;
-        }
-        flush();
-        if (ended)
-            ws.send(JSON.stringify({ type: 'end' }));
-    };
-    ws.onmessage = (ev) => {
-        if (typeof ev.data !== 'string')
-            return;
-        let msg;
-        try {
-            msg = JSON.parse(ev.data);
-        }
-        catch {
-            return;
-        }
-        if (msg.type === 'hearing') {
-            const h = { heard_count: Math.max(0, Math.floor(Number(msg.heard_count)) || 0) };
-            for (const fn of listeners.hearing)
-                fn(h);
-        }
-        else if (msg.type === 'verdict') {
-            if (settled)
-                return;
-            settled = true;
-            const receipt = receiptOf(msg.receipt);
-            const v = {
-                accepted: msg.accepted === true, spent: true,
-                approved_with: typeof msg.approved_with === 'string' ? msg.approved_with : null,
-                reason: String(msg.reason ?? ''), bits: msg.bits ?? { words: 0, voice: 0, total: 0 },
-                cos: typeof msg.cos === 'number' ? msg.cos : null, z: typeof msg.z === 'number' ? msg.z : null,
-                speech_s: Number(msg.speech_s ?? 0), ms: Number(msg.ms ?? 0), since_end_ms: Number(msg.since_end_ms ?? 0), closed_by: String(msg.closed_by ?? ''),
-                ...(receipt ? { receipt } : {}),
-            };
-            for (const fn of listeners.verdict)
-                fn(v);
-            resolveVerdict(v);
-        }
-        else if (msg.type === 'error') {
-            fail(new AgentcardError(String(msg.code ?? 'verifier_error'), String(msg.message ?? 'The verifier refused the stream.')));
-        }
-    };
-    ws.onerror = () => fail(new AgentcardError('unreachable', 'The verifier could not be reached.'));
-    ws.onclose = () => fail(new AgentcardError('stream_closed', 'The verifier closed the stream without a verdict.'));
-    const handle = {
-        format: input.format,
-        push(chunk) { if (ended || settled)
-            return; queue.push(toArrayBuffer(chunk)); flush(); },
-        end() { if (ended)
-            return; ended = true; if (open) {
-            flush();
-            ws.send(JSON.stringify({ type: 'end' }));
-        } },
-        channel(kind) {
-            if (settled || ended || !CHANNEL_KINDS.includes(kind))
-                return;
-            if (!open) {
-                channelKind = kind;
-                channelPending = null;
-                return;
-            }
-            channelKind = kind;
-            ws.send(JSON.stringify({ type: 'channel', kind }));
-        },
-        seal(head) {
-            if (settled || ended || sealed || typeof head.eph !== 'string' || !head.eph)
-                return;
-            sealed = true;
-            const kid = typeof head.kid === 'string' && head.kid ? head.kid : null;
-            queue.push(JSON.stringify({ type: 'sealed', alg: head.alg, eph: head.eph, ...(kid ? { kid } : {}) }));
-            flush();
-        },
-        on(event, fn) { listeners[event].push(fn); return handle; },
-        verdict: () => verdictPromise,
-        close() { if (!settled) {
-            settled = true;
-            rejectVerdict(new AgentcardError('stream_closed', 'The stream was closed before a verdict.'));
-        } try {
-            ws.close();
-        }
-        catch { /* already closed */ } },
-    };
-    return handle;
-}
-const PCM16_16K_BYTES_PER_MS = 32;
-/**
- * A finished recording through the same door. For `pcm16-16k` with `chunkMs`
- * the bytes go in timed chunks, as a microphone would send them; otherwise
- * the whole buffer goes at once. Ends the stream and resolves the verdict.
- */
-export async function streamBuffer(handle, bytes, chunkMs) {
-    const u8 = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
-    if (chunkMs && chunkMs > 0 && handle.format === 'pcm16-16k') {
-        const step = PCM16_16K_BYTES_PER_MS * chunkMs;
-        for (let i = 0; i < u8.length; i += step) {
-            handle.push(u8.subarray(i, Math.min(u8.length, i + step)));
-            if (i + step < u8.length)
-                await new Promise((r) => setTimeout(r, chunkMs));
-        }
-    }
-    else {
-        handle.push(u8);
-    }
-    handle.end();
-    return handle.verdict();
-}
-/** The verifier's streaming address from its origin (`/v1/stream` appended) or a full address, as given. */
-export function streamAddress(verifierUrl) {
-    const trimmed = verifierUrl.replace(/\/+$/, '');
-    return /\/v1\/stream$/.test(trimmed) ? trimmed : trimmed + '/v1/stream';
-}