modular-voice-agent-sdk 1.0.0 → 1.2.0

package/dist/backends/native/audio-llm.js

@@ -0,0 +1,680 @@
+/**
+ * NativeAudioLLM - Native Multimodal Audio LLM Backend
+ *
+ * Implements BOTH STTPipeline and LLMPipeline interfaces.
+ * Register the same instance as both `stt` and `llm` in VoicePipeline.
+ *
+ * Uses internal caching to achieve single binary invocation:
+ * 1. transcribe(audio) → calls audio LLM binary, caches response, returns transcript
+ * 2. generate(messages) → returns cached response (no second invocation)
+ *
+ * The model is prompted to return both transcription and response in a structured format.
+ *
+ * Works with: Qwen2-Audio, and other audio-capable models via llama.cpp or similar.
+ */
+import { spawn } from 'child_process';
+import { existsSync, writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { LLMLogger, LLMConversationTracker } from '../../services';
+export class NativeAudioLLM {
+    config;
+    ready = false;
+    tracker;
+    // Cache for single-call optimization
+    cachedResponse = null;
+    // Store conversation context for audio processing
+    pendingMessages = [];
+    pendingOptions;
+    constructor(config) {
+        this.config = {
+            sampleRate: 16000,
+            ...config,
+        };
+        this.tracker = new LLMConversationTracker(new LLMLogger());
+    }
+    async initialize(_onProgress) {
+        console.log('Initializing NativeAudioLLM...');
+        if (!existsSync(this.config.binaryPath)) {
+            throw new Error(`Audio LLM binary not found at: ${this.config.binaryPath}`);
+        }
+        if (!existsSync(this.config.modelPath)) {
+            throw new Error(`Audio LLM model not found at: ${this.config.modelPath}`);
+        }
+        if (this.config.projectorPath && !existsSync(this.config.projectorPath)) {
+            throw new Error(`Audio projector model not found at: ${this.config.projectorPath}`);
+        }
+        this.ready = true;
+        console.log(`NativeAudioLLM ready. Model: ${this.config.modelPath}`);
+    }
+    isReady() {
+        return this.ready;
+    }
+    supportsTools() {
+        return true;
+    }
+    // ============================================================
+    // STTPipeline Implementation
+    // ============================================================
+    /**
+     * Transcribe audio by calling the audio LLM binary.
+     * Caches the full response for the subsequent generate() call.
+     */
+    async transcribe(audio) {
+        const audioHash = this.hashAudio(audio);
+        // Check if we already processed this audio
+        if (this.cachedResponse?.audioHash === audioHash) {
+            return this.cachedResponse.transcript;
+        }
+        // Build messages with system prompt instructing structured output
+        const messages = this.pendingMessages.length > 0 ? this.pendingMessages : [];
+        // Process audio with native binary
+        const { transcript, result } = await this.processAudioWithBinary(audio, messages, this.pendingOptions);
+        // Cache for subsequent generate() call
+        this.cachedResponse = { transcript, result, audioHash };
+        return transcript;
+    }
+    // ============================================================
+    // LLMPipeline Implementation
+    // ============================================================
+    /**
+     * Generate response. If called after transcribe() with matching context,
+     * returns cached response (single binary invocation total).
+     */
+    async generate(messages, options) {
+        // Store context for potential audio processing
+        this.pendingMessages = messages;
+        this.pendingOptions = options;
+        // Check if we have a cached response from transcribe()
+        if (this.cachedResponse) {
+            const cached = this.cachedResponse;
+            this.cachedResponse = null; // Clear cache
+            // Stream the cached response if callback provided
+            if (options?.onToken && cached.result.content) {
+                for (const char of cached.result.content) {
+                    options.onToken(char);
+                }
+            }
+            // Log the cached response
+            this.tracker.logOutput(options?.conversationId ?? 'default', cached.result.content, cached.result.toolCalls);
+            return cached.result;
+        }
+        // No cache - do standard text generation (text-only mode)
+        return this.textGenerate(messages, options);
+    }
+    // ============================================================
+    // Internal: Audio Processing
+    // ============================================================
+    async processAudioWithBinary(audio, messages, options) {
+        const conversationId = options?.conversationId ?? 'default';
+        // Write audio to temp file
+        const audioPath = join(tmpdir(), `audio-llm-${Date.now()}-${Math.random().toString(36).slice(2)}.wav`);
+        // Build grammar for structured output
+        const grammar = this.buildAudioGrammar(options?.tools);
+        const grammarPath = join(tmpdir(), `audio-grammar-${Date.now()}.gbnf`);
+        writeFileSync(grammarPath, grammar);
+        try {
+            this.writeWav(audioPath, audio, this.config.sampleRate);
+            // Build prompt with structured output instruction
+            const prompt = this.formatAudioPrompt(messages, options?.tools);
+            // Log input
+            this.tracker.logInput(conversationId, messages);
+            // Build args for the binary (includes grammar)
+            const args = this.buildAudioArgs(audioPath, prompt, grammarPath);
+            // Run the audio binary (llama-mtmd-cli)
+            const output = await this.runAudioBinary(args, options);
+            // Parse the structured response
+            const { transcript, responseText, toolCalls } = this.parseStructuredResponse(output);
+            const result = {
+                content: responseText,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+            };
+            // Log output
+            this.tracker.logOutput(conversationId, responseText, result.toolCalls);
+            return { transcript, result };
+        }
+        finally {
+            // Clean up temp files
+            try {
+                if (existsSync(audioPath))
+                    unlinkSync(audioPath);
+                if (existsSync(grammarPath))
+                    unlinkSync(grammarPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    /**
+     * Build command line args for the audio LLM binary (llama-mtmd-cli)
+     *
+     * Uses llama-mtmd-cli for multimodal audio processing.
+     * Requires --mmproj for the audio projector.
+     *
+     * Output: clean response text (no special formatting needed)
+     */
+    buildAudioArgs(audioPath, prompt, grammarPath) {
+        const args = [
+            '-m',
+            this.config.modelPath,
+            '-n',
+            String(this.config.maxNewTokens),
+            '--temp',
+            String(this.config.temperature ?? 0.7),
+            '--no-warmup', // Skip warmup for faster response
+            // Audio input
+            '--audio',
+            audioPath,
+            '-p',
+            prompt,
+        ];
+        // Add grammar if provided
+        if (grammarPath) {
+            args.push('--grammar-file', grammarPath);
+        }
+        // Projector is REQUIRED for audio models
+        if (this.config.projectorPath) {
+            args.push('--mmproj', this.config.projectorPath);
+        }
+        if (this.config.gpuLayers !== undefined) {
+            args.push('-ngl', String(this.config.gpuLayers));
+        }
+        // Debug: log the command being run
+        console.log(`[NativeAudioLLM] Running: ${this.config.binaryPath} ${args.join(' ').slice(0, 200)}...`);
+        return args;
+    }
+    /**
+     * Build GBNF grammar for audio mode:
+     * <transcription>text</transcription>\n(SAY: text | TOOL: json)
+     */
+    buildAudioGrammar(tools) {
+        const hasTools = tools && tools.length > 0;
+        if (hasTools) {
+            const toolNames = tools.map(t => `"\\"${t.name}\\""`).join(' | ');
+            return `# Grammar for audio: Heard then SAY or TOOL
+root ::= heard "\\n" response
+
+heard ::= "Heard:" ws heard-text
+heard-text ::= heard-char+
+heard-char ::= [a-zA-Z0-9 .,!?'\"():;-]
+
+response ::= say-response | tool-call
+
+say-response ::= "SAY:" ws text-content
+text-content ::= text-char+
+text-char ::= [a-zA-Z0-9 .,!?'\"():;\\n\\t\\r-]
+
+tool-call ::= "TOOL:" ws tool-array
+tool-array ::= "[" ws tool-obj ws "]"
+tool-obj ::= "{" ws "\\"name\\":" ws tool-name "," ws "\\"arguments\\":" ws arguments ws "}"
+tool-name ::= ${toolNames}
+arguments ::= "{" ws (keyval ("," ws keyval)*)? ws "}"
+keyval ::= string ":" ws value
+value ::= string | number | bool | null | object | array
+string ::= "\\"" chars "\\""
+chars ::= char*
+char ::= [^"\\\\\\x00-\\x1f] | "\\\\" escape
+escape ::= ["\\\\/bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F]
+number ::= "-"? ("0" | [1-9] [0-9]*) ("." [0-9]+)? ([eE] [+-]? [0-9]+)?
+bool ::= "true" | "false"
+null ::= "null"
+object ::= "{" ws (keyval ("," ws keyval)*)? ws "}"
+array ::= "[" ws (value ("," ws value)*)? ws "]"
+ws ::= [ \\t\\n]*
+`;
+        }
+        else {
+            // No tools - just Heard then Reply
+            return `# Grammar for audio: Heard then Reply
+root ::= heard "\\n\\n" reply
+
+heard ::= "Heard:" ws heard-text
+heard-text ::= heard-char+
+heard-char ::= [a-zA-Z0-9 .,!?'\"():;-]
+
+reply ::= "Reply:" ws text-content
+text-content ::= text-char+
+text-char ::= [a-zA-Z0-9 .,!?'\"():;\\n\\t\\r-]
+`;
+        }
+    }
+    /**
+     * Build GBNF grammar for text mode (no transcription):
+     * SAY: text | TOOL: json
+     */
+    buildTextGrammar(tools) {
+        const toolNames = tools.map(t => `"\\"${t.name}\\""`).join(' | ');
+        return `# Grammar for text: SAY or TOOL
+root ::= say-response | tool-call
+
+say-response ::= "SAY:" ws text-content
+text-content ::= text-char+
+text-char ::= [a-zA-Z0-9 .,!?'\"():;\\n\\t\\r-]
+
+tool-call ::= "TOOL:" ws tool-array
+tool-array ::= "[" ws tool-obj ws "]"
+tool-obj ::= "{" ws "\\"name\\":" ws tool-name "," ws "\\"arguments\\":" ws arguments ws "}"
+tool-name ::= ${toolNames}
+arguments ::= "{" ws (keyval ("," ws keyval)*)? ws "}"
+keyval ::= string ":" ws value
+value ::= string | number | bool | null | object | array
+string ::= "\\"" chars "\\""
+chars ::= char*
+char ::= [^"\\\\\\x00-\\x1f] | "\\\\" escape
+escape ::= ["\\\\/bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F]
+number ::= "-"? ("0" | [1-9] [0-9]*) ("." [0-9]+)? ([eE] [+-]? [0-9]+)?
+bool ::= "true" | "false"
+null ::= "null"
+object ::= "{" ws (keyval ("," ws keyval)*)? ws "}"
+array ::= "[" ws (value ("," ws value)*)? ws "]"
+ws ::= [ \\t\\n]*
+`;
+    }
+    /**
+     * Format prompt for audio processing with llama-mtmd-cli
+     *
+     * Uses "Heard:" prefix for transcript and "SAY:"/"TOOL:" for response.
+     * This format works well with Ultravox for getting both transcript and response.
+     */
+    formatAudioPrompt(messages, tools) {
+        const hasTools = tools && tools.length > 0;
+        // Build system context
+        let systemContext = '';
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                systemContext = msg.content;
+                break;
+            }
+        }
+        // Build prompt for llama-mtmd-cli
+        let prompt = '';
+        if (systemContext) {
+            prompt += `${systemContext}\n\n`;
+        }
+        if (hasTools) {
+            // Build tool list with clear instructions
+            const toolDescriptions = tools
+                .map((t) => `- ${t.name}(${Object.keys(t.parameters?.properties || {}).join(', ')}): ${t.description}`)
+                .join('\n');
+            prompt += `Tools available:\n${toolDescriptions}\n\n`;
+            prompt += `If the user asks for something a tool provides, you MUST use TOOL.
+Format:
+Heard: [what the user said]
+TOOL: [{"name":"tool_name","arguments":{...}}] OR SAY: [your response]`;
+        }
+        else {
+            prompt += `Format:
+Heard: [what the user said]
+
+Reply: [your brief response]`;
+        }
+        return prompt;
+    }
+    /**
+     * Parse the audio LLM response
+     *
+     * Format with tools:
+     *   Heard: [what user said]
+     *   SAY: [response] OR TOOL: [{"name":"...","arguments":{...}}]
+     *
+     * Format without tools:
+     *   Heard: [what user said]
+     *   Reply: [response]
+     */
+    parseStructuredResponse(output) {
+        // Extract transcript from "Heard: ..." line
+        const heardMatch = output.match(/Heard:\s*(.+?)(?:\n|$)/);
+        const transcript = heardMatch ? heardMatch[1].trim() : '[transcript unavailable]';
+        // Get everything after the Heard line
+        const afterHeard = output.replace(/Heard:\s*.+?(?:\n|$)/, '').trim();
+        const toolCalls = [];
+        let responseText = '';
+        // Check for TOOL: prefix
+        if (afterHeard.startsWith('TOOL:')) {
+            const toolJson = afterHeard.slice(5).trim();
+            try {
+                const parsed = JSON.parse(toolJson);
+                // Handle array format [{"name": ..., "arguments": ...}]
+                if (Array.isArray(parsed)) {
+                    for (const tc of parsed) {
+                        if (tc && typeof tc.name === 'string') {
+                            toolCalls.push({
+                                id: `native-audio-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                                name: tc.name,
+                                arguments: tc.arguments || {},
+                            });
+                        }
+                    }
+                }
+                // Handle single object format {"name": ..., "arguments": ...}
+                else if (parsed && typeof parsed.name === 'string') {
+                    toolCalls.push({
+                        id: `native-audio-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                        name: parsed.name,
+                        arguments: parsed.arguments || {},
+                    });
+                }
+            }
+            catch {
+                // Failed to parse tool call, treat as response
+                responseText = afterHeard;
+            }
+        }
+        // Check for SAY: prefix
+        else if (afterHeard.startsWith('SAY:')) {
+            responseText = afterHeard.slice(4).trim();
+        }
+        // Check for Reply: prefix (no-tools format)
+        else if (afterHeard.startsWith('Reply:')) {
+            responseText = afterHeard.slice(6).trim();
+        }
+        // Fallback: use entire content after Heard as response
+        else {
+            responseText = afterHeard;
+        }
+        return { transcript, responseText, toolCalls };
+    }
+    // ============================================================
+    // Internal: Text Generation (fallback for text-only mode)
+    // ============================================================
+    async textGenerate(messages, options) {
+        const conversationId = options?.conversationId ?? 'default';
+        const hasTools = options?.tools && options.tools.length > 0;
+        this.tracker.logInput(conversationId, messages);
+        const prompt = this.formatTextPrompt(messages, options?.tools);
+        // If tools provided, use grammar mode
+        let grammarPath;
+        if (hasTools) {
+            const grammar = this.buildTextGrammar(options.tools);
+            grammarPath = join(tmpdir(), `text-grammar-${Date.now()}.gbnf`);
+            writeFileSync(grammarPath, grammar);
+        }
+        try {
+            // Use text binary (llama-completion) for text-only generation
+            const textBinary = this.config.textBinaryPath || this.config.binaryPath.replace('llama-mtmd-cli', 'llama-completion');
+            const args = [
+                '-m',
+                this.config.modelPath,
+                '-n',
+                String(this.config.maxNewTokens),
+                '--temp',
+                String(this.config.temperature ?? 0.7),
+                '-p',
+                prompt,
+            ];
+            if (grammarPath) {
+                args.push('--grammar-file', grammarPath);
+            }
+            if (this.config.gpuLayers !== undefined) {
+                args.push('-ngl', String(this.config.gpuLayers));
+            }
+            console.log(`[NativeAudioLLM] Text generation: ${textBinary} ${args.slice(0, 6).join(' ')}...`);
+            // Run llama-completion for text generation
+            const output = await this.runTextBinary(textBinary, args, options);
+            this.tracker.logOutput(conversationId, output);
+            // Parse output for tool calls if grammar mode
+            if (hasTools) {
+                return this.parseTextResponse(output);
+            }
+            return {
+                content: output,
+                finishReason: 'stop',
+            };
+        }
+        finally {
+            // Clean up grammar file
+            if (grammarPath && existsSync(grammarPath)) {
+                try {
+                    unlinkSync(grammarPath);
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    /**
+     * Parse text response for SAY:/TOOL: format
+     */
+    parseTextResponse(output) {
+        const trimmed = output.trim();
+        if (trimmed.startsWith('TOOL:')) {
+            const toolJson = trimmed.slice(5).trim();
+            try {
+                const parsed = JSON.parse(toolJson);
+                const toolCalls = [];
+                if (Array.isArray(parsed)) {
+                    for (const tc of parsed) {
+                        if (tc && typeof tc.name === 'string') {
+                            toolCalls.push({
+                                id: `native-text-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                                name: tc.name,
+                                arguments: tc.arguments || {},
+                            });
+                        }
+                    }
+                }
+                else if (parsed && typeof parsed.name === 'string') {
+                    toolCalls.push({
+                        id: `native-text-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+                        name: parsed.name,
+                        arguments: parsed.arguments || {},
+                    });
+                }
+                return {
+                    content: '',
+                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                    finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+                };
+            }
+            catch {
+                // Failed to parse, treat as text
+            }
+        }
+        // SAY: response or fallback
+        const content = trimmed.startsWith('SAY:') ? trimmed.slice(4).trim() : trimmed;
+        return {
+            content,
+            finishReason: 'stop',
+        };
+    }
+    /**
+     * Format prompt for text-only mode
+     */
+    formatTextPrompt(messages, _tools) {
+        let prompt = '';
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                prompt += `<|im_start|>system\n${msg.content}<|im_end|>\n`;
+            }
+            else if (msg.role === 'user') {
+                prompt += `<|im_start|>user\n${msg.content}<|im_end|>\n`;
+            }
+            else if (msg.role === 'assistant') {
+                prompt += `<|im_start|>assistant\n${msg.content}<|im_end|>\n`;
+            }
+            else if (msg.role === 'tool') {
+                prompt += `<|im_start|>tool\n${msg.content}<|im_end|>\n`;
+            }
+        }
+        prompt += '<|im_start|>assistant\n';
+        return prompt;
+    }
+    // ============================================================
+    // Internal: Binary Execution
+    // ============================================================
+    /** Special tokens to filter from output */
+    static SPECIAL_TOKENS = /\[end of text\]|<\|im_end\|>|<\|im_start\|>|<\|endoftext\|>/gi;
+    /**
+     * Run llama-mtmd-cli with audio input
+     * Output format: clean response text (no markers needed)
+     */
+    runAudioBinary(args, options) {
+        return new Promise((resolve, reject) => {
+            const proc = spawn(this.config.binaryPath, args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let output = '';
+            let stderrOutput = '';
+            let hasOutput = false;
+            // Timeout after 120 seconds (audio loading can be slow)
+            const timeout = setTimeout(() => {
+                if (!hasOutput) {
+                    proc.kill();
+                    reject(new Error(`Audio LLM binary timed out (no output after 120s).\n` +
+                        `Ensure llama-mtmd-cli is installed and supports audio.\n` +
+                        `stderr: ${stderrOutput.slice(0, 500)}`));
+                }
+            }, 120000);
+            proc.stdout.on('data', (data) => {
+                hasOutput = true;
+                output += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderrOutput += data.toString();
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (code !== 0) {
+                    reject(new Error(`Audio LLM binary exited with code ${code}.\n` +
+                        `stderr: ${stderrOutput.slice(0, 500)}`));
+                    return;
+                }
+                // llama-mtmd-cli outputs clean response text to stdout
+                const response = this.parseMtmdOutput(output);
+                console.log(`[NativeAudioLLM] Response: ${response.slice(0, 200)}...`);
+                // Stream parsed response if callback provided
+                if (options?.onToken && response) {
+                    for (const char of response) {
+                        options.onToken(char);
+                    }
+                }
+                resolve(response);
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to spawn audio binary: ${err.message}`));
+            });
+        });
+    }
+    /**
+     * Parse llama-mtmd-cli's output format
+     * Output is clean response text on stdout (no special formatting)
+     */
+    parseMtmdOutput(output) {
+        // llama-mtmd-cli outputs clean response text
+        // Just trim whitespace and remove any special tokens
+        return output
+            .replace(NativeAudioLLM.SPECIAL_TOKENS, '')
+            .trim();
+    }
+    /**
+     * Run llama-completion for text-only generation (after tool calls)
+     * Output is clean completion text
+     */
+    runTextBinary(binaryPath, args, options) {
+        return new Promise((resolve, reject) => {
+            const proc = spawn(binaryPath, args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let output = '';
+            let stderrOutput = '';
+            // Timeout after 60 seconds
+            const timeout = setTimeout(() => {
+                proc.kill();
+                reject(new Error(`Text LLM binary timed out.\n` +
+                    `stderr: ${stderrOutput.slice(0, 500)}`));
+            }, 60000);
+            proc.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderrOutput += data.toString();
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (code !== 0) {
+                    reject(new Error(`Text LLM binary exited with code ${code}.\n` +
+                        `stderr: ${stderrOutput.slice(0, 500)}`));
+                    return;
+                }
+                // llama-completion outputs clean response text
+                const response = output
+                    .replace(NativeAudioLLM.SPECIAL_TOKENS, '')
+                    .trim();
+                console.log(`[NativeAudioLLM] Text response: ${response.slice(0, 200)}...`);
+                // Stream response if callback provided
+                if (options?.onToken && response) {
+                    for (const char of response) {
+                        options.onToken(char);
+                    }
+                }
+                resolve(response);
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to spawn text binary: ${err.message}`));
+            });
+        });
+    }
+    // ============================================================
+    // Internal: Helpers
+    // ============================================================
+    hashAudio(audio) {
+        // Simple hash based on length and samples
+        let hash = audio.length;
+        const step = Math.max(1, Math.floor(audio.length / 100));
+        for (let i = 0; i < audio.length; i += step) {
+            hash = (hash << 5) - hash + Math.floor(audio[i] * 1000);
+            hash |= 0;
+        }
+        return `audio-${audio.length}-${hash}`;
+    }
+    /**
+     * Write Float32Array audio data to a WAV file
+     */
+    writeWav(path, audio, sampleRate) {
+        const numChannels = 1;
+        const bitsPerSample = 16;
+        const byteRate = sampleRate * numChannels * (bitsPerSample / 8);
+        const blockAlign = numChannels * (bitsPerSample / 8);
+        const dataSize = audio.length * (bitsPerSample / 8);
+        const fileSize = 36 + dataSize;
+        const buffer = Buffer.alloc(44 + dataSize);
+        let offset = 0;
+        buffer.write('RIFF', offset);
+        offset += 4;
+        buffer.writeUInt32LE(fileSize, offset);
+        offset += 4;
+        buffer.write('WAVE', offset);
+        offset += 4;
+        buffer.write('fmt ', offset);
+        offset += 4;
+        buffer.writeUInt32LE(16, offset);
+        offset += 4;
+        buffer.writeUInt16LE(1, offset);
+        offset += 2;
+        buffer.writeUInt16LE(numChannels, offset);
+        offset += 2;
+        buffer.writeUInt32LE(sampleRate, offset);
+        offset += 4;
+        buffer.writeUInt32LE(byteRate, offset);
+        offset += 4;
+        buffer.writeUInt16LE(blockAlign, offset);
+        offset += 2;
+        buffer.writeUInt16LE(bitsPerSample, offset);
+        offset += 2;
+        buffer.write('data', offset);
+        offset += 4;
+        buffer.writeUInt32LE(dataSize, offset);
+        offset += 4;
+        for (let i = 0; i < audio.length; i++) {
+            const sample = Math.max(-1, Math.min(1, audio[i]));
+            const int16 = sample < 0 ? sample * 32768 : sample * 32767;
+            buffer.writeInt16LE(Math.round(int16), offset);
+            offset += 2;
+        }
+        writeFileSync(path, buffer);
+    }
+}
+//# sourceMappingURL=audio-llm.js.map