@perkos/perkos-voice 0.1.0

package/dist/echoSuppression.js

@@ -0,0 +1,42 @@
+export class EchoSuppressionGate {
+    now;
+    cooldownMs;
+    onSuppressed;
+    #barrier;
+    #outputDepth = 0;
+    #guardUntil = 0;
+    #marked = false;
+    constructor(now = Date.now, cooldownMs = 350, onSuppressed = () => { }) {
+        this.now = now;
+        this.cooldownMs = cooldownMs;
+        this.onSuppressed = onSuppressed;
+    }
+    start(barrier) {
+        if (this.#barrier)
+            return;
+        this.#marked = false;
+        const current = barrier.catch(() => { }).then(() => { this.#guardUntil = this.now() + this.cooldownMs; });
+        this.#barrier = current.finally(() => { this.#barrier = undefined; });
+    }
+    beginOutput() { this.#outputDepth += 1; this.#marked = false; }
+    endOutput() {
+        if (this.#outputDepth > 0)
+            this.#outputDepth -= 1;
+        if (this.#outputDepth === 0)
+            this.#guardUntil = this.now() + this.cooldownMs;
+    }
+    shouldSuppress() {
+        const suppressed = this.#outputDepth > 0 || this.#barrier !== undefined || this.now() < this.#guardUntil;
+        if (suppressed && !this.#marked) {
+            this.#marked = true;
+            this.onSuppressed();
+        }
+        if (!suppressed)
+            this.#marked = false;
+        return suppressed;
+    }
+    async waitForBarrier() { await this.#barrier; }
+}
+export function acceptRemoteMicrophone(source, microphoneSource, remoteIdentity, localIdentity, agentIdentity) {
+    return source === microphoneSource && Boolean(remoteIdentity) && remoteIdentity !== localIdentity && remoteIdentity !== agentIdentity;
+}

package/dist/fakes.d.ts

@@ -0,0 +1,42 @@
+import type { AgentRuntime, MediaRoom, MediaTurnInput, SpeechPipeline } from "./ports.js";
+import type { TranscriptPolicy, VoiceGatewayGrant, VoiceMode } from "./types.js";
+export declare class InMemoryMediaRoom implements MediaRoom {
+    #private;
+    private readonly blockPublishUntilCancelled;
+    joined: boolean;
+    closed: boolean;
+    readonly published: Map<string, Uint8Array<ArrayBufferLike>[]>;
+    readonly cancelled: string[];
+    readonly inputSuppression: boolean[];
+    constructor(blockPublishUntilCancelled?: boolean);
+    enqueueTurn(turnId: string, audio: readonly Uint8Array[]): void;
+    join(_grant: VoiceGatewayGrant): Promise<void>;
+    setBargeInHandler(handler: (turnId: string) => Promise<void>): void;
+    setInputSuppressed(suppressed: boolean): void;
+    simulateBargeIn(turnId: string): Promise<void>;
+    receiveTurn(): Promise<MediaTurnInput>;
+    publish(turnId: string, audio: AsyncIterable<Uint8Array>): Promise<"completed" | "cancelled">;
+    cancelPublish(turnId: string): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class FakeSpeechPipeline implements SpeechPipeline {
+    private readonly transcript;
+    private readonly audio;
+    readonly cancelled: string[];
+    readonly policies: TranscriptPolicy[];
+    constructor(transcript?: string, audio?: Uint8Array<ArrayBuffer>);
+    transcribe(_turnId: string, input: AsyncIterable<Uint8Array>, policy: TranscriptPolicy): Promise<string>;
+    synthesize(_turnId: string, _text: string, _mode: VoiceMode, _speechVoice?: string): AsyncIterable<Uint8Array>;
+    cancel(turnId: string): Promise<void>;
+}
+export declare class FakeAgentRuntime implements AgentRuntime {
+    private readonly reply;
+    readonly inputs: Array<{
+        turnId: string;
+        text: string;
+    }>;
+    readonly cancelled: string[];
+    constructor(reply?: string);
+    respond(turnId: string, input: string, signal: AbortSignal): Promise<string>;
+    cancel(turnId: string): Promise<void>;
+}

package/dist/fakes.js

@@ -0,0 +1,80 @@
+async function* chunks(values) {
+    for (const value of values)
+        yield value;
+}
+export class InMemoryMediaRoom {
+    blockPublishUntilCancelled;
+    joined = false;
+    closed = false;
+    published = new Map();
+    cancelled = [];
+    inputSuppression = [];
+    #inputs = [];
+    #releasePublish;
+    #bargeInHandler;
+    constructor(blockPublishUntilCancelled = false) {
+        this.blockPublishUntilCancelled = blockPublishUntilCancelled;
+    }
+    enqueueTurn(turnId, audio) {
+        this.#inputs.push({ turnId, audio: chunks(audio) });
+    }
+    async join(_grant) { this.joined = true; }
+    setBargeInHandler(handler) { this.#bargeInHandler = handler; }
+    setInputSuppressed(suppressed) { this.inputSuppression.push(suppressed); }
+    async simulateBargeIn(turnId) { await this.#bargeInHandler?.(turnId); }
+    async receiveTurn() {
+        const input = this.#inputs.shift();
+        if (!input)
+            throw new Error("No in-memory media turn is queued");
+        return input;
+    }
+    async publish(turnId, audio) {
+        const received = [];
+        for await (const chunk of audio)
+            received.push(chunk);
+        this.published.set(turnId, received);
+        if (this.blockPublishUntilCancelled) {
+            await new Promise((resolve) => { this.#releasePublish = resolve; });
+            return "cancelled";
+        }
+        return "completed";
+    }
+    async cancelPublish(turnId) {
+        this.cancelled.push(turnId);
+        this.#releasePublish?.();
+        this.#releasePublish = undefined;
+    }
+    async close() { this.closed = true; }
+}
+export class FakeSpeechPipeline {
+    transcript;
+    audio;
+    cancelled = [];
+    policies = [];
+    constructor(transcript = "hello", audio = new Uint8Array([1, 2, 3])) {
+        this.transcript = transcript;
+        this.audio = audio;
+    }
+    async transcribe(_turnId, input, policy) {
+        this.policies.push(policy);
+        for await (const _chunk of input) { /* consume without persistence */ }
+        return this.transcript;
+    }
+    async *synthesize(_turnId, _text, _mode, _speechVoice) { yield this.audio; }
+    async cancel(turnId) { this.cancelled.push(turnId); }
+}
+export class FakeAgentRuntime {
+    reply;
+    inputs = [];
+    cancelled = [];
+    constructor(reply = "hello back") {
+        this.reply = reply;
+    }
+    async respond(turnId, input, signal) {
+        if (signal.aborted)
+            throw new Error("Turn cancelled");
+        this.inputs.push({ turnId, text: input });
+        return this.reply;
+    }
+    async cancel(turnId) { this.cancelled.push(turnId); }
+}

package/dist/gateway.d.ts

@@ -0,0 +1,46 @@
+import type { AgentRuntime, MediaRoom, SpeechPipeline } from "./ports.js";
+import { VoiceSessionStateMachine } from "./state-machine.js";
+import type { VoiceCapabilityHandshake, VoiceGatewayGrant, VoiceSessionRequest } from "./types.js";
+import type { MediaSuccessObserver } from "./mediaMetrics.js";
+export declare class VoicePolicyError extends Error {
+    readonly code = "VOICE_POLICY_ERROR";
+}
+export declare class VoiceAuthorizationError extends Error {
+    readonly code = "VOICE_AUTHORIZATION_ERROR";
+}
+export interface StartVoiceSession {
+    request: VoiceSessionRequest;
+    handshake: VoiceCapabilityHandshake | unknown;
+    grant: VoiceGatewayGrant;
+}
+export interface FinalAcceptedVoiceTurn {
+    turnId: string;
+    transcript: string;
+    response: string;
+    outcome: "completed" | "chat_fallback";
+}
+export type FinalTurnSink = (turn: FinalAcceptedVoiceTurn) => Promise<void>;
+/**
+ * Orchestrates transient media and text. It exposes no persistence or content
+ * logging hooks; adapters must treat audio/transcripts as session-scoped data.
+ */
+export declare class VoiceGateway {
+    #private;
+    private readonly media;
+    private readonly speech;
+    private readonly runtime;
+    private readonly now;
+    private readonly observe?;
+    private readonly publishTimeoutMs;
+    private readonly logFailure;
+    private readonly finalTurnSink?;
+    private readonly runtimeTimeoutMs;
+    private readonly speechSlaMs;
+    private readonly presenceMs;
+    readonly state: VoiceSessionStateMachine;
+    constructor(media: MediaRoom, speech: SpeechPipeline, runtime: AgentRuntime, now?: () => Date, observe?: MediaSuccessObserver | undefined, publishTimeoutMs?: number, logFailure?: (line: string) => void, finalTurnSink?: FinalTurnSink | undefined, runtimeTimeoutMs?: number, speechSlaMs?: number, presenceMs?: number);
+    start(input: StartVoiceSession): Promise<void>;
+    runTurn(): Promise<string>;
+    bargeIn(turnId: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/gateway.js

@@ -0,0 +1,418 @@
+import { reasonVoiceAvailability } from "./capability.js";
+import { VoiceSessionStateMachine } from "./state-machine.js";
+import { NoSpeechError, TtsError } from "./speechErrors.js";
+import { VOICE_SPEECH_SLA_MS, looksLikeDetachedVoiceWork, voiceSubtaskAck, voiceSubtaskTimedOut } from "./voiceSubtask.js";
+import { VOICE_PRESENCE_MS, presencePublishId, presenceToneFrames } from "./presenceTone.js";
+export class VoicePolicyError extends Error {
+    code = "VOICE_POLICY_ERROR";
+}
+export class VoiceAuthorizationError extends Error {
+    code = "VOICE_AUTHORIZATION_ERROR";
+}
+/**
+ * Orchestrates transient media and text. It exposes no persistence or content
+ * logging hooks; adapters must treat audio/transcripts as session-scoped data.
+ */
+export class VoiceGateway {
+    media;
+    speech;
+    runtime;
+    now;
+    observe;
+    publishTimeoutMs;
+    logFailure;
+    finalTurnSink;
+    runtimeTimeoutMs;
+    speechSlaMs;
+    presenceMs;
+    state = new VoiceSessionStateMachine();
+    #turnControllers = new Map();
+    #subtaskControllers = new Map();
+    #subtaskOperations = new Set();
+    #bargeInOperations = new Map();
+    #activeTurnOperations = new Set();
+    #request;
+    #closing = false;
+    constructor(media, speech, runtime, now = () => new Date(), observe, publishTimeoutMs = 30_000, logFailure = () => { }, finalTurnSink, runtimeTimeoutMs = 12_000, speechSlaMs = VOICE_SPEECH_SLA_MS, presenceMs = VOICE_PRESENCE_MS) {
+        this.media = media;
+        this.speech = speech;
+        this.runtime = runtime;
+        this.now = now;
+        this.observe = observe;
+        this.publishTimeoutMs = publishTimeoutMs;
+        this.logFailure = logFailure;
+        this.finalTurnSink = finalTurnSink;
+        this.runtimeTimeoutMs = runtimeTimeoutMs;
+        this.speechSlaMs = speechSlaMs;
+        this.presenceMs = presenceMs;
+        this.media.setBargeInHandler?.((turnId) => this.bargeIn(turnId));
+    }
+    async start(input) {
+        this.#validatePolicy(input.request);
+        this.state.transition({ type: "authorization_requested" });
+        const decision = reasonVoiceAvailability(input.handshake, {
+            agentId: input.request.agentId,
+            mode: input.request.mode,
+            transcriptPolicy: input.request.transcriptPolicy,
+            requireInterrupt: false,
+            now: this.now(),
+        });
+        if (!decision.available) {
+            this.state.transition({ type: "failed", reason: decision.reason });
+            throw new VoiceAuthorizationError(`Voice authorization denied: ${decision.reason}`);
+        }
+        if (input.grant.agentIdentity !== input.request.agentId || input.grant.meetingId !== input.request.meetingId) {
+            this.state.transition({ type: "failed", reason: "grant_scope_mismatch" });
+            throw new VoiceAuthorizationError("Grant is not scoped to the requested agent and meeting");
+        }
+        if (Date.parse(input.grant.expiresAt) <= this.now().getTime()) {
+            this.state.transition({ type: "failed", reason: "grant_expired" });
+            throw new VoiceAuthorizationError("Grant has expired");
+        }
+        this.#request = input.request;
+        this.state.transition({ type: "authorized" });
+        this.state.transition({ type: "join_started" });
+        await this.media.join(input.grant);
+        this.state.transition({ type: "joined" });
+        this.state.transition({ type: "listening" });
+    }
+    async runTurn() {
+        if (this.#closing)
+            return "session-closed";
+        const operation = this.#runTurn();
+        this.#activeTurnOperations.add(operation);
+        try {
+            return await operation;
+        }
+        catch (error) {
+            if (this.#closing)
+                return "session-closed";
+            throw error;
+        }
+        finally {
+            this.#activeTurnOperations.delete(operation);
+        }
+    }
+    async #runTurn() {
+        await Promise.allSettled([...this.#bargeInOperations.values()]);
+        const request = this.#request;
+        if (!request)
+            throw new VoicePolicyError("Session has not started");
+        const input = await this.media.receiveTurn();
+        this.media.setInputSuppressed?.(true);
+        this.state.transition({ type: "turn_committed", turnId: input.turnId });
+        const controller = new AbortController();
+        this.#turnControllers.set(input.turnId, controller);
+        try {
+            let transcript;
+            try {
+                transcript = await this.speech.transcribe(input.turnId, input.audio, request.transcriptPolicy);
+            }
+            catch (error) {
+                if (error instanceof NoSpeechError) {
+                    this.state.transition({ type: "turn_skipped", turnId: input.turnId });
+                    return input.turnId;
+                }
+                throw error;
+            }
+            this.observe?.("stt_success");
+            const runtime = this.runtime.respond(input.turnId, transcript, controller.signal);
+            runtime.catch(() => { });
+            const presence = this.#armPresence(input.turnId);
+            let slaTimer;
+            let hardTimer;
+            const slaMs = this.speechSlaMs;
+            const allowSla = slaMs > 0 && slaMs < this.runtimeTimeoutMs && looksLikeDetachedVoiceWork(transcript);
+            const sla = allowSla
+                ? new Promise((resolve) => { slaTimer = setTimeout(() => resolve("sla"), slaMs); })
+                : new Promise(() => { });
+            const hardTimeout = new Promise((resolve) => { hardTimer = setTimeout(() => resolve("timeout"), this.runtimeTimeoutMs); });
+            const runtimeOutcome = await Promise.race([
+                runtime.then((response) => ({ status: "completed", response })),
+                ...(allowSla ? [sla.then(() => ({ status: "sla" }))] : []),
+                hardTimeout.then(() => ({ status: "timeout" })),
+            ]).finally(() => { if (slaTimer)
+                clearTimeout(slaTimer); });
+            await presence.stop();
+            if (runtimeOutcome.status === "timeout") {
+                if (hardTimer)
+                    clearTimeout(hardTimer);
+                controller.abort();
+                await this.runtime.cancel(input.turnId);
+                this.observe?.("runtime_timeout");
+                if (!this.#closing && this.state.snapshot.state === "thinking")
+                    this.state.transition({ type: "turn_skipped", turnId: input.turnId });
+                return input.turnId;
+            }
+            if (runtimeOutcome.status === "sla") {
+                await this.#speakNow(input.turnId, voiceSubtaskAck(transcript), request, controller);
+                this.observe?.("voice_subtask_started");
+                if (!this.#closing && this.state.snapshot.state === "thinking")
+                    this.state.transition({ type: "turn_skipped", turnId: input.turnId });
+                this.#subtaskControllers.set(input.turnId, controller);
+                this.#followSubtask(input.turnId, transcript, runtime, controller, request);
+                return input.turnId;
+            }
+            if (hardTimer)
+                clearTimeout(hardTimer);
+            if (this.#closing || controller.signal.aborted)
+                return input.turnId;
+            const response = runtimeOutcome.response;
+            this.observe?.("openclaw_success");
+            this.state.transition({ type: "response_started", turnId: input.turnId });
+            try {
+                const publish = this.media.publish(input.turnId, this.speech.synthesize(input.turnId, response, request.mode, request.speechVoice));
+                publish.catch(() => { });
+                const cancelled = new Promise((resolve) => controller.signal.addEventListener("abort", () => resolve("cancelled"), { once: true }));
+                let timer;
+                const timeout = new Promise((_resolve, reject) => { timer = setTimeout(() => reject(new TtsError("stream_stalled")), this.publishTimeoutMs); });
+                const outcome = await Promise.race([publish, cancelled, timeout]).finally(() => { if (timer)
+                    clearTimeout(timer); });
+                if (outcome === "stream_stalled") {
+                    this.logFailure("voice tts failed: stream_stalled");
+                    controller.abort();
+                    await Promise.allSettled([this.media.cancelPublish(input.turnId), this.speech.cancel(input.turnId)]);
+                    if (!this.#closing && this.state.snapshot.state === "speaking")
+                        this.state.transition({ type: "response_aborted", turnId: input.turnId });
+                    await this.#commitFallback(input.turnId, transcript, response);
+                    return input.turnId;
+                }
+                if (outcome === "cancelled") {
+                    if (this.finalTurnSink)
+                        this.observe?.("chat_commit_skipped_cancelled");
+                    if (this.state.snapshot.state === "speaking") {
+                        controller.abort();
+                        await Promise.allSettled([this.media.cancelPublish(input.turnId), this.speech.cancel(input.turnId)]);
+                    }
+                    await Promise.race([publish.catch(() => "cancelled"), new Promise((resolve) => setTimeout(() => resolve("cancelled"), 1_000))]);
+                    if (this.state.snapshot.state === "speaking")
+                        this.state.transition({ type: "response_aborted", turnId: input.turnId });
+                    return input.turnId;
+                }
+            }
+            catch (error) {
+                if (error instanceof TtsError && error.category === "stream_stalled") {
+                    this.logFailure("voice tts failed: stream_stalled");
+                    controller.abort();
+                    await Promise.allSettled([this.media.cancelPublish(input.turnId), this.speech.cancel(input.turnId)]);
+                    if (!this.#closing && this.state.snapshot.state === "speaking")
+                        this.state.transition({ type: "response_aborted", turnId: input.turnId });
+                    await this.#commitFallback(input.turnId, transcript, response);
+                    return input.turnId;
+                }
+                throw error;
+            }
+            this.observe?.("tts_success");
+            if (!this.state.snapshot.cancelledTurnIds.includes(input.turnId)) {
+                this.state.transition({ type: "response_completed", turnId: input.turnId });
+                if (this.finalTurnSink) {
+                    this.observe?.("chat_commit_started");
+                    try {
+                        await this.finalTurnSink({ turnId: input.turnId, transcript, response, outcome: "completed" });
+                        this.observe?.("chat_commit_succeeded");
+                    }
+                    catch {
+                        this.observe?.("chat_commit_failed");
+                    }
+                }
+            }
+            return input.turnId;
+        }
+        finally {
+            if (!this.#subtaskControllers.has(input.turnId))
+                this.#turnControllers.delete(input.turnId);
+            this.media.setInputSuppressed?.(false);
+        }
+    }
+    #armPresence(turnId) {
+        if (!(this.presenceMs > 0))
+            return { stop: async () => { } };
+        const presenceId = presencePublishId(turnId);
+        const controller = new AbortController();
+        let timer;
+        let started = false;
+        let cancelled = false;
+        let publish;
+        timer = setTimeout(() => {
+            if (cancelled || this.#closing || controller.signal.aborted)
+                return;
+            started = true;
+            this.observe?.("voice_presence_started");
+            publish = this.media.publish(presenceId, presenceToneFrames(controller.signal));
+            publish.catch(() => { });
+        }, this.presenceMs);
+        return {
+            stop: async () => {
+                cancelled = true;
+                if (timer)
+                    clearTimeout(timer);
+                controller.abort();
+                if (!started)
+                    return;
+                await this.media.cancelPublish(presenceId);
+                if (publish)
+                    await Promise.race([publish.catch(() => undefined), new Promise((resolve) => setTimeout(resolve, 250))]);
+                this.observe?.("voice_presence_cancelled");
+            },
+        };
+    }
+    #followSubtask(turnId, transcript, runtime, controller, request) {
+        const operation = (async () => {
+            let leftoverTimer;
+            try {
+                const leftover = new Promise((resolve) => {
+                    leftoverTimer = setTimeout(() => resolve("timeout"), Math.max(1, this.runtimeTimeoutMs));
+                });
+                const outcome = await Promise.race([
+                    runtime.then((response) => ({ status: "completed", response })),
+                    leftover.then(() => ({ status: "timeout" })),
+                ]);
+                if (this.#closing || controller.signal.aborted)
+                    return;
+                if (outcome.status === "timeout") {
+                    controller.abort();
+                    await this.runtime.cancel(turnId);
+                    this.observe?.("voice_subtask_timeout");
+                    await this.#speakProgress(`${turnId}:subtask-timeout`, voiceSubtaskTimedOut(transcript), request, controller);
+                    return;
+                }
+                this.observe?.("openclaw_success");
+                this.observe?.("voice_subtask_completed");
+                await this.#speakProgress(`${turnId}:subtask`, outcome.response, request, controller);
+                if (this.finalTurnSink && !this.#closing && !controller.signal.aborted) {
+                    this.observe?.("chat_commit_started");
+                    try {
+                        await this.finalTurnSink({ turnId, transcript, response: outcome.response, outcome: "completed" });
+                        this.observe?.("chat_commit_succeeded");
+                    }
+                    catch {
+                        this.observe?.("chat_commit_failed");
+                    }
+                }
+            }
+            catch {
+                this.observe?.("voice_subtask_failed");
+            }
+            finally {
+                if (leftoverTimer)
+                    clearTimeout(leftoverTimer);
+                this.#subtaskControllers.delete(turnId);
+                this.#turnControllers.delete(turnId);
+            }
+        })();
+        this.#subtaskOperations.add(operation);
+        void operation.finally(() => this.#subtaskOperations.delete(operation));
+    }
+    async #speakProgress(turnId, text, request, controller) {
+        if (this.#closing || controller.signal.aborted || !text.trim())
+            return;
+        if (this.state.snapshot.state !== "listening")
+            return;
+        try {
+            this.state.transition({ type: "turn_committed", turnId });
+        }
+        catch {
+            return;
+        }
+        await this.#speakNow(turnId, text, request, controller);
+    }
+    async #speakNow(turnId, text, request, controller) {
+        if (this.#closing || controller.signal.aborted || !text.trim())
+            return;
+        if (this.state.snapshot.state === "listening" || this.state.snapshot.state === "thinking") {
+            try {
+                this.state.transition({ type: "response_started", turnId });
+            }
+            catch { /* already speaking */ }
+        }
+        try {
+            const publish = this.media.publish(turnId, this.speech.synthesize(turnId, text, request.mode, request.speechVoice));
+            publish.catch(() => { });
+            const cancelled = new Promise((resolve) => controller.signal.addEventListener("abort", () => resolve("cancelled"), { once: true }));
+            let timer;
+            const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve("stalled"), this.publishTimeoutMs); });
+            const outcome = await Promise.race([publish, cancelled, timeout]).finally(() => { if (timer)
+                clearTimeout(timer); });
+            if (outcome === "cancelled" || outcome === "stalled") {
+                await Promise.allSettled([this.media.cancelPublish(turnId), this.speech.cancel(turnId)]);
+                if (this.state.snapshot.state === "speaking")
+                    this.state.transition({ type: "response_aborted", turnId });
+                return;
+            }
+            this.observe?.("tts_success");
+            if (this.state.snapshot.state === "speaking")
+                this.state.transition({ type: "response_completed", turnId });
+        }
+        catch {
+            if (this.state.snapshot.state === "speaking") {
+                try {
+                    this.state.transition({ type: "response_aborted", turnId });
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    async #commitFallback(turnId, transcript, response) {
+        if (!this.finalTurnSink || this.#closing)
+            return;
+        this.observe?.("chat_fallback_started");
+        try {
+            await this.finalTurnSink({ turnId, transcript, response, outcome: "chat_fallback" });
+            this.observe?.("chat_fallback_succeeded");
+        }
+        catch {
+            this.observe?.("chat_fallback_failed");
+        }
+    }
+    async bargeIn(turnId) {
+        const existing = this.#bargeInOperations.get(turnId);
+        if (existing)
+            return existing;
+        const operation = (async () => {
+            if (this.state.snapshot.state === "speaking")
+                this.state.transition({ type: "barge_in", turnId });
+            this.#turnControllers.get(turnId)?.abort();
+            await Promise.allSettled([this.media.cancelPublish(turnId), this.speech.cancel(turnId), this.runtime.cancel(turnId)]);
+            this.observe?.("barge_in_confirmed");
+            this.observe?.("publish_cancelled_barge_in");
+            this.#turnControllers.delete(turnId);
+        })();
+        this.#bargeInOperations.set(turnId, operation);
+        try {
+            await operation;
+        }
+        finally {
+            this.#bargeInOperations.delete(turnId);
+        }
+    }
+    async close() {
+        this.#closing = true;
+        await Promise.allSettled([...this.#bargeInOperations.values()]);
+        this.state.transition({ type: "close_requested" });
+        const activeTurnIds = [...new Set([...this.#turnControllers.keys(), ...this.#subtaskControllers.keys()])];
+        if (activeTurnIds.length > 0)
+            this.observe?.("turn_cancelled_session_close");
+        for (const turnId of activeTurnIds)
+            this.#turnControllers.get(turnId)?.abort();
+        for (const turnId of activeTurnIds)
+            this.#subtaskControllers.get(turnId)?.abort();
+        await Promise.allSettled(activeTurnIds.flatMap((turnId) => [this.runtime.cancel(turnId), this.speech.cancel(turnId), this.media.cancelPublish(turnId)]));
+        await this.media.close();
+        await Promise.race([
+            Promise.allSettled([...this.#activeTurnOperations, ...this.#subtaskOperations]),
+            new Promise((resolve) => setTimeout(resolve, 2_000)),
+        ]);
+        this.state.transition({ type: "closed" });
+    }
+    #validatePolicy(request) {
+        if (request.transcriptPolicy === "saved") {
+            const consent = request.transcriptConsent;
+            if (!consent?.granted || !consent.subjectId || !Number.isFinite(Date.parse(consent.grantedAt))) {
+                throw new VoicePolicyError("Saved transcripts require explicit, valid consent");
+            }
+        }
+        else if (request.transcriptConsent) {
+            throw new VoicePolicyError("Transcript consent is only accepted for saved transcripts");
+        }
+    }
+}

package/dist/grants.d.ts

@@ -0,0 +1,22 @@
+import type { VoiceGatewayGrant } from "./types.js";
+export interface GrantRequest {
+    sessionId: string;
+    projectId: string;
+    meetingId: string;
+    voiceProcessingConsent: true;
+}
+export interface GrantSource {
+    obtain(request: GrantRequest): Promise<VoiceGatewayGrant>;
+}
+export declare class FileGrantSource implements GrantSource {
+    private readonly path;
+    constructor(path: string);
+    obtain(): Promise<VoiceGatewayGrant>;
+}
+export declare class M2mGrantSource implements GrantSource {
+    private readonly endpoint;
+    private readonly credential;
+    private readonly fetcher;
+    constructor(endpoint: string, credential: string, fetcher?: typeof fetch);
+    obtain(request: GrantRequest): Promise<VoiceGatewayGrant>;
+}