opencode-interrupt-plugin 0.3.1 → 0.4.1

package/dist/audio/monitor.d.ts

@@ -1,13 +1,12 @@
 import { EventEmitter } from 'events';
 export declare class AudioMonitor extends EventEmitter {
-    private process;
+    private pollTimer;
     private isRunning;
-    private silenceTimer;
     private threshold;
-    private silenceMs;
-    constructor(threshold?: number, silenceMs?: number);
+    private pollMs;
+    constructor(threshold?: number, pollMs?: number);
     start(): void;
-    private tryFallbackMonitor;
+    private poll;
     stop(): void;
     private handleRMS;
     setThreshold(threshold: number): void;

package/dist/audio/monitor.js

@@ -1,96 +1,60 @@
 import { spawn } from 'child_process';
 import { EventEmitter } from 'events';
 export class AudioMonitor extends EventEmitter {
-    process = null;
+    pollTimer = null;
     isRunning = false;
-    silenceTimer = null;
     threshold;
-    silenceMs;
-    constructor(threshold = 0.02, silenceMs = 300) {
+    pollMs;
+    constructor(threshold = 0.02, pollMs = 100) {
         super();
         this.threshold = threshold;
-        this.silenceMs = silenceMs;
+        this.pollMs = pollMs;
     }
     start() {
         if (this.isRunning)
             return;
-        this.process = spawn('sox', [
-            '-q',
-            '-d',
+        this.isRunning = true;
+        this.emit('started');
+        this.poll();
+    }
+    poll() {
+        if (!this.isRunning)
+            return;
+        const proc = spawn('sox', [
+            '-q', '-d',
             '-t', 'sox', '-',
+            'trim', '0', '0.1',
             'stat',
-            '-freq',
-        ], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        let buffer = '';
-        this.process.stderr?.on('data', (chunk) => {
-            buffer += chunk.toString();
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                const rms = parseRMSLine(line);
-                if (rms !== null) {
-                    this.handleRMS(rms);
-                }
+        ], { stdio: ['ignore', 'ignore', 'pipe'] });
+        let out = '';
+        proc.stderr?.on('data', (d) => { out += d.toString(); });
+        proc.on('exit', () => {
+            if (!this.isRunning)
+                return;
+            const rms = parseRMSFromStat(out);
+            if (rms !== null) {
+                this.handleRMS(rms);
             }
+            this.pollTimer = setTimeout(() => this.poll(), this.pollMs);
         });
-        this.process.on('error', () => {
-            this.tryFallbackMonitor();
-        });
-        this.process.on('exit', () => {
-            this.isRunning = false;
-            this.emit('stopped');
-        });
-        this.isRunning = true;
-        this.emit('started');
-    }
-    tryFallbackMonitor() {
-        const poll = () => {
+        proc.on('error', () => {
             if (!this.isRunning)
                 return;
-            const proc = spawn('sox', [
-                '-q', '-d',
-                '-t', 'sox', '-',
-                'trim', '0', '0.1',
-                'stat',
-            ], { stdio: ['ignore', 'ignore', 'pipe'] });
-            let out = '';
-            proc.stderr?.on('data', (d) => { out += d.toString(); });
-            proc.on('exit', () => {
-                const rms = parseRMSFromStat(out);
-                if (rms !== null)
-                    this.handleRMS(rms);
-                setTimeout(poll, 100);
-            });
-            proc.on('error', () => {
-                this.emit('error', new Error('sox not found. Install it: brew install sox (macOS) or apt install sox (Linux)'));
-                this.isRunning = false;
-            });
-        };
-        this.isRunning = true;
-        poll();
+            this.emit('error', new Error('sox not found. Install it: brew install sox (macOS) or apt install sox (Linux)'));
+            this.isRunning = false;
+        });
     }
     stop() {
         this.isRunning = false;
-        if (this.process) {
-            this.process.kill('SIGTERM');
-            this.process = null;
-        }
-        if (this.silenceTimer) {
-            clearTimeout(this.silenceTimer);
-            this.silenceTimer = null;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
         }
         this.emit('stopped');
     }
     handleRMS(rms) {
         if (rms > this.threshold) {
             this.emit('voice-detected', rms);
-            if (this.silenceTimer)
-                clearTimeout(this.silenceTimer);
-            this.silenceTimer = setTimeout(() => {
-                this.emit('silence');
-            }, this.silenceMs);
         }
     }
     setThreshold(threshold) {

package/dist/audio/overlap.d.ts

@@ -9,7 +9,10 @@ export declare class VoiceOverlapDetector extends EventEmitter {
     private active;
     private cooldownUntil;
     private readonly COOLDOWN_MS;
-    constructor(threshold?: number);
+    private getIsTTSPlaying;
+    private stopTTS;
+    private getPartialContent;
+    constructor(threshold?: number, getIsTTSPlaying?: () => boolean, stopTTS?: () => void, getPartialContent?: () => string);
     start(): void;
     stop(): void;
     updateThreshold(threshold: number): void;

package/dist/audio/overlap.js

@@ -1,14 +1,19 @@
 import { AudioMonitor } from './monitor.js';
-import { isTTSPlaying, getPartialTTSContent, onTTSEnd } from './tts-tracker.js';
 import { EventEmitter } from 'events';
 export class VoiceOverlapDetector extends EventEmitter {
     monitor;
     active = false;
     cooldownUntil = 0;
     COOLDOWN_MS = 3000;
-    constructor(threshold = 0.02) {
+    getIsTTSPlaying;
+    stopTTS;
+    getPartialContent;
+    constructor(threshold = 0.02, getIsTTSPlaying = () => false, stopTTS = () => { }, getPartialContent = () => '') {
         super();
         this.monitor = new AudioMonitor(threshold);
+        this.getIsTTSPlaying = getIsTTSPlaying;
+        this.stopTTS = stopTTS;
+        this.getPartialContent = getPartialContent;
         this.monitor.on('voice-detected', (rms) => {
             this.handleVoiceDetected(rms);
         });
@@ -30,14 +35,14 @@ export class VoiceOverlapDetector extends EventEmitter {
         this.monitor.setThreshold(threshold);
     }
     handleVoiceDetected(rms) {
-        if (!isTTSPlaying())
+        if (!this.getIsTTSPlaying())
             return;
         if (Date.now() < this.cooldownUntil)
             return;
         const now = Date.now();
         this.cooldownUntil = now + this.COOLDOWN_MS;
-        const partialContent = getPartialTTSContent(now);
-        onTTSEnd();
+        const partialContent = this.getPartialContent();
+        this.stopTTS();
         const event = {
             partialTTSContent: partialContent,
             overlapTimestamp: now,

package/dist/audio/tts-tracker.d.ts

@@ -1,11 +1,8 @@
 export interface TTSState {
     isPlaying: boolean;
     startedAt: number;
-    content: string;
-    estimatedDurationMs: number;
 }
-export declare function onTTSStart(content: string): void;
+export declare function onTTSStart(): void;
 export declare function onTTSEnd(): void;
 export declare function isTTSPlaying(): boolean;
 export declare function isTTSTool(toolName: string): boolean;
-export declare function getPartialTTSContent(elapsedMs: number): string;

package/dist/audio/tts-tracker.js

@@ -1,25 +1,10 @@
-const TTS_TOOL_NAMES = new Set(['speak', 'tts', 'text_to_speech', 'say']);
 const ttsState = {
     isPlaying: false,
     startedAt: 0,
-    content: '',
-    estimatedDurationMs: 0,
 };
-function estimateDuration(text) {
-    const words = text.split(/\s+/).length;
-    const durationMs = (words / 2.5) * 1000;
-    return Math.max(500, Math.min(120000, durationMs));
-}
-export function onTTSStart(content) {
+export function onTTSStart() {
     ttsState.isPlaying = true;
     ttsState.startedAt = Date.now();
-    ttsState.content = content;
-    ttsState.estimatedDurationMs = estimateDuration(content);
-    setTimeout(() => {
-        if (ttsState.isPlaying && Date.now() - ttsState.startedAt > ttsState.estimatedDurationMs) {
-            ttsState.isPlaying = false;
-        }
-    }, ttsState.estimatedDurationMs + 2000);
 }
 export function onTTSEnd() {
     ttsState.isPlaying = false;
@@ -28,10 +13,5 @@ export function isTTSPlaying() {
     return ttsState.isPlaying;
 }
 export function isTTSTool(toolName) {
-    return TTS_TOOL_NAMES.has(toolName.toLowerCase());
-}
-export function getPartialTTSContent(elapsedMs) {
-    const progress = Math.min(elapsedMs / ttsState.estimatedDurationMs, 0.95);
-    const charIndex = Math.floor(ttsState.content.length * progress);
-    return ttsState.content.slice(0, charIndex) + '...[interrupted]';
+    return ['speak', 'tts', 'text_to_speech', 'say'].includes(toolName.toLowerCase());
 }

package/dist/config.d.ts

@@ -7,6 +7,9 @@ export interface PluginConfig {
     minResponseLength?: number;
     voiceDetection?: boolean;
     debug?: boolean;
+    tts?: boolean;
+    ttsVoice?: string;
+    ttsRate?: string;
 }
 export interface ResolvedConfig {
     licenseKey?: string;
@@ -19,6 +22,9 @@ export interface ResolvedConfig {
     voiceDetection: boolean;
     voiceMode: string;
     debug: boolean;
+    tts: boolean;
+    ttsVoice: string;
+    ttsRate: string;
 }
 export declare const FREE_DEFAULTS: ResolvedConfig;
 export declare const SENSITIVITY_PRESETS: Record<string, Partial<ResolvedConfig>>;

package/dist/config.js

@@ -1,3 +1,5 @@
+const DEFAULT_TTS_VOICE = "en-US-AvaNeural";
+const DEFAULT_TTS_RATE = "+25%";
 export const FREE_DEFAULTS = {
     isLicensed: false,
     micThreshold: 0.02,
@@ -8,6 +10,9 @@ export const FREE_DEFAULTS = {
     voiceDetection: true,
     voiceMode: 'enabled',
     debug: false,
+    tts: true,
+    ttsVoice: DEFAULT_TTS_VOICE,
+    ttsRate: DEFAULT_TTS_RATE,
 };
 export const SENSITIVITY_PRESETS = {
     low: {
@@ -41,6 +46,9 @@ export function resolveConfig(userConfig, isLicensed) {
         voiceDetection: userConfig.voiceDetection ?? FREE_DEFAULTS.voiceDetection,
         debug: userConfig.debug ?? FREE_DEFAULTS.debug,
         licenseKey: userConfig.licenseKey,
+        tts: userConfig.tts ?? FREE_DEFAULTS.tts,
+        ttsVoice: userConfig.ttsVoice ?? FREE_DEFAULTS.ttsVoice,
+        ttsRate: userConfig.ttsRate ?? FREE_DEFAULTS.ttsRate,
     };
     const preset = SENSITIVITY_PRESETS[base.sensitivity];
     if (!userConfig.timingWindowMs)

package/dist/index.js

@@ -5,7 +5,13 @@ import { prepareInjection } from './injector.js';
 import { onTTSStart, onTTSEnd, isTTSTool } from './audio/tts-tracker.js';
 import { VoiceOverlapDetector } from './audio/overlap.js';
 import { detectTextInterruption } from './detector.js';
+import { TTSStreamer } from './tts/index.js';
 let activeSessionId = null;
+const TTS_COMMANDS = [
+    { name: 'tts-on', description: 'Enable streaming TTS', template: 'TTS enabled.' },
+    { name: 'tts-off', description: 'Disable streaming TTS', template: 'TTS disabled.' },
+    { name: 'tts-speak', description: 'Speak text immediately', template: '$ARGUMENTS' },
+];
 export const InterruptPlugin = (userConfig = {}) => {
     return async ({ client }) => {
         const licenseResult = await checkLicense(userConfig.licenseKey);
@@ -17,12 +23,36 @@ export const InterruptPlugin = (userConfig = {}) => {
             console.log('\n[interrupt] Free mode — voice interruption enabled with default settings.\n' +
                 '  Purchase a license at camaramagic.com to customize sensitivity, mic threshold, and more.\n');
         }
-        const overlapDetector = new VoiceOverlapDetector(config.micThreshold);
+        if (config.tts) {
+            if (config.debug) {
+                console.log(`[interrupt] Streaming TTS enabled (voice: ${config.ttsVoice}, rate: ${config.ttsRate})`);
+            }
+        }
+        const ttsStreamer = new TTSStreamer({
+            enabled: config.tts,
+            voice: config.ttsVoice,
+            rate: config.ttsRate,
+        });
+        ttsStreamer.on('tts-start', () => {
+            onTTSStart();
+        });
+        ttsStreamer.on('tts-end', () => {
+            onTTSEnd();
+        });
+        ttsStreamer.on('tts-error', (err) => {
+            if (config.debug) {
+                console.error(`[interrupt] TTS error: ${err}`);
+            }
+        });
+        const overlapDetector = new VoiceOverlapDetector(config.micThreshold, () => ttsStreamer.isPlaying(), () => {
+            ttsStreamer.stop();
+            onTTSEnd();
+        }, () => ttsStreamer.getPartialContent());
         overlapDetector.on('voice-overlap', (event) => {
             if (!activeSessionId)
                 return;
             if (config.debug) {
-                console.log(`[interrupt] Voice overlap (RMS: ${event.rmsLevel.toFixed(4)})`);
+                console.log(`[interrupt] Voice overlap detected (RMS: ${event.rmsLevel.toFixed(4)})`);
             }
             updateSessionState(activeSessionId, {
                 wasInterrupted: true,
@@ -42,16 +72,35 @@ export const InterruptPlugin = (userConfig = {}) => {
         return {
             event: async ({ event }) => {
                 const evt = event;
-                const sessionId = evt.session_id || evt.properties?.info?.id;
+                const sessionId = evt.session_id || evt.properties?.info?.id || evt.properties?.sessionID;
                 if (evt.type === 'session.created' && sessionId) {
                     activeSessionId = sessionId;
                     getSessionState(sessionId);
+                    ttsStreamer.resetSession();
                 }
                 if (evt.type === 'session.deleted' && sessionId) {
                     clearSessionState(sessionId);
+                    ttsStreamer.resetSession();
                     if (activeSessionId === sessionId)
                         activeSessionId = null;
                 }
+                if (evt.type === 'message.part.updated') {
+                    const part = evt.properties?.part;
+                    if (part && part.type === 'text' && part.text) {
+                        if (config.tts) {
+                            ttsStreamer.onTextChunk({
+                                messageID: part.messageID,
+                                type: part.type,
+                                text: part.text,
+                            });
+                        }
+                    }
+                }
+                if (evt.type === 'session.idle') {
+                    if (config.tts) {
+                        await ttsStreamer.flush();
+                    }
+                }
             },
             'chat.message': async (input, output) => {
                 const sessionId = input.sessionID;
@@ -110,12 +159,41 @@ export const InterruptPlugin = (userConfig = {}) => {
                     });
                 }
             },
+            config: async (input) => {
+                if (!input.command)
+                    input.command = {};
+                for (const cmd of TTS_COMMANDS) {
+                    input.command[cmd.name] = {
+                        description: cmd.description,
+                        template: cmd.template,
+                    };
+                }
+            },
+            'command.execute.before': async (cmdInput) => {
+                if (!cmdInput.command.startsWith('tts-'))
+                    return;
+                if (cmdInput.command === 'tts-on') {
+                    ttsStreamer.enable();
+                    throw new Error('Command handled by interrupt plugin');
+                }
+                if (cmdInput.command === 'tts-off') {
+                    ttsStreamer.disable();
+                    throw new Error('Command handled by interrupt plugin');
+                }
+                if (cmdInput.command === 'tts-speak') {
+                    const text = cmdInput.arguments.trim();
+                    if (text) {
+                        ttsStreamer.speakNow(text);
+                    }
+                    throw new Error('Command handled by interrupt plugin');
+                }
+            },
             'tool.execute.before': async (input, output) => {
                 const toolName = input.tool || '';
                 const args = output?.args || {};
                 if (isTTSTool(toolName)) {
                     const text = args.text || args.content || '';
-                    onTTSStart(text);
+                    onTTSStart();
                 }
             },
             'tool.execute.after': async (input, output) => {

package/dist/tts/buffer.d.ts

@@ -0,0 +1,12 @@
+export declare class SentenceBuffer {
+    private buffer;
+    private processedLength;
+    feed(chunk: {
+        messageID: string;
+        type: string;
+        text: string;
+    }): string[];
+    flush(): string;
+    clear(): void;
+    get length(): number;
+}

package/dist/tts/buffer.js

@@ -0,0 +1,44 @@
+export class SentenceBuffer {
+    buffer = "";
+    processedLength = new Map();
+    feed(chunk) {
+        if (chunk.type !== "text")
+            return [];
+        const lastLen = this.processedLength.get(chunk.messageID) ?? 0;
+        if (chunk.text.length <= lastLen)
+            return [];
+        const delta = chunk.text.slice(lastLen);
+        this.processedLength.set(chunk.messageID, chunk.text.length);
+        this.buffer += delta;
+        const sentences = [];
+        const re = /[.!?](?:\s|$)/g;
+        let match;
+        while ((match = re.exec(this.buffer)) !== null) {
+            const end = match.index + match[0].length;
+            const sentence = this.buffer.slice(0, end).trim();
+            if (sentence)
+                sentences.push(sentence);
+            this.buffer = this.buffer.slice(end).trim();
+            re.lastIndex = 0;
+        }
+        if (this.buffer.length >= 120) {
+            const forced = this.buffer.trim();
+            if (forced)
+                sentences.push(forced);
+            this.buffer = "";
+        }
+        return sentences;
+    }
+    flush() {
+        const remaining = this.buffer.trim();
+        this.buffer = "";
+        return remaining;
+    }
+    clear() {
+        this.buffer = "";
+        this.processedLength.clear();
+    }
+    get length() {
+        return this.buffer.length;
+    }
+}

package/dist/tts/engine.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from "events";
+export interface TTSEngineOptions {
+    voice?: string;
+    rate?: string;
+    volume?: string;
+}
+export declare class TTSEngine extends EventEmitter {
+    private player;
+    private generator;
+    private playing;
+    private voice;
+    private rate;
+    private volume;
+    constructor(options?: TTSEngineOptions);
+    speak(text: string): Promise<void>;
+    stop(): void;
+    get isPlaying(): boolean;
+}

package/dist/tts/engine.js

@@ -0,0 +1,94 @@
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import { join } from "path";
+const VENV_PYTHON = join(process.env.HOME || "/home/pystar", ".config", "opencode", "tts-venv", "bin", "python");
+const DEFAULT_VOICE = "en-US-AvaNeural";
+const DEFAULT_RATE = "+25%";
+const DEFAULT_VOLUME = "+0%";
+export class TTSEngine extends EventEmitter {
+    player = null;
+    generator = null;
+    playing = false;
+    voice;
+    rate;
+    volume;
+    constructor(options = {}) {
+        super();
+        this.voice = options.voice ?? DEFAULT_VOICE;
+        this.rate = options.rate ?? DEFAULT_RATE;
+        this.volume = options.volume ?? DEFAULT_VOLUME;
+    }
+    speak(text) {
+        if (!text.trim())
+            return Promise.resolve();
+        const t0 = Date.now();
+        return new Promise((resolve, reject) => {
+            this.generator = spawn(VENV_PYTHON, [
+                "-m", "edge_tts",
+                "--voice", this.voice,
+                "--rate", this.rate,
+                "--volume", this.volume,
+                "--text", text,
+            ], { stdio: ["ignore", "pipe", "pipe"] });
+            this.player = spawn("ffplay", [
+                "-nodisp", "-autoexit", "-loglevel", "quiet", "-i", "-",
+            ], { stdio: ["pipe", "ignore", "ignore"] });
+            this.generator.stdout.pipe(this.player.stdin);
+            this.playing = true;
+            this.emit("playback-start");
+            let genDone = false;
+            let playDone = false;
+            const checkDone = () => {
+                if (genDone && playDone) {
+                    console.log(`[interrupt-tts] stream done text="${text.slice(0, 60)}" total=${Date.now() - t0}ms`);
+                    resolve();
+                }
+            };
+            this.generator.on("close", (code) => {
+                genDone = true;
+                if (code !== 0) {
+                    console.log(`[interrupt-tts] edge-tts exited ${code}`);
+                }
+                checkDone();
+            });
+            this.generator.on("error", (err) => {
+                genDone = true;
+                this.emit("error", `edge-tts: ${err.message}`);
+                if (this.player) {
+                    this.player.kill();
+                    this.player = null;
+                }
+                this.playing = false;
+                reject(err);
+            });
+            this.player.on("close", (code) => {
+                playDone = true;
+                this.player = null;
+                this.playing = false;
+                this.emit("playback-end", { interrupted: false });
+                checkDone();
+            });
+            this.player.on("error", () => {
+                playDone = true;
+                this.player = null;
+                this.playing = false;
+                this.emit("playback-end", { interrupted: false });
+                reject(new Error("ffplay not found. Install ffmpeg."));
+            });
+        });
+    }
+    stop() {
+        if (this.generator) {
+            this.generator.kill("SIGTERM");
+            this.generator = null;
+        }
+        if (this.player) {
+            this.player.kill("SIGTERM");
+            this.player = null;
+        }
+        this.playing = false;
+    }
+    get isPlaying() {
+        return this.playing;
+    }
+}

package/dist/tts/index.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from "events";
+export interface TTSStreamerOptions {
+    enabled?: boolean;
+    voice?: string;
+    rate?: string;
+    volume?: string;
+}
+export declare class TTSStreamer extends EventEmitter {
+    private buffer;
+    private engine;
+    private queue;
+    private processing;
+    private stopped;
+    private spokenText;
+    private enabled;
+    private forceTimer;
+    private readonly FORCE_FLUSH_MS;
+    private lastActivity;
+    constructor(options?: TTSStreamerOptions);
+    onTextChunk(chunk: {
+        messageID: string;
+        type: string;
+        text: string;
+    }): void;
+    private scheduleForceFlush;
+    private cancelForceFlush;
+    flush(): Promise<void>;
+    speakNow(text: string): void;
+    stop(): void;
+    disable(): void;
+    enable(): void;
+    getPartialContent(): string;
+    isPlaying(): boolean;
+    resetSession(): void;
+    private processQueue;
+}

package/dist/tts/index.js

@@ -0,0 +1,147 @@
+import { EventEmitter } from "events";
+import { SentenceBuffer } from "./buffer.js";
+import { TTSEngine } from "./engine.js";
+export class TTSStreamer extends EventEmitter {
+    buffer = new SentenceBuffer();
+    engine;
+    queue = [];
+    processing = false;
+    stopped = false;
+    spokenText = "";
+    enabled;
+    forceTimer = null;
+    FORCE_FLUSH_MS = 1500;
+    lastActivity = 0;
+    constructor(options = {}) {
+        super();
+        this.enabled = options.enabled !== false;
+        this.engine = new TTSEngine({
+            voice: options.voice,
+            rate: options.rate,
+            volume: options.volume,
+        });
+        this.engine.on("playback-start", () => {
+            this.lastActivity = Date.now();
+            this.emit("tts-start");
+        });
+        this.engine.on("playback-end", ({ interrupted }) => {
+            this.emit("tts-end", { interrupted });
+        });
+        this.engine.on("error", (err) => {
+            this.emit("tts-error", err);
+        });
+    }
+    onTextChunk(chunk) {
+        if (!this.enabled)
+            return;
+        this.lastActivity = Date.now();
+        const sentences = this.buffer.feed(chunk);
+        console.log(`[interrupt-tts] chunk len=${chunk.text.length} sentences=${sentences.length} queue=${this.queue.length} processing=${this.processing} buflen=${this.buffer.length}`);
+        if (sentences.length > 0) {
+            this.cancelForceFlush();
+            for (const s of sentences) {
+                this.queue.push(s);
+            }
+            if (!this.processing) {
+                this.processQueue();
+            }
+        }
+        else if (this.buffer.length > 0 && !this.processing) {
+            this.scheduleForceFlush();
+        }
+    }
+    scheduleForceFlush() {
+        this.cancelForceFlush();
+        this.forceTimer = setTimeout(() => {
+            if (!this.enabled || this.stopped || this.buffer.length === 0)
+                return;
+            const text = this.buffer.flush();
+            if (text) {
+                console.log(`[interrupt-tts] force-flush "${text.slice(0, 60)}"`);
+                this.queue.push(text);
+                if (!this.processing) {
+                    this.processQueue();
+                }
+            }
+        }, this.FORCE_FLUSH_MS);
+    }
+    cancelForceFlush() {
+        if (this.forceTimer) {
+            clearTimeout(this.forceTimer);
+            this.forceTimer = null;
+        }
+    }
+    async flush() {
+        if (!this.enabled)
+            return;
+        const remaining = this.buffer.flush();
+        if (remaining) {
+            console.log(`[interrupt-tts] flush remaining="${remaining.slice(0, 80)}"`);
+            this.queue.push(remaining);
+        }
+        if (!this.processing)
+            return;
+        await new Promise((resolve) => {
+            const check = () => {
+                if (!this.processing)
+                    resolve();
+                else
+                    setImmediate(check);
+            };
+            this.once("queue-drained", resolve);
+            if (!this.processing)
+                resolve();
+        });
+    }
+    speakNow(text) {
+        if (!text.trim())
+            return;
+        this.stop();
+        this.queue.unshift(text);
+        this.stopped = false;
+        if (!this.processing) {
+            this.processQueue();
+        }
+    }
+    stop() {
+        this.stopped = true;
+        this.queue = [];
+        this.engine.stop();
+        this.processing = false;
+        this.cancelForceFlush();
+    }
+    disable() {
+        this.enabled = false;
+        this.stop();
+    }
+    enable() {
+        this.enabled = true;
+    }
+    getPartialContent() {
+        if (this.spokenText.trim()) {
+            return this.spokenText.trim() + "...[interrupted]";
+        }
+        return "";
+    }
+    isPlaying() {
+        return this.engine.isPlaying || this.queue.length > 0 || this.processing || (Date.now() - this.lastActivity < 3000);
+    }
+    resetSession() {
+        this.buffer.clear();
+        this.queue = [];
+        this.spokenText = "";
+        this.cancelForceFlush();
+    }
+    async processQueue() {
+        this.processing = true;
+        while (this.queue.length > 0 && !this.stopped) {
+            const sentence = this.queue.shift();
+            await this.engine.speak(sentence);
+            if (!this.stopped) {
+                this.spokenText += sentence + " ";
+            }
+        }
+        this.processing = false;
+        this.emit("queue-drained");
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-interrupt-plugin",
-  "version": "0.3.1",
-  "description": "Voice interruption for OpenCode. Detects when you speak over TTS output and redirects the AI mid-response.",
+  "version": "0.4.1",
+  "description": "Streaming TTS + voice interruption for OpenCode. Speaks responses as they arrive and detects when you talk over it.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",