@pellux/goodvibes-sdk 1.1.0 → 1.3.0

package/dist/platform/voice/spoken-turn/controller.js

@@ -0,0 +1,448 @@
+import { summarizeError } from '../../utils/index.js';
+import { TtsTextChunker } from './text-chunker.js';
+/**
+ * How many synthesis requests may sit in the pipeline at once (synthesizing,
+ * waiting to play, or playing). 2 = the chunk being played plus ONE prefetch,
+ * so the next audio is ready the moment the current sink drains. Bounding
+ * this is what keeps a streaming answer from bursting N concurrent requests
+ * at the voice provider — ElevenLabs plans allow as few as 3 concurrent, and
+ * an unbounded burst 429s the whole turn. The SDK config schema has no tts.*
+ * key for pipeline tuning, so this is a constant by design.
+ */
+const SYNTHESIS_PIPELINE_WINDOW = 2;
+/**
+ * Upper bound for one merged synthesis request's text. The ElevenLabs
+ * provider passes request text through verbatim (no cap of its own); the API
+ * caps text per request by plan — 2,500 chars on the lowest tiers, 5,000 on
+ * most others. 1,500 stays safely under every plan while still folding a
+ * multi-paragraph answer into one or two requests.
+ */
+const SYNTHESIS_MERGE_MAX_CHARS = 1500;
+/**
+ * Backoff schedule for transient synthesis failures (429 rate/concurrency
+ * limits, transient 5xx, network drops): first retry after 1s, second after
+ * 2.5s, then the chunk is skipped honestly and the turn continues. The SDK's
+ * provider errors are plain Error strings with the HTTP status embedded — no
+ * Retry-After header is exposed — so the schedule is fixed, not server-driven.
+ */
+const SYNTHESIS_RETRY_DELAYS_MS = [1000, 2500];
+/**
+ * Source label attached to every synthesis request's metadata. Consumers may
+ * override it so provider-side telemetry attributes requests to the right
+ * surface (TUI, agent, webui).
+ */
+const DEFAULT_SYNTHESIS_SOURCE = 'goodvibes-sdk';
+/**
+ * SpokenTurnController — the shared spoken-output policy engine. It watches a
+ * turn's lifecycle events, chunks the streamed answer into speech-sized pieces,
+ * merges and dispatches synthesis requests through a bounded 2-slot window with
+ * retry/backoff, and drives an injected {@link AudioSink} with honest
+ * drain-vs-interrupt semantics. All I/O is the sink's; this class is pure
+ * policy and runs unchanged in the terminal, the agent, and the browser.
+ */
+export class SpokenTurnController {
+    pendingPrompt = null;
+    activeTurnId = null;
+    chunker = null;
+    chunkSequence = 0;
+    playbackChain = Promise.resolve();
+    abortControllers = new Set();
+    timer = null;
+    errorReportedForTurn = false;
+    noSinkNoticed = false;
+    /** Chunker output waiting to be merged into a synthesis request. */
+    pendingTexts = [];
+    /** Requests currently in the pipeline (synthesizing / waiting / playing). */
+    pipelineDepth = 0;
+    /** Bumped on every teardown so stale pipeline releases are ignored. */
+    pipelineGeneration = 0;
+    pumpScheduled = false;
+    /** Set when TURN_COMPLETED arrives; the turn releases once the pipeline drains. */
+    completedTurnId = null;
+    voiceService;
+    configManager;
+    sink;
+    notify;
+    source;
+    now;
+    setIntervalImpl;
+    clearIntervalImpl;
+    setTimeoutImpl;
+    clearTimeoutImpl;
+    constructor(options) {
+        this.voiceService = options.voiceService;
+        this.configManager = options.configManager;
+        this.sink = options.sink;
+        this.notify = options.notify;
+        this.source = options.source ?? DEFAULT_SYNTHESIS_SOURCE;
+        this.now = options.now ?? (() => Date.now());
+        this.setIntervalImpl = options.setInterval ?? setInterval;
+        this.clearIntervalImpl = options.clearInterval ?? clearInterval;
+        this.setTimeoutImpl = options.setTimeout ?? setTimeout;
+        this.clearTimeoutImpl = options.clearTimeout ?? clearTimeout;
+    }
+    submitNextTurn(prompt) {
+        const normalized = prompt.trim();
+        if (!normalized)
+            return false;
+        this.stop();
+        if (!this.sink.available) {
+            if (!this.noSinkNoticed) {
+                this.noSinkNoticed = true;
+                this.notify?.('[TTS] Text response will continue, but live audio is unavailable. Install mpv or ffplay.');
+            }
+            return false;
+        }
+        // Reset the no-sink notice if the sink becomes available again.
+        this.noSinkNoticed = false;
+        this.pendingPrompt = normalized;
+        return true;
+    }
+    /**
+     * Returns whether speech was actually ACTIVE when stopped. The notice only
+     * prints in that case — stop() on an idle controller used to notify anyway,
+     * spamming "[TTS] Spoken output stopped." on every Ctrl+C (an earlier replay
+     * fix); callers use the return to decide whether the press "did a
+     * job" (see handleCtrlC's consume-on-speech-stop).
+     */
+    stop(message) {
+        const wasActive = this.pendingPrompt !== null || this.activeTurnId !== null
+            || this.chunker !== null || this.abortControllers.size > 0;
+        this.pendingPrompt = null;
+        this.activeTurnId = null;
+        this.chunker?.reset();
+        this.chunker = null;
+        this.stopTimer();
+        this.resetPipeline();
+        for (const controller of this.abortControllers)
+            controller.abort();
+        this.abortControllers.clear();
+        this.sink.stop();
+        this.playbackChain = Promise.resolve();
+        this.errorReportedForTurn = false;
+        if (message && wasActive)
+            this.notify?.(`[TTS] ${message}`);
+        return wasActive;
+    }
+    /**
+     * Exit-path teardown: drops everything not yet audible (pending arm,
+     * buffered text, queued chunks) but lets the audio the user is already
+     * hearing finish naturally, capped at `drainTimeoutMs`, before the hard
+     * stop. Deliberate interrupts (Ctrl+C, /tts stop, turn cancel) keep their
+     * instant path through stop(); this is only for exiting the app while the
+     * final audio of a completed response is still draining.
+     */
+    async stopForExit(drainTimeoutMs = 2000) {
+        this.pendingPrompt = null;
+        this.activeTurnId = null;
+        this.chunker?.reset();
+        this.chunker = null;
+        this.stopTimer();
+        this.resetPipeline();
+        // Cancel chunks that have not started playing; the chunk currently in the
+        // sink is not in this set (its controller is released before playback).
+        for (const controller of this.abortControllers)
+            controller.abort();
+        this.abortControllers.clear();
+        await this.sink.waitForDrain(drainTimeoutMs);
+        // Backstop: anything still alive after the window is torn down hard.
+        this.stop();
+    }
+    handleTurnEvent(event) {
+        if (event.type === 'TURN_SUBMITTED') {
+            this.maybeStartTurn(event.turnId, event.prompt);
+            return;
+        }
+        if (!this.activeTurnId || event.turnId !== this.activeTurnId)
+            return;
+        if (event.type === 'STREAM_DELTA') {
+            this.queueTexts(this.chunker?.push(event.content) ?? []);
+            return;
+        }
+        if (event.type === 'STREAM_END') {
+            return;
+        }
+        if (event.type === 'TURN_COMPLETED') {
+            this.finishTurn(event.turnId);
+            return;
+        }
+        if (event.type === 'TURN_CANCEL' || event.type === 'TURN_ERROR' || event.type === 'PREFLIGHT_FAIL') {
+            this.stop(event.type === 'TURN_CANCEL' ? 'Spoken output stopped.' : 'Spoken output stopped because the turn did not complete.');
+        }
+    }
+    maybeStartTurn(turnId, prompt) {
+        if (!this.pendingPrompt)
+            return;
+        if (prompt.trim() !== this.pendingPrompt)
+            return;
+        this.pendingPrompt = null;
+        this.activeTurnId = turnId;
+        this.chunkSequence = 0;
+        this.errorReportedForTurn = false;
+        this.chunker = new TtsTextChunker({ now: this.now });
+        this.playbackChain = Promise.resolve();
+        this.resetPipeline();
+        this.startTimer();
+        this.notify?.(`[TTS] Live playback queued through ${this.sink.label}.`);
+    }
+    finishTurn(turnId) {
+        if (turnId !== this.activeTurnId)
+            return;
+        this.queueTexts(this.chunker?.flushAll() ?? []);
+        this.stopTimer();
+        this.completedTurnId = turnId;
+        // Nothing pending and nothing in flight releases immediately; otherwise
+        // the last pipeline slot to free performs the release.
+        this.maybeReleaseTurn();
+    }
+    resetPipeline() {
+        this.pendingTexts = [];
+        this.pipelineDepth = 0;
+        this.pipelineGeneration++;
+        this.completedTurnId = null;
+    }
+    startTimer() {
+        this.stopTimer();
+        this.timer = this.setIntervalImpl(() => {
+            if (!this.activeTurnId || !this.chunker)
+                return;
+            this.queueTexts(this.chunker.flushDue());
+        }, 250);
+    }
+    stopTimer() {
+        if (!this.timer)
+            return;
+        this.clearIntervalImpl(this.timer);
+        this.timer = null;
+    }
+    /**
+     * Chunker output does NOT map 1:1 to synthesis requests. Text queues here
+     * and the pump merges everything pending into one request whenever a
+     * pipeline slot is free — so the request count tracks how often the model
+     * out-paces the audio, not how many sentences it wrote. A short answer that
+     * arrives before the first pump tick is exactly one request.
+     */
+    queueTexts(chunks) {
+        for (const chunk of chunks) {
+            if (chunk.trim())
+                this.pendingTexts.push(chunk);
+        }
+        if (this.pendingTexts.length > 0)
+            this.schedulePump();
+    }
+    /**
+     * Deferred one tick so text delivered in the same synchronous burst (fast
+     * deltas, or a turn that completes instantly) coalesces into a single
+     * request instead of firing per sentence boundary.
+     */
+    schedulePump() {
+        if (this.pumpScheduled)
+            return;
+        this.pumpScheduled = true;
+        queueMicrotask(() => {
+            this.pumpScheduled = false;
+            this.pump();
+        });
+    }
+    pump() {
+        while (this.activeTurnId && this.pendingTexts.length > 0 && this.pipelineDepth < SYNTHESIS_PIPELINE_WINDOW) {
+            this.dispatchChunk(this.takeMergedText());
+        }
+        this.maybeReleaseTurn();
+    }
+    /** Merge everything pending into one request, capped at the per-request text limit. */
+    takeMergedText() {
+        let merged = '';
+        while (this.pendingTexts.length > 0) {
+            const next = this.pendingTexts[0];
+            if (!merged && next.length > SYNTHESIS_MERGE_MAX_CHARS) {
+                // A single oversized entry (e.g. a large end-of-turn flush): split at
+                // a word boundary under the per-request cap; the rest stays queued.
+                const cut = findSplitIndex(next, SYNTHESIS_MERGE_MAX_CHARS);
+                this.pendingTexts[0] = next.slice(cut).trim();
+                return next.slice(0, cut).trim();
+            }
+            if (merged && merged.length + 1 + next.length > SYNTHESIS_MERGE_MAX_CHARS)
+                break;
+            merged = merged ? `${merged} ${next}` : next;
+            this.pendingTexts.shift();
+        }
+        return merged;
+    }
+    dispatchChunk(text) {
+        const turnId = this.activeTurnId;
+        if (!turnId || !text.trim())
+            return;
+        const sequence = ++this.chunkSequence;
+        const generation = this.pipelineGeneration;
+        this.pipelineDepth++;
+        const abortController = new AbortController();
+        this.abortControllers.add(abortController);
+        const resultPromise = this.synthesizeWithRetry(text, turnId, sequence, abortController.signal)
+            .then((result) => ({ ok: true, result }))
+            .catch((error) => ({ ok: false, error }));
+        this.playbackChain = this.playbackChain.then(async () => {
+            try {
+                if (abortController.signal.aborted) {
+                    this.abortControllers.delete(abortController);
+                    return;
+                }
+                const result = await resultPromise;
+                this.abortControllers.delete(abortController);
+                // Re-check after the await: an abort that landed while synthesis was
+                // in flight (deliberate stop or exit) makes the rejection expected —
+                // it must not be reported, and it must not hard-stop a sink that may
+                // still be draining the previous chunk.
+                if (abortController.signal.aborted)
+                    return;
+                if (!result.ok) {
+                    // Retries are exhausted (or the failure was not transient). Skip
+                    // just this chunk and keep speaking the rest of the turn — a gap in
+                    // speech beats losing the whole response.
+                    this.reportSkippedChunk(result.error);
+                    return;
+                }
+                await this.sink.play(result.result.chunks, {
+                    format: String(result.result.format ?? 'mp3'),
+                    signal: abortController.signal,
+                });
+            }
+            finally {
+                this.releasePipelineSlot(generation);
+            }
+        }).catch((error) => {
+            this.abortControllers.delete(abortController);
+            this.reportError(error);
+        });
+    }
+    releasePipelineSlot(generation) {
+        if (generation !== this.pipelineGeneration)
+            return;
+        this.pipelineDepth = Math.max(0, this.pipelineDepth - 1);
+        if (this.pendingTexts.length > 0) {
+            this.schedulePump();
+            return;
+        }
+        this.maybeReleaseTurn();
+    }
+    maybeReleaseTurn() {
+        if (!this.completedTurnId || this.completedTurnId !== this.activeTurnId)
+            return;
+        if (this.pendingTexts.length > 0 || this.pipelineDepth > 0 || this.pumpScheduled)
+            return;
+        this.activeTurnId = null;
+        this.completedTurnId = null;
+        this.chunker = null;
+        this.abortControllers.clear();
+    }
+    async synthesizeWithRetry(text, turnId, sequence, signal) {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await this.synthesize(text, turnId, sequence, signal);
+            }
+            catch (error) {
+                const retryable = attempt < SYNTHESIS_RETRY_DELAYS_MS.length
+                    && !signal.aborted
+                    && isTransientSynthesisError(error);
+                if (!retryable)
+                    throw error;
+                await this.delay(SYNTHESIS_RETRY_DELAYS_MS[attempt], signal);
+            }
+        }
+    }
+    /** Abortable backoff sleep — an abort clears the timer and rejects, so a stop mid-backoff leaves nothing running. */
+    delay(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal.aborted) {
+                reject(new Error('Synthesis retry cancelled'));
+                return;
+            }
+            const timer = this.setTimeoutImpl(() => {
+                signal.removeEventListener('abort', onAbort);
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                this.clearTimeoutImpl(timer);
+                reject(new Error('Synthesis retry cancelled'));
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    synthesize(text, turnId, sequence, signal) {
+        return this.voiceService.synthesizeStream(readOptionalConfigString(this.configManager, 'tts.provider'), {
+            text,
+            voiceId: readOptionalConfigString(this.configManager, 'tts.voice'),
+            format: 'mp3',
+            speed: readOptionalConfigNumber(this.configManager, 'tts.speed'),
+            signal,
+            metadata: {
+                source: this.source,
+                feature: 'live-tts',
+                turnId,
+                sequence,
+            },
+        });
+    }
+    /**
+     * One synthesis request failed after its retries. Report once per turn and
+     * keep going — the rest of the response still plays.
+     */
+    reportSkippedChunk(error) {
+        if (this.errorReportedForTurn)
+            return;
+        this.errorReportedForTurn = true;
+        this.notify?.(`[TTS] Skipping part of the spoken response — synthesis kept failing (${summarizeError(error)}). Playback continues with the rest.`);
+    }
+    reportError(error) {
+        if (this.errorReportedForTurn)
+            return;
+        this.errorReportedForTurn = true;
+        this.activeTurnId = null;
+        this.chunker = null;
+        this.stopTimer();
+        this.resetPipeline();
+        for (const controller of this.abortControllers)
+            controller.abort();
+        this.abortControllers.clear();
+        this.sink.stop();
+        this.playbackChain = Promise.resolve();
+        this.notify?.(`[TTS] Live playback stopped: ${summarizeError(error)}`);
+    }
+}
+/**
+ * Transient = worth a bounded retry: rate/concurrency limits (HTTP 429),
+ * transient server errors (5xx), and network-level drops. The SDK's voice
+ * providers throw plain Error strings with the HTTP status embedded in the
+ * message, so classification is by message content.
+ */
+function isTransientSynthesisError(error) {
+    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    if (message.includes('429') || message.includes('rate limit') || message.includes('rate_limit')
+        || message.includes('too many requests') || message.includes('concurrent'))
+        return true;
+    if (/http 5\d\d/.test(message))
+        return true;
+    return message.includes('fetch failed') || message.includes('network')
+        || message.includes('timed out') || message.includes('timeout')
+        || message.includes('econnreset') || message.includes('socket');
+}
+/** Split point at or under `limit`, preferring the last word boundary. */
+function findSplitIndex(text, limit) {
+    const space = text.lastIndexOf(' ', limit);
+    return space > 0 ? space : limit;
+}
+function readOptionalConfigString(configManager, key) {
+    const value = String(configManager.get(key) ?? '').trim();
+    return value || undefined;
+}
+/**
+ * readOptionalConfigNumber — reads a numeric config value by key.
+ *
+ * Accepts a string key and casts it, returning undefined when the value is
+ * absent, zero, or not a finite positive number.
+ */
+function readOptionalConfigNumber(configManager, key) {
+    const raw = configManager.get(key);
+    const value = typeof raw === 'number' ? raw : parseFloat(String(raw ?? ''));
+    return isFinite(value) && value > 0 ? value : undefined;
+}

package/dist/platform/voice/spoken-turn/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Spoken-turn — the shared spoken-output (live TTS) policy engine.
+ *
+ * SDK owns POLICY: the sentence chunker, the bounded 2-slot synthesis window
+ * with merge coalescing, the transient-failure retry/backoff with honest
+ * skip-and-continue, and the turn-lifecycle state machine with drain-vs-
+ * interrupt semantics. Consumers own I/O by supplying an {@link AudioSink}
+ * (a terminal subprocess player, a browser Web Audio sink, or a test fake) and,
+ * where they run their own scheduler, injectable clocks/timers.
+ */
+export { SpokenTurnController } from './controller.js';
+export type { SpokenTurnControllerOptions } from './controller.js';
+export { TtsTextChunker, normalizeSpeechText } from './text-chunker.js';
+export type { TtsTextChunkerOptions } from './text-chunker.js';
+export type { AudioSink, AudioSinkPlaybackOptions } from './audio-sink.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/voice/spoken-turn/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/voice/spoken-turn/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,YAAY,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxE,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/platform/voice/spoken-turn/index.js

@@ -0,0 +1,12 @@
+/**
+ * Spoken-turn — the shared spoken-output (live TTS) policy engine.
+ *
+ * SDK owns POLICY: the sentence chunker, the bounded 2-slot synthesis window
+ * with merge coalescing, the transient-failure retry/backoff with honest
+ * skip-and-continue, and the turn-lifecycle state machine with drain-vs-
+ * interrupt semantics. Consumers own I/O by supplying an {@link AudioSink}
+ * (a terminal subprocess player, a browser Web Audio sink, or a test fake) and,
+ * where they run their own scheduler, injectable clocks/timers.
+ */
+export { SpokenTurnController } from './controller.js';
+export { TtsTextChunker, normalizeSpeechText } from './text-chunker.js';

package/dist/platform/voice/spoken-turn/text-chunker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * TtsTextChunker — turns a stream of provider content deltas into speech-sized
+ * chunks at sentence boundaries, with a max-length cut and a latency flush so a
+ * long unpunctuated run still starts speaking. This is pure policy (no I/O, no
+ * timers of its own — the caller drives `flushDue()` on its own clock), so it
+ * lives in the SDK and is shared verbatim by every voice consumer.
+ */
+export interface TtsTextChunkerOptions {
+    readonly minBoundaryChars?: number | undefined;
+    readonly maxChunkChars?: number | undefined;
+    readonly maxLatencyMs?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+export declare class TtsTextChunker {
+    private buffer;
+    private firstBufferedAt;
+    private readonly minBoundaryChars;
+    private readonly maxChunkChars;
+    private readonly maxLatencyMs;
+    private readonly now;
+    constructor(options?: TtsTextChunkerOptions);
+    push(delta: string): string[];
+    flushDue(): string[];
+    flushAll(): string[];
+    reset(): void;
+    private drainReady;
+    private findBoundary;
+    private findLatestSentenceBoundary;
+    private findWordBoundaryBefore;
+    private takeChunk;
+}
+export declare function normalizeSpeechText(text: string): string;
+//# sourceMappingURL=text-chunker.d.ts.map

package/dist/platform/voice/spoken-turn/text-chunker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-chunker.d.ts","sourceRoot":"","sources":["../../../../src/platform/voice/spoken-turn/text-chunker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEvB,OAAO,GAAE,qBAA0B;IAO/C,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAO7B,QAAQ,IAAI,MAAM,EAAE;IAMpB,QAAQ,IAAI,MAAM,EAAE;IASpB,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,0BAA0B;IAelC,OAAO,CAAC,sBAAsB;IAQ9B,OAAO,CAAC,SAAS;CAMlB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/dist/platform/voice/spoken-turn/text-chunker.js

@@ -0,0 +1,97 @@
+export class TtsTextChunker {
+    buffer = '';
+    firstBufferedAt = null;
+    minBoundaryChars;
+    maxChunkChars;
+    maxLatencyMs;
+    now;
+    constructor(options = {}) {
+        this.minBoundaryChars = options.minBoundaryChars ?? 24;
+        this.maxChunkChars = options.maxChunkChars ?? 320;
+        this.maxLatencyMs = options.maxLatencyMs ?? 1_000;
+        this.now = options.now ?? (() => Date.now());
+    }
+    push(delta) {
+        if (!delta)
+            return [];
+        if (this.firstBufferedAt === null)
+            this.firstBufferedAt = this.now();
+        this.buffer += delta;
+        return this.drainReady(false);
+    }
+    flushDue() {
+        if (!this.buffer.trim() || this.firstBufferedAt === null)
+            return [];
+        if (this.now() - this.firstBufferedAt < this.maxLatencyMs)
+            return [];
+        return this.drainReady(true);
+    }
+    flushAll() {
+        if (!this.buffer.trim()) {
+            this.buffer = '';
+            this.firstBufferedAt = null;
+            return [];
+        }
+        return [this.takeChunk(this.buffer.length)].filter(Boolean);
+    }
+    reset() {
+        this.buffer = '';
+        this.firstBufferedAt = null;
+    }
+    drainReady(forceLatencyFlush) {
+        const chunks = [];
+        while (this.buffer.trim()) {
+            const boundary = this.findBoundary(forceLatencyFlush);
+            if (boundary <= 0)
+                break;
+            const chunk = this.takeChunk(boundary);
+            if (chunk)
+                chunks.push(chunk);
+            forceLatencyFlush = false;
+        }
+        return chunks;
+    }
+    findBoundary(forceLatencyFlush) {
+        const latestSentence = this.findLatestSentenceBoundary();
+        if (latestSentence >= this.minBoundaryChars)
+            return latestSentence;
+        if (this.buffer.length >= this.maxChunkChars) {
+            return this.findWordBoundaryBefore(this.maxChunkChars) || this.maxChunkChars;
+        }
+        if (forceLatencyFlush) {
+            return this.buffer.length;
+        }
+        return -1;
+    }
+    findLatestSentenceBoundary() {
+        let best = -1;
+        for (let i = 0; i < this.buffer.length; i++) {
+            const char = this.buffer[i];
+            if (char !== '.' && char !== '!' && char !== '?' && char !== ';' && char !== ':' && char !== '\n') {
+                continue;
+            }
+            const next = this.buffer[i + 1];
+            if (i === this.buffer.length - 1 || next === undefined || /\s/.test(next)) {
+                best = i + 1;
+            }
+        }
+        return best;
+    }
+    findWordBoundaryBefore(index) {
+        const max = Math.min(index, this.buffer.length);
+        for (let i = max; i > 0; i--) {
+            if (/\s/.test(this.buffer[i - 1] ?? ''))
+                return i;
+        }
+        return -1;
+    }
+    takeChunk(end) {
+        const raw = this.buffer.slice(0, end);
+        this.buffer = this.buffer.slice(end);
+        this.firstBufferedAt = this.buffer.trim() ? this.now() : null;
+        return normalizeSpeechText(raw);
+    }
+}
+export function normalizeSpeechText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-sdk",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "TypeScript SDK for building GoodVibes operator, peer, web, mobile, and daemon-connected apps with typed contracts, auth, realtime events, and transport layers.",
   "keywords": [
     "goodvibes",
@@ -477,14 +477,14 @@
   "sideEffects": false,
   "type": "module",
   "dependencies": {
-    "@pellux/goodvibes-contracts": "1.1.0",
-    "@pellux/goodvibes-daemon-sdk": "1.1.0",
-    "@pellux/goodvibes-errors": "1.1.0",
-    "@pellux/goodvibes-operator-sdk": "1.1.0",
-    "@pellux/goodvibes-peer-sdk": "1.1.0",
-    "@pellux/goodvibes-transport-core": "1.1.0",
-    "@pellux/goodvibes-transport-http": "1.1.0",
-    "@pellux/goodvibes-transport-realtime": "1.1.0"
+    "@pellux/goodvibes-contracts": "1.3.0",
+    "@pellux/goodvibes-daemon-sdk": "1.3.0",
+    "@pellux/goodvibes-errors": "1.3.0",
+    "@pellux/goodvibes-operator-sdk": "1.3.0",
+    "@pellux/goodvibes-peer-sdk": "1.3.0",
+    "@pellux/goodvibes-transport-core": "1.3.0",
+    "@pellux/goodvibes-transport-http": "1.3.0",
+    "@pellux/goodvibes-transport-realtime": "1.3.0"
   },
   "optionalDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",