describe("talk transcription gateway relay", () => {

afterEach(() => {

vi.useRealTimers();

clearTalkTranscriptionRelaySessionsForTest();

});

expect(provider.createSession).not.toHaveBeenCalled();

});

it("rejects session creation when transcription expiry would exceed Date range", () => {

vi.useFakeTimers();

vi.setSystemTime(new Date(8_640_000_000_000_000));

const sttSession = {

connect: vi.fn(async () => {}),

sendAudio: vi.fn(),

close: vi.fn(),

isConnected: vi.fn(() => true),

};

const provider: RealtimeTranscriptionProviderPlugin = {

id: "stt-test",

label: "STT Test",

isConfigured: () => true,

createSession: vi.fn(() => sttSession),

};

const context = {

getRuntimeConfig: () => ({}),

broadcastToConnIds: vi.fn(),

} as never;

expect(() =>

createTalkTranscriptionRelaySession({

context,

connId: "conn-1",

provider,

providerConfig: {},

}),

).toThrow("Transcription relay session expiry is outside the supported Date range");

expect(provider.createSession).not.toHaveBeenCalled();

});

it("cancels an active transcription turn and closes the provider session", async () => {

let sttRequest: RealtimeTranscriptionSessionCreateRequest | undefined;

const sttSession = {

import { randomUUID } from "node:crypto";

import type { RealtimeTranscriptionProviderPlugin } from "../plugins/types.js";

import type { RealtimeTranscriptionProviderConfig } from "../realtime-transcription/provider-types.js";

import { parseFiniteNumber as readFiniteNumber } from "../shared/number-coercion.js";

import {

asDateTimestampMs,

parseFiniteNumber as readFiniteNumber,

resolveExpiresAtMsFromDurationMs,

} from "../shared/number-coercion.js";

import { recordTalkObservabilityEvent } from "../talk/observability.js";

import {

type TalkEvent,

}

function pruneExpiredTranscriptionSessions(nowMs = Date.now()): void {

const validNowMs = asDateTimestampMs(nowMs);

if (validNowMs === undefined) {

return;

}

for (const session of transcriptionSessions.values()) {

if (nowMs > session.expiresAtMs) {

const expiresAtMs = asDateTimestampMs(session.expiresAtMs);

if (expiresAtMs === undefined || validNowMs > expiresAtMs) {

closeTranscriptionSession(session, "completed");

}

}

enforceTranscriptionSessionLimits(params.connId);

assertRelayInputAudioConfig(params.providerConfig);

const transcriptionSessionId = randomUUID();

const expiresAtMs = Date.now() + TRANSCRIPTION_SESSION_TTL_MS;

const expiresAtMs = resolveExpiresAtMsFromDurationMs(TRANSCRIPTION_SESSION_TTL_MS);

if (expiresAtMs === undefined) {

throw new Error("Transcription relay session expiry is outside the supported Date range");

}

const talk = createTalkSessionController(

{

sessionId: transcriptionSessionId,

connId: string,

): TranscriptionRelaySession {

const session = transcriptionSessions.get(transcriptionSessionId);

if (!session || session.connId !== connId || Date.now() > session.expiresAtMs) {

const nowMs = asDateTimestampMs(Date.now());

const expiresAtMs = session ? asDateTimestampMs(session.expiresAtMs) : undefined;

if (

!session ||

session.connId !== connId ||

nowMs === undefined ||

expiresAtMs === undefined ||

nowMs > expiresAtMs

) {

if (session) {

closeTranscriptionSession(session, "completed");

}