dvgateway-adapters 1.9.7 → 1.9.12

package/dist/realtime/gpt-live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpt-live.d.ts","sourceRoot":"","sources":["../../src/realtime/gpt-live.ts"],"names":[],"mappings":"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"}

package/dist/realtime/gpt-live.js

@@ -0,0 +1,628 @@
+/**
+ * OpenAI GPT-Live Speech-to-Speech Adapter (@since SDK 1.9.10)
+ *
+ * GPT-Live (`gpt-live-1`) is a **full-duplex** voice model: it listens while it
+ * speaks and decides on its own when to start and stop talking. Reasoning and
+ * tool use are **delegated** to a backend — either an OpenAI Responses model
+ * (`delegation: { type: 'responses' }`) or your own code (`{ type: 'client' }`).
+ *
+ * Wiring is the same as the other S2S adapters (`OpenAIRealtimeAdapter`,
+ * `GeminiLiveAdapter`): feed `gw.streamAudio(..., { pipelineType: 's2s' })` into
+ * `startSession()` and inject `onAudioOutput` chunks with `gw.injectTts()`.
+ *
+ * What this adapter does for you (each item was measured on the real API,
+ * 2026-10-11 — see docs/gpt-live-integration-plan.md §9):
+ *
+ *  - **16 kHz PCM end to end.** GPT-Live accepts `audio/pcm` at 16 kHz, the same
+ *    format as DVGateway, so there is no resampling.
+ *  - **Speech gate.** GPT-Live streams output audio continuously, silence included
+ *    (the output length equals the session length). Injecting it raw would keep
+ *    the gateway's TTS player "speaking" forever and `tts:complete` would never
+ *    fire. The adapter forwards only speech segments (RMS gate + hang time).
+ *  - **No silent defaults.** `delegation` is required (OpenAI treats a missing
+ *    delegation as client mode) and `store` is sent as `false` explicitly
+ *    (`store: true` keeps a stereo recording at OpenAI for 30 days).
+ *  - **Delegation policy prompt.** Without one, the model said "yes, that time is
+ *    available — I'll book it" without checking in 2 of 5 runs; with the policy
+ *    prompt it delegated 15 of 15 times and never claimed completion.
+ *    `buildGptLiveInstructions()` produces that prompt shape.
+ *  - **Unspoken-result detection.** In 1 of 15 runs the model received the backend
+ *    result and never said it. `onUnspokenResult` fires when no new speech starts
+ *    within `unspokenResultMs` after a result is sent, so you can re-send it.
+ *
+ * What it does NOT do (by design — see the plan doc):
+ *  - No automatic reconnect (a new connection is a new billed session and a
+ *    pending action could run twice). Errors go to `onError`; you decide.
+ *  - No exact wording. GPT-Live paraphrases. Play legally required notices
+ *    (e.g. "AI 상담원입니다") with `gw.say()` **before** `startSession()`.
+ *
+ * API reference: https://developers.openai.com/api/docs/guides/live
+ * WebSocket:     wss://api.openai.com/v1/live/sessions
+ */
+import WebSocket from 'ws';
+import { float32ToSlin16 } from 'dvgateway-sdk';
+// ─── Constants ───────────────────────────────────────────────────────────────
+export const GPT_LIVE_URL = 'wss://api.openai.com/v1/live/sessions';
+export const GPT_LIVE_MODEL = 'gpt-live-1';
+const SAMPLE_RATE = 16000;
+const FRAME_SAMPLES = SAMPLE_RATE / 50; // 20 ms
+/** OpenAI error codes that retrying cannot fix (same set LiveKit treats as fatal). */
+const FATAL_ERROR_CODES = new Set([
+    'insufficient_quota',
+    'invalid_api_key',
+    'account_deactivated',
+    'billing_hard_limit_reached',
+]);
+/** Error with the OpenAI code attached when there is one. */
+export class GptLiveError extends Error {
+    code;
+    fatal;
+    status;
+    constructor(message, code, fatal = false, status) {
+        super(message);
+        this.code = code;
+        this.fatal = fatal;
+        this.status = status;
+        this.name = 'GptLiveError';
+    }
+}
+/**
+ * Build conversation instructions in the shape OpenAI recommends for GPT-Live
+ * (Backchannel / Interruption / Delegation policy — the headings are kept in
+ * English as OpenAI advises) plus DVGateway's phone rules.
+ *
+ * The delegation policy is what made the model stop claiming unchecked results
+ * in our measurement (2/5 → 0/15).
+ */
+export function buildGptLiveInstructions(o = {}) {
+    const persona = o.persona ?? '당신은 한국어 전화 상담원입니다. 차분하고 친절하게, 서두르지 않고 한국어로 말합니다.';
+    const caps = o.capabilities?.length ? o.capabilities : ['정보 조회: 상대가 묻는 내용에 필요한 정보를 확인합니다.'];
+    const when = o.delegateWhen?.length ? o.delegateWhen : ['답이 백엔드 정보에 달려 있을 때.', '이미 맡긴 작업을 상대가 고칠 때.'];
+    const notWhen = o.dontDelegateWhen?.length ? o.dontDelegateWhen
+        : ['인사이거나, 이미 받은 결과를 다시 말해 달라고 할 때.', '무엇을 원하는지 짧게 되물어야 알 수 있을 때.'];
+    const rules = [
+        '확인되지 않은 일을 가능하다거나 완료됐다고 말하지 않습니다. 결과를 받은 뒤에만 말합니다.',
+        '결과를 기다리는 동안에는 확인 중이라고만 말합니다.',
+        '묻는 말은 문장 끝에 한 번만 합니다.',
+        '이름·날짜·숫자가 불분명하면 그 부분만 다시 묻습니다.',
+        '잘 못 들었으면 "제가 잘 못 들었습니다" 라고 말합니다. 상대에게 또박또박 말하라고 하지 않습니다.',
+        ...(o.rules ?? []),
+    ];
+    return [
+        persona,
+        '상대가 답답해하면 짧게 공감하고 다음에 할 일로 넘어갑니다.',
+        '',
+        'Backchannel policy: 맞장구는 가끔만 합니다. 상대의 말을 덮지 않습니다.',
+        '',
+        'Interruption policy: 상대가 말하면 바로 멈추고 듣습니다.',
+        '',
+        'Delegation policy:',
+        'Backend tools:',
+        ...caps.map((c) => `- ${c}`),
+        '',
+        'Delegate to the backend when:',
+        ...when.map((c) => `- ${c}`),
+        '',
+        'Do not delegate to the backend when:',
+        ...notWhen.map((c) => `- ${c}`),
+        '',
+        'Delegate before giving an answer that depends on backend work.',
+        'Do not guess the result while waiting.',
+        '',
+        ...rules.map((r) => `- ${r}`),
+    ].join('\n');
+}
+// ─── Speech gate (exported for tests) ────────────────────────────────────────
+/**
+ * Forwards only speech from a continuous output stream.
+ * Opens at the first frame with RMS ≥ threshold; stays open until `hangMs` of
+ * quieter frames have passed (so pauses inside a sentence survive).
+ */
+export class SpeechGate {
+    threshold;
+    hangMs;
+    open = false;
+    quietMs = 0;
+    constructor(threshold = 0.001, hangMs = 600) {
+        this.threshold = threshold;
+        this.hangMs = hangMs;
+    }
+    get isOpen() { return this.open; }
+    /**
+     * Feed one chunk of 16 kHz PCM16 (little-endian). Returns what to forward and
+     * whether the gate opened/closed during this chunk.
+     */
+    push(pcm) {
+        const frameBytes = FRAME_SAMPLES * 2;
+        const keep = [];
+        let opened = false;
+        let closed = false;
+        for (let off = 0; off < pcm.length; off += frameBytes) {
+            const end = Math.min(off + frameBytes, pcm.length);
+            const frame = pcm.subarray(off, end - ((end - off) % 2));
+            if (frame.length < 2)
+                continue;
+            const loud = frameRms(frame) >= this.threshold;
+            const ms = (frame.length / 2) * 1000 / SAMPLE_RATE;
+            if (loud) {
+                if (!this.open) {
+                    this.open = true;
+                    opened = true;
+                }
+                this.quietMs = 0;
+                keep.push(frame);
+            }
+            else if (this.open) {
+                this.quietMs += ms;
+                if (this.quietMs >= this.hangMs) {
+                    this.open = false;
+                    this.quietMs = 0;
+                    closed = true;
+                }
+                else {
+                    keep.push(frame);
+                }
+            }
+        }
+        return { out: Buffer.concat(keep), opened, closed };
+    }
+}
+export function frameRms(pcm) {
+    const n = pcm.length >> 1;
+    if (n === 0)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        const v = pcm.readInt16LE(i * 2) / 32768;
+        sum += v * v;
+    }
+    return Math.sqrt(sum / n);
+}
+/** Build the `session.start` event (exported for tests). */
+export function buildGptLiveSessionStart(o) {
+    const session = {
+        model: GPT_LIVE_MODEL,
+        instructions: o.instructions ?? buildGptLiveInstructions({}),
+        audio: { format: { type: 'audio/pcm', rate: SAMPLE_RATE }, output: { voice: o.voice ?? 'marin' } },
+        store: o.store ?? false, // explicit — never rely on the server default
+    };
+    if (o.history?.length) {
+        session.input = o.history.slice(-128).map((m) => ({
+            type: 'message',
+            role: m.role,
+            content: [{ type: m.role === 'assistant' ? 'output_text' : 'input_text', text: m.text }],
+        }));
+    }
+    if (o.delegation.type === 'client') {
+        session.delegation = { type: 'client' };
+    }
+    else {
+        const r = o.delegation.responses;
+        const tools = (r.tools ?? []).map((t) => ({
+            type: 'function',
+            name: t.name,
+            ...(t.description && { description: t.description }),
+            ...(t.parameters && { parameters: t.parameters }),
+        }));
+        if (r.webSearch)
+            tools.push({ type: 'web_search' });
+        const responses = { model: r.model, parallel_tool_calls: r.parallelToolCalls ?? false };
+        if (r.instructions)
+            responses.instructions = r.instructions;
+        if (tools.length)
+            responses.tools = tools;
+        if (r.toolChoice)
+            responses.tool_choice = r.toolChoice;
+        if (r.reasoning)
+            responses.reasoning = r.reasoning;
+        if (r.serviceTier)
+            responses.service_tier = r.serviceTier;
+        if (r.maxOutputTokens)
+            responses.max_output_tokens = Math.max(16, r.maxOutputTokens);
+        session.delegation = { type: 'responses', responses };
+    }
+    return { type: 'session.start', event_id: 'dvg_session_start', session };
+}
+/** OpenAI echoes part of a wrong key in error bodies — never pass it on. */
+export function redactKey(s) {
+    return s.replace(/sk-[A-Za-z0-9_*-]+/g, 'sk-***');
+}
+class Session {
+    ws = null;
+    started = false;
+    closing = false;
+    finalized = false;
+    usageSeconds = 0;
+    closeReason;
+    gate;
+    finished = [];
+    open = {};
+    pendingCalls = new Set();
+    delegations = new Map();
+    eventSeq = 0;
+    constructor(gate) { this.gate = gate; }
+}
+// ─── Adapter ─────────────────────────────────────────────────────────────────
+export class GptLiveAdapter {
+    o;
+    sessions = new Map();
+    audioOutputHandler = null;
+    transcriptHandler = null;
+    errorHandler = null;
+    toolCallHandler = null;
+    speechActivityHandler = null;
+    delegationHandler = null;
+    usageHandler = null;
+    unspokenHandler = null;
+    constructor(opts) {
+        if (!opts?.apiKey)
+            throw new Error('GptLiveAdapter: apiKey is required');
+        if (!opts.delegation || (opts.delegation.type !== 'client' && opts.delegation.type !== 'responses')) {
+            throw new Error('GptLiveAdapter: delegation is required ({ type: "client" } or { type: "responses", responses: { model } })');
+        }
+        if (opts.delegation.type === 'responses' && !opts.delegation.responses?.model) {
+            throw new Error('GptLiveAdapter: delegation.responses.model is required');
+        }
+        this.o = opts;
+    }
+    onAudioOutput(h) { this.audioOutputHandler = h; }
+    onTranscript(h) { this.transcriptHandler = h; }
+    onError(h) { this.errorHandler = h; }
+    /** Responses delegation: a backend function call to run. Answer with submitToolResult(). */
+    onToolCall(h) { this.toolCallHandler = h; }
+    /** caller: from input transcript timing · callee: from the output speech gate (both approximate). */
+    onSpeechActivity(h) { this.speechActivityHandler = h; }
+    /** Client delegation: return `{ speak }` (said aloud, paraphrased) or `{ note }` (silent context). */
+    onDelegation(h) { this.delegationHandler = h; }
+    onUsage(h) { this.usageHandler = h; }
+    /** A result was sent but the model did not start speaking within `unspokenResultMs`. */
+    onUnspokenResult(h) { this.unspokenHandler = h; }
+    async startSession(linkedId, audioIn) {
+        if (this.sessions.has(linkedId))
+            throw new Error(`GPT-Live session already running for ${linkedId}`);
+        const g = this.o.speechGate ?? {};
+        const s = new Session(new SpeechGate(g.rmsThreshold ?? 0.001, g.hangMs ?? 600));
+        this.sessions.set(linkedId, s);
+        try {
+            const ws = await this.connect(linkedId, s);
+            s.ws = ws;
+            this.send(s, buildGptLiveSessionStart(this.o));
+            await this.waitStarted(linkedId, s);
+            void this.pipeAudio(linkedId, s, audioIn);
+            await new Promise((resolve) => {
+                if (ws.readyState === WebSocket.CLOSED)
+                    resolve();
+                else
+                    ws.once('close', () => resolve());
+            });
+        }
+        finally {
+            this.finish(linkedId, s);
+        }
+    }
+    /** Close gracefully: session.close → wait for session.closed (final usage) → close the socket. */
+    async stop(linkedId) {
+        const ids = linkedId ? [linkedId] : [...this.sessions.keys()];
+        await Promise.all(ids.map(async (id) => {
+            const s = this.sessions.get(id);
+            if (!s?.ws)
+                return;
+            if (s.ws.readyState === WebSocket.OPEN && !s.closing) {
+                s.closing = true;
+                this.send(s, { type: 'session.close', event_id: this.eid(s, 'close') });
+                await new Promise((resolve) => {
+                    const t = setTimeout(resolve, this.o.closeTimeoutMs ?? 15000);
+                    const iv = setInterval(() => {
+                        if (s.finalized || s.ws?.readyState !== WebSocket.OPEN) {
+                            clearTimeout(t);
+                            clearInterval(iv);
+                            resolve();
+                        }
+                    }, 20);
+                    t.unref?.();
+                });
+            }
+            try {
+                s.ws.close(1000, 'session ended');
+            }
+            catch { /* already closed */ }
+        }));
+    }
+    /** Responses delegation: return a function result. Continues the backend once every pending call is answered. */
+    submitToolResult(linkedId, callId, result) {
+        const s = this.sessions.get(linkedId);
+        if (!s)
+            return;
+        this.send(s, {
+            type: 'response.item.create',
+            event_id: this.eid(s, 'tool'),
+            item: { type: 'function_call_output', call_id: callId, output: typeof result === 'string' ? result : JSON.stringify(result) },
+        });
+        s.pendingCalls.delete(callId);
+        if (s.pendingCalls.size === 0)
+            this.send(s, { type: 'response.create', event_id: this.eid(s, 'continue') });
+    }
+    /** Something to say now (paraphrased). Pass the client delegation id for a task result, else null. */
+    appendCommentary(linkedId, delegationId, text) {
+        this.append(linkedId, 'session.commentary.append', delegationId, text);
+    }
+    /** Silent context the model may use later. */
+    appendThinking(linkedId, delegationId, text) {
+        this.append(linkedId, 'session.thinking.append', delegationId, text);
+    }
+    /** Trusted instructions (can interrupt current speech). */
+    appendInstructions(linkedId, text) {
+        this.append(linkedId, 'session.instructions.append', null, text);
+    }
+    muteInput(linkedId) { const s = this.sessions.get(linkedId); if (s)
+        this.send(s, { type: 'session.input_audio.mute', event_id: this.eid(s, 'mute') }); }
+    unmuteInput(linkedId) { const s = this.sessions.get(linkedId); if (s)
+        this.send(s, { type: 'session.input_audio.unmute', event_id: this.eid(s, 'unmute') }); }
+    // ── internals ────────────────────────────────────────────────────────────
+    eid(s, tag) { s.eventSeq += 1; return `dvg_${tag}_${s.eventSeq}`; }
+    send(s, ev) {
+        if (s.ws && s.ws.readyState === WebSocket.OPEN)
+            s.ws.send(JSON.stringify(ev));
+    }
+    append(linkedId, type, delegationId, text) {
+        const s = this.sessions.get(linkedId);
+        if (!s)
+            return;
+        const eventId = this.eid(s, 'append');
+        this.send(s, { type, event_id: eventId, delegation_id: delegationId, content: text });
+        if (type === 'session.commentary.append' && delegationId)
+            this.watchResult(linkedId, s, delegationId, eventId);
+    }
+    connect(linkedId, s) {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(this.o.url ?? GPT_LIVE_URL, { headers: { Authorization: `Bearer ${this.o.apiKey}` } });
+            const timer = setTimeout(() => { ws.terminate(); reject(new GptLiveError('GPT-Live: connect timeout')); }, this.o.connectTimeoutMs ?? 15000);
+            ws.once('open', () => { clearTimeout(timer); resolve(ws); });
+            ws.once('unexpected-response', (_req, res) => {
+                clearTimeout(timer);
+                let body = '';
+                res.on('data', (d) => { if (body.length < 2000)
+                    body += d.toString(); });
+                res.on('end', () => {
+                    let code;
+                    try {
+                        code = JSON.parse(body)?.error?.code;
+                    }
+                    catch { /* not JSON */ }
+                    const err = new GptLiveError(`GPT-Live HTTP ${res.statusCode}: ${redactKey(body).slice(0, 500)}`, code, res.statusCode === 401 || res.statusCode === 403 || (code !== undefined && FATAL_ERROR_CODES.has(code)), res.statusCode);
+                    reject(err);
+                });
+            });
+            ws.once('error', (e) => { clearTimeout(timer); reject(new GptLiveError(`GPT-Live: ${redactKey(String(e.message))}`)); });
+            ws.on('message', (data) => {
+                let ev;
+                try {
+                    ev = JSON.parse(data.toString());
+                }
+                catch {
+                    return;
+                }
+                try {
+                    this.handle(linkedId, s, ev);
+                }
+                catch (e) {
+                    this.errorHandler?.(e, linkedId);
+                }
+            });
+        }).then((ws) => {
+            ws.on('error', (e) => this.errorHandler?.(new GptLiveError(`GPT-Live: ${redactKey(String(e.message))}`), linkedId));
+            return ws;
+        }).catch((e) => {
+            this.errorHandler?.(e, linkedId);
+            throw e;
+        });
+    }
+    waitStarted(linkedId, s) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const e = new GptLiveError('GPT-Live: session.started not received');
+                this.errorHandler?.(e, linkedId);
+                s.ws?.close();
+                reject(e);
+            }, this.o.connectTimeoutMs ?? 15000);
+            const iv = setInterval(() => {
+                if (s.started) {
+                    clearTimeout(timer);
+                    clearInterval(iv);
+                    resolve();
+                }
+                else if (!s.ws || s.ws.readyState !== WebSocket.OPEN) {
+                    clearTimeout(timer);
+                    clearInterval(iv);
+                    reject(new GptLiveError('GPT-Live: closed before session.started'));
+                }
+            }, 10);
+        });
+    }
+    async pipeAudio(linkedId, s, audioIn) {
+        let checked = false;
+        try {
+            for await (const chunk of audioIn) {
+                if (!s.ws || s.ws.readyState !== WebSocket.OPEN || s.closing)
+                    break;
+                if (!checked) {
+                    checked = true;
+                    // 🔴 full duplex: a mixed stream feeds the model its own voice. Warn once, keep going
+                    // (blocking the call would be worse than a degraded one).
+                    if (chunk.dir !== 'in' && !this.o.allowMixedInput) {
+                        this.errorHandler?.(new GptLiveError(`GPT-Live: input audio is not caller-only (dir=${chunk.dir}) — the model will hear its own voice. ` +
+                            "Use Stasis mode=customer and gw.streamAudio(id, { dir: 'in' }).", 'input_not_caller_only'), linkedId);
+                    }
+                }
+                const pcm = float32ToSlin16(chunk.samples);
+                this.send(s, { type: 'session.input_audio.append', audio: Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength).toString('base64') });
+            }
+        }
+        catch (e) {
+            this.errorHandler?.(e, linkedId);
+        }
+    }
+    handle(linkedId, s, ev) {
+        switch (ev.type) {
+            case 'session.started':
+                s.started = true;
+                break;
+            case 'session.output_audio.delta': {
+                if (!ev.delta)
+                    break;
+                const { out, opened, closed } = s.gate.push(Buffer.from(ev.delta, 'base64'));
+                if (opened) {
+                    this.speechActivityHandler?.({ linkedId, side: 'callee', speaking: true, timestampMs: Date.now() });
+                    // new speech after a result → the result was (very likely) said
+                    for (const d of s.delegations.values())
+                        if (d.answeredAt !== undefined && !d.spoken)
+                            this.markSpoken(d);
+                }
+                if (out.length)
+                    this.audioOutputHandler?.(out, linkedId);
+                if (closed)
+                    this.speechActivityHandler?.({ linkedId, side: 'callee', speaking: false, timestampMs: Date.now() });
+                break;
+            }
+            case 'session.input_transcript.delta':
+                this.transcriptDelta(linkedId, s, 'customer', ev);
+                break;
+            case 'session.output_transcript.delta': {
+                this.transcriptDelta(linkedId, s, 'agent', ev);
+                for (const d of s.delegations.values()) {
+                    if (d.ackStartMs !== undefined && typeof ev.start_ms === 'number' && ev.start_ms >= d.ackStartMs && !d.spoken) {
+                        d.textAfterAck += ev.delta ?? '';
+                        // a tail of the sentence that was already going («…만요.») is short — require more than that
+                        if (d.textAfterAck.replace(/\s/g, '').length >= 10)
+                            this.markSpoken(d);
+                    }
+                }
+                break;
+            }
+            case 'session.commentary.appended': {
+                const d = s.delegations.get(ev.client_event_id);
+                if (d && typeof ev.start_ms === 'number')
+                    d.ackStartMs = ev.start_ms;
+                break;
+            }
+            case 'session.delegation.created': {
+                const id = ev.delegation?.id;
+                if (!id || ev.delegation?.target !== 'client' || !this.delegationHandler)
+                    break;
+                const req = {
+                    linkedId, delegationId: id,
+                    transcript: [...s.finished],
+                    pending: s.open.customer?.text ?? '',
+                };
+                Promise.resolve(this.delegationHandler(req)).then((res) => {
+                    if (res === undefined || res === null)
+                        return;
+                    const r = typeof res === 'string' ? { speak: res } : res;
+                    if (r.note)
+                        this.appendThinking(linkedId, id, r.note);
+                    if (r.speak)
+                        this.appendCommentary(linkedId, id, r.speak);
+                }).catch((e) => this.errorHandler?.(e, linkedId));
+                break;
+            }
+            case 'response.event': {
+                const inner = ev.event ?? {};
+                if (inner.type === 'response.output_item.done' && inner.item?.type === 'function_call' && inner.item.call_id) {
+                    // the completed item carries name + call_id (arguments.done alone does not — OpenAI delegation guide)
+                    s.pendingCalls.add(inner.item.call_id);
+                    let args = {};
+                    try {
+                        args = JSON.parse(inner.item.arguments ?? '{}');
+                    }
+                    catch { /* keep empty */ }
+                    this.toolCallHandler?.({ callId: inner.item.call_id, name: inner.item.name ?? '', args, linkedId });
+                }
+                break;
+            }
+            case 'session.usage.updated':
+                if (typeof ev.usage?.seconds === 'number')
+                    s.usageSeconds = ev.usage.seconds; // cumulative — replace, never add
+                break;
+            case 'session.closed':
+                s.finalized = true;
+                s.closeReason = ev.reason;
+                if (typeof ev.usage?.seconds === 'number')
+                    s.usageSeconds = ev.usage.seconds;
+                break;
+            case 'error': {
+                const code = ev.error?.code ?? undefined;
+                const msg = redactKey(String(ev.error?.message ?? 'unknown error'));
+                this.errorHandler?.(new GptLiveError(`GPT-Live${code ? ` [${code}]` : ''}: ${msg}`, code, code !== undefined && FATAL_ERROR_CODES.has(code)), linkedId);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    transcriptDelta(linkedId, s, speaker, ev) {
+        const text = ev.delta ?? '';
+        if (!text)
+            return;
+        const pause = this.o.transcriptPauseMs ?? 800;
+        const start = typeof ev.start_ms === 'number' ? ev.start_ms : undefined;
+        const cur = s.open[speaker];
+        if (cur && start !== undefined && start - cur.lastEndMs > pause)
+            this.closeUtterance(linkedId, s, speaker);
+        const u = s.open[speaker];
+        if (!u) {
+            s.open[speaker] = { speaker, text, lastEndMs: ev.end_ms ?? start ?? 0 };
+            if (speaker === 'customer')
+                this.speechActivityHandler?.({ linkedId, side: 'caller', speaking: true, timestampMs: Date.now() });
+        }
+        else {
+            u.text += text;
+            if (typeof ev.end_ms === 'number')
+                u.lastEndMs = Math.max(u.lastEndMs, ev.end_ms);
+        }
+    }
+    closeUtterance(linkedId, s, speaker) {
+        const u = s.open[speaker];
+        if (!u)
+            return;
+        delete s.open[speaker];
+        const text = u.text.trim();
+        if (text) {
+            s.finished.push({ speaker, text });
+            this.transcriptHandler?.({ linkedId, text, isFinal: true, speaker, timestampMs: Date.now() });
+        }
+        if (speaker === 'customer')
+            this.speechActivityHandler?.({ linkedId, side: 'caller', speaking: false, timestampMs: Date.now() });
+    }
+    watchResult(linkedId, s, delegationId, eventId) {
+        const ms = this.o.unspokenResultMs ?? 5000;
+        const d = { eventId, answeredAt: Date.now(), textAfterAck: '', spoken: false };
+        s.delegations.set(eventId, d);
+        if (ms <= 0)
+            return;
+        d.timer = setTimeout(() => {
+            if (!d.spoken && this.sessions.get(linkedId) === s) {
+                this.unspokenHandler?.({ linkedId, delegationId, waitedMs: ms });
+            }
+        }, ms);
+        d.timer.unref?.();
+    }
+    markSpoken(d) {
+        d.spoken = true;
+        if (d.timer)
+            clearTimeout(d.timer);
+    }
+    finish(linkedId, s) {
+        if (this.sessions.get(linkedId) !== s)
+            return;
+        this.closeUtterance(linkedId, s, 'customer');
+        this.closeUtterance(linkedId, s, 'agent');
+        for (const d of s.delegations.values())
+            if (d.timer)
+                clearTimeout(d.timer);
+        this.sessions.delete(linkedId);
+        if (s.started) {
+            this.usageHandler?.({ linkedId, seconds: s.usageSeconds, confirmed: s.finalized, ...(s.closeReason !== undefined && { closeReason: s.closeReason }) });
+        }
+    }
+}
+//# sourceMappingURL=gpt-live.js.map