discoclaw 1.2.3 → 1.3.0

package/dist/voice/providers/gemini-live-token-estimator.js

@@ -0,0 +1,100 @@
+/**
+ * Token estimator for Gemini Live sessions.
+ *
+ * Tracks approximate token usage across text, audio, and tool payloads
+ * to warn before the context window fills and server-side sliding window
+ * compression silently drops older context.
+ *
+ * Estimation is deliberately coarse (chars/4 for text, duration-based for
+ * audio) — the goal is order-of-magnitude awareness, not exact counts.
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Rough chars-per-token for mixed English text. */
+const CHARS_PER_TOKEN = 4;
+/** Approximate tokens per second of 16 kHz mono speech audio. */
+const AUDIO_TOKENS_PER_SECOND = 25;
+/** Input audio: 16 kHz mono PCM s16le → 2 bytes per sample. */
+const INPUT_BYTES_PER_SECOND = 16_000 * 2;
+/** Output audio: 24 kHz mono PCM s16le → 2 bytes per sample. */
+const OUTPUT_BYTES_PER_SECOND = 24_000 * 2;
+const DEFAULT_BUDGET = {
+    warnAt: 200_000,
+    compressAt: 500_000,
+};
+// ---------------------------------------------------------------------------
+// Estimator
+// ---------------------------------------------------------------------------
+export class GeminiLiveTokenEstimator {
+    textTokens = 0;
+    audioTokens = 0;
+    toolTokens = 0;
+    warnEmitted = false;
+    compressEmitted = false;
+    budget;
+    constructor(budget) {
+        this.budget = { ...DEFAULT_BUDGET, ...budget };
+    }
+    /** Record text tokens (sent or received). */
+    addText(text) {
+        this.textTokens += Math.ceil(text.length / CHARS_PER_TOKEN);
+    }
+    /** Record input audio tokens from PCM byte count (16 kHz mono). */
+    addInputAudio(pcmBytes) {
+        const seconds = pcmBytes / INPUT_BYTES_PER_SECOND;
+        this.audioTokens += Math.ceil(seconds * AUDIO_TOKENS_PER_SECOND);
+    }
+    /** Record output audio tokens from PCM byte count (24 kHz mono). */
+    addOutputAudio(pcmBytes) {
+        const seconds = pcmBytes / OUTPUT_BYTES_PER_SECOND;
+        this.audioTokens += Math.ceil(seconds * AUDIO_TOKENS_PER_SECOND);
+    }
+    /** Record a tool call (function name + serialised args). */
+    addToolCall(name, args) {
+        const payload = name + JSON.stringify(args);
+        this.toolTokens += Math.ceil(payload.length / CHARS_PER_TOKEN);
+    }
+    /** Record a tool response. */
+    addToolResponse(output) {
+        this.toolTokens += Math.ceil(output.length / CHARS_PER_TOKEN);
+    }
+    /** Current estimate snapshot. */
+    get estimate() {
+        const total = this.textTokens + this.audioTokens + this.toolTokens;
+        return { textTokens: this.textTokens, audioTokens: this.audioTokens, toolTokens: this.toolTokens, total };
+    }
+    /** Whether the warn threshold has been crossed. */
+    get shouldWarn() {
+        return this.estimate.total >= this.budget.warnAt;
+    }
+    /** Whether the compress/rotate threshold has been crossed. */
+    get shouldCompress() {
+        return this.estimate.total >= this.budget.compressAt;
+    }
+    /**
+     * Check thresholds and return which (if any) was newly crossed.
+     * Returns the threshold name once per crossing — subsequent calls
+     * return `null` until `reset()` is called.
+     */
+    checkThreshold() {
+        if (this.shouldCompress && !this.compressEmitted) {
+            this.compressEmitted = true;
+            this.warnEmitted = true; // skip warn if compress fires first
+            return 'compress';
+        }
+        if (this.shouldWarn && !this.warnEmitted) {
+            this.warnEmitted = true;
+            return 'warn';
+        }
+        return null;
+    }
+    /** Reset all counters (e.g. after session rotation). */
+    reset() {
+        this.textTokens = 0;
+        this.audioTokens = 0;
+        this.toolTokens = 0;
+        this.warnEmitted = false;
+        this.compressEmitted = false;
+    }
+}

package/dist/voice/providers/gemini-live-token-estimator.test.js

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest';
+import { GeminiLiveTokenEstimator } from './gemini-live-token-estimator.js';
+describe('GeminiLiveTokenEstimator', () => {
+    // -----------------------------------------------------------------------
+    // addText
+    // -----------------------------------------------------------------------
+    describe('addText', () => {
+        it('estimates tokens at ~4 chars per token', () => {
+            const est = new GeminiLiveTokenEstimator();
+            est.addText('Hello world!'); // 12 chars -> ceil(12/4) = 3 tokens
+            expect(est.estimate.textTokens).toBe(3);
+            expect(est.estimate.total).toBe(3);
+        });
+        it('rounds up partial tokens', () => {
+            const est = new GeminiLiveTokenEstimator();
+            est.addText('Hi'); // 2 chars -> ceil(2/4) = 1 token
+            expect(est.estimate.textTokens).toBe(1);
+        });
+        it('accumulates across multiple calls', () => {
+            const est = new GeminiLiveTokenEstimator();
+            est.addText('aaaa'); // 4 chars -> 1 token
+            est.addText('bbbbbbbb'); // 8 chars -> 2 tokens
+            expect(est.estimate.textTokens).toBe(3);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // addInputAudio
+    // -----------------------------------------------------------------------
+    describe('addInputAudio', () => {
+        it('estimates tokens from 16kHz mono PCM bytes', () => {
+            const est = new GeminiLiveTokenEstimator();
+            // 1 second of 16kHz mono PCM s16le = 32000 bytes -> 25 tokens
+            est.addInputAudio(32_000);
+            expect(est.estimate.audioTokens).toBe(25);
+        });
+        it('rounds up partial seconds', () => {
+            const est = new GeminiLiveTokenEstimator();
+            // 100 bytes -> 100/32000 ~= 0.003s -> ceil(0.003 * 25) = 1 token
+            est.addInputAudio(100);
+            expect(est.estimate.audioTokens).toBe(1);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // addOutputAudio
+    // -----------------------------------------------------------------------
+    describe('addOutputAudio', () => {
+        it('estimates tokens from 24kHz mono PCM bytes', () => {
+            const est = new GeminiLiveTokenEstimator();
+            // 1 second of 24kHz mono PCM s16le = 48000 bytes -> 25 tokens
+            est.addOutputAudio(48_000);
+            expect(est.estimate.audioTokens).toBe(25);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // addToolCall / addToolResponse
+    // -----------------------------------------------------------------------
+    describe('addToolCall', () => {
+        it('estimates tokens from function name + serialised args', () => {
+            const est = new GeminiLiveTokenEstimator();
+            est.addToolCall('web_search', { query: 'hello' });
+            // payload = 'web_search{"query":"hello"}' -> 27 chars -> ceil(27/4) = 7
+            expect(est.estimate.toolTokens).toBe(7);
+        });
+    });
+    describe('addToolResponse', () => {
+        it('estimates tokens from response output', () => {
+            const est = new GeminiLiveTokenEstimator();
+            est.addToolResponse('some result text'); // 16 chars -> ceil(16/4) = 4
+            expect(est.estimate.toolTokens).toBe(4);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // estimate
+    // -----------------------------------------------------------------------
+    describe('estimate', () => {
+        it('returns combined total of text, audio, and tool tokens', () => {
+            const est = new GeminiLiveTokenEstimator();
+            est.addText('test'); // 1 token
+            est.addInputAudio(32_000); // 25 tokens
+            est.addToolCall('x', {}); // 'x{}' -> ceil(3/4) = 1 token
+            expect(est.estimate).toEqual({
+                textTokens: 1,
+                audioTokens: 25,
+                toolTokens: 1,
+                total: 27,
+            });
+        });
+    });
+    // -----------------------------------------------------------------------
+    // threshold checking
+    // -----------------------------------------------------------------------
+    describe('threshold checking', () => {
+        it('returns null when below warn threshold', () => {
+            const est = new GeminiLiveTokenEstimator({ warnAt: 100 });
+            est.addText('hi'); // 1 token
+            expect(est.checkThreshold()).toBeNull();
+        });
+        it('returns "warn" when crossing the warn threshold', () => {
+            const est = new GeminiLiveTokenEstimator({ warnAt: 2, compressAt: 100 });
+            est.addText('12345678'); // ceil(8/4) = 2 tokens
+            expect(est.checkThreshold()).toBe('warn');
+        });
+        it('returns "warn" only once per threshold crossing', () => {
+            const est = new GeminiLiveTokenEstimator({ warnAt: 2, compressAt: 100 });
+            est.addText('12345678'); // 2 tokens -> crosses warn
+            expect(est.checkThreshold()).toBe('warn');
+            est.addText('more');
+            expect(est.checkThreshold()).toBeNull();
+        });
+        it('returns "compress" when crossing the compress threshold', () => {
+            const est = new GeminiLiveTokenEstimator({ warnAt: 2, compressAt: 5 });
+            est.addText('12345678901234567890'); // ceil(20/4) = 5 tokens
+            expect(est.checkThreshold()).toBe('compress');
+        });
+        it('skips "warn" if compress fires first', () => {
+            const est = new GeminiLiveTokenEstimator({ warnAt: 2, compressAt: 3 });
+            est.addText('123456789012'); // ceil(12/4) = 3 tokens -> crosses both
+            expect(est.checkThreshold()).toBe('compress');
+            expect(est.checkThreshold()).toBeNull();
+        });
+        it('shouldWarn reflects threshold state', () => {
+            const est = new GeminiLiveTokenEstimator({ warnAt: 2 });
+            expect(est.shouldWarn).toBe(false);
+            est.addText('12345678'); // 2 tokens
+            expect(est.shouldWarn).toBe(true);
+        });
+        it('shouldCompress reflects threshold state', () => {
+            const est = new GeminiLiveTokenEstimator({ compressAt: 2 });
+            expect(est.shouldCompress).toBe(false);
+            est.addText('12345678'); // 2 tokens
+            expect(est.shouldCompress).toBe(true);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // reset
+    // -----------------------------------------------------------------------
+    describe('reset', () => {
+        it('clears all token counters', () => {
+            const est = new GeminiLiveTokenEstimator();
+            est.addText('hello');
+            est.addInputAudio(32_000);
+            est.addToolCall('fn', {});
+            est.reset();
+            expect(est.estimate).toEqual({
+                textTokens: 0,
+                audioTokens: 0,
+                toolTokens: 0,
+                total: 0,
+            });
+        });
+        it('re-arms threshold notifications after reset', () => {
+            const est = new GeminiLiveTokenEstimator({ warnAt: 2, compressAt: 100 });
+            est.addText('12345678'); // 2 tokens -> crosses warn
+            expect(est.checkThreshold()).toBe('warn');
+            est.reset();
+            est.addText('12345678'); // 2 tokens again -> warn fires again
+            expect(est.checkThreshold()).toBe('warn');
+        });
+    });
+});

package/dist/voice/providers/gemini-live-types.js

@@ -0,0 +1,32 @@
+/**
+ * Types for the Gemini Multimodal Live API provider.
+ *
+ * Extracted so that both GeminiLiveProvider (Phase 1.1) and the future
+ * GeminiLiveResponder (Phase 1.2) can share them without circular deps.
+ */
+export const DEFAULT_GEMINI_LIVE_MODEL = 'gemini-3.1-flash-live-preview';
+/**
+ * Returns the caller-provided Gemini Live model when it looks like a live-capable
+ * model ID. Non-live model IDs are ignored so voice mode falls back to the
+ * provider default instead of sending an invalid model to the Live API.
+ */
+export function normalizeGeminiLiveModel(model) {
+    const trimmed = model?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.startsWith('gemini-') && trimmed.includes('live') ? trimmed : undefined;
+}
+/**
+ * Gemini 3.1 Flash Live currently supports synchronous function calling only.
+ * Gemini 2.5 Flash Live supports NON_BLOCKING declarations and response scheduling.
+ */
+export function supportsGeminiLiveAsyncFunctionCalling(model) {
+    return /^gemini-2\.5-.*live/i.test(model.trim());
+}
+/**
+ * Gemini 3.1 Flash Live only supports clientContent for initial history seeding.
+ * Regular conversational text turns must use realtimeInput.text.
+ */
+export function supportsGeminiLiveIncrementalClientContent(model) {
+    return /^gemini-2\.5-.*live/i.test(model.trim());
+}

package/dist/voice/providers/gemini-tool-mapper.js

@@ -0,0 +1,91 @@
+/**
+ * Gemini tool mapper — converts OpenAI function-calling tool schemas into
+ * Gemini-compatible function declarations for the Multimodal Live API.
+ *
+ * Gemini expects:
+ * - Uppercase type names (STRING, NUMBER, OBJECT, BOOLEAN, ARRAY, INTEGER)
+ * - No `additionalProperties` field
+ * - Function declarations as `{ name, description, parameters }` (no `type: 'function'` wrapper)
+ *
+ * The mapper is intentionally stateless and pure — it transforms schemas at
+ * session setup time and has no runtime side effects.
+ */
+// ---------------------------------------------------------------------------
+// Type mapping
+// ---------------------------------------------------------------------------
+const TYPE_MAP = {
+    string: 'STRING',
+    number: 'NUMBER',
+    integer: 'INTEGER',
+    boolean: 'BOOLEAN',
+    object: 'OBJECT',
+    array: 'ARRAY',
+};
+/**
+ * Convert a JSON Schema type string to Gemini's uppercase equivalent.
+ * Returns the input uppercased if not in the known map (defensive).
+ */
+function mapType(jsonSchemaType) {
+    return TYPE_MAP[jsonSchemaType] ?? jsonSchemaType.toUpperCase();
+}
+// ---------------------------------------------------------------------------
+// Schema conversion
+// ---------------------------------------------------------------------------
+/**
+ * Recursively convert a JSON Schema object to a GeminiSchema.
+ * Strips `additionalProperties` and converts type names.
+ */
+export function convertSchema(schema) {
+    const result = {
+        type: mapType(String(schema.type ?? 'object')),
+    };
+    if (typeof schema.description === 'string') {
+        result.description = schema.description;
+    }
+    if (schema.properties != null && typeof schema.properties === 'object') {
+        const props = schema.properties;
+        result.properties = {};
+        for (const [key, value] of Object.entries(props)) {
+            result.properties[key] = convertSchema(value);
+        }
+    }
+    if (schema.items != null && typeof schema.items === 'object') {
+        result.items = convertSchema(schema.items);
+    }
+    if (Array.isArray(schema.required) && schema.required.length > 0) {
+        result.required = schema.required;
+    }
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        result.enum = schema.enum;
+    }
+    // additionalProperties is intentionally omitted — Gemini doesn't support it.
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Convert an array of OpenAI function tool schemas to a Gemini tools config.
+ * Returns `undefined` when the input array is empty (no tools block needed).
+ */
+export function toGeminiTools(openaiTools, opts = {}) {
+    if (openaiTools.length === 0)
+        return undefined;
+    const nonBlockingFunctionNames = new Set(opts.nonBlockingFunctionNames ?? []);
+    const declarations = openaiTools.map((tool) => {
+        const decl = {
+            name: tool.function.name,
+            description: tool.function.description,
+        };
+        // Only include parameters if the schema has properties
+        const params = tool.function.parameters;
+        if (params && typeof params === 'object' && Object.keys(params).length > 0) {
+            decl.parameters = convertSchema(params);
+        }
+        if (nonBlockingFunctionNames.has(tool.function.name)) {
+            decl.behavior = 'NON_BLOCKING';
+        }
+        return decl;
+    });
+    return { functionDeclarations: declarations };
+}

package/dist/voice/providers/gemini-tool-mapper.test.js

@@ -0,0 +1,253 @@
+import { describe, expect, it } from 'vitest';
+import { toGeminiTools, convertSchema } from './gemini-tool-mapper.js';
+import { buildToolSchemas } from '../../runtime/openai-tool-schemas.js';
+// ---------------------------------------------------------------------------
+// convertSchema
+// ---------------------------------------------------------------------------
+describe('convertSchema', () => {
+    it('converts lowercase types to uppercase', () => {
+        const result = convertSchema({ type: 'string', description: 'A name' });
+        expect(result).toEqual({ type: 'STRING', description: 'A name' });
+    });
+    it('converts object with properties recursively', () => {
+        const result = convertSchema({
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Path' },
+                count: { type: 'number', description: 'How many' },
+            },
+            required: ['file_path'],
+        });
+        expect(result).toEqual({
+            type: 'OBJECT',
+            properties: {
+                file_path: { type: 'STRING', description: 'Path' },
+                count: { type: 'NUMBER', description: 'How many' },
+            },
+            required: ['file_path'],
+        });
+    });
+    it('strips additionalProperties', () => {
+        const result = convertSchema({
+            type: 'object',
+            properties: { x: { type: 'string' } },
+            additionalProperties: false,
+        });
+        expect(result).not.toHaveProperty('additionalProperties');
+    });
+    it('converts array types with items', () => {
+        const result = convertSchema({
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    tool: { type: 'string', description: 'Tool name' },
+                },
+                required: ['tool'],
+                additionalProperties: true,
+            },
+        });
+        expect(result).toEqual({
+            type: 'ARRAY',
+            items: {
+                type: 'OBJECT',
+                properties: {
+                    tool: { type: 'STRING', description: 'Tool name' },
+                },
+                required: ['tool'],
+            },
+        });
+    });
+    it('handles boolean type', () => {
+        const result = convertSchema({ type: 'boolean', description: 'Flag' });
+        expect(result).toEqual({ type: 'BOOLEAN', description: 'Flag' });
+    });
+    it('handles integer type', () => {
+        const result = convertSchema({ type: 'integer' });
+        expect(result).toEqual({ type: 'INTEGER' });
+    });
+    it('preserves enum values', () => {
+        const result = convertSchema({ type: 'string', enum: ['a', 'b', 'c'] });
+        expect(result).toEqual({ type: 'STRING', enum: ['a', 'b', 'c'] });
+    });
+    it('defaults to OBJECT when type is missing', () => {
+        const result = convertSchema({ properties: { x: { type: 'string' } } });
+        expect(result.type).toBe('OBJECT');
+    });
+    it('omits description when not present', () => {
+        const result = convertSchema({ type: 'string' });
+        expect(result).toEqual({ type: 'STRING' });
+        expect(Object.keys(result)).toEqual(['type']);
+    });
+    it('omits required when empty', () => {
+        const result = convertSchema({ type: 'object', required: [] });
+        expect(result).not.toHaveProperty('required');
+    });
+});
+// ---------------------------------------------------------------------------
+// toGeminiTools
+// ---------------------------------------------------------------------------
+describe('toGeminiTools', () => {
+    it('returns undefined for empty input', () => {
+        expect(toGeminiTools([])).toBeUndefined();
+    });
+    it('converts a single OpenAI tool to Gemini function declaration', () => {
+        const openai = [{
+                type: 'function',
+                function: {
+                    name: 'web_search',
+                    description: 'Search the web.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string', description: 'Search query.' },
+                        },
+                        required: ['query'],
+                        additionalProperties: false,
+                    },
+                },
+            }];
+        const result = toGeminiTools(openai);
+        expect(result).toEqual({
+            functionDeclarations: [{
+                    name: 'web_search',
+                    description: 'Search the web.',
+                    parameters: {
+                        type: 'OBJECT',
+                        properties: {
+                            query: { type: 'STRING', description: 'Search query.' },
+                        },
+                        required: ['query'],
+                    },
+                }],
+        });
+    });
+    it('converts multiple tools', () => {
+        const openai = [
+            {
+                type: 'function',
+                function: {
+                    name: 'read_file',
+                    description: 'Read a file.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            file_path: { type: 'string', description: 'Path.' },
+                        },
+                        required: ['file_path'],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            {
+                type: 'function',
+                function: {
+                    name: 'bash',
+                    description: 'Run a command.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            command: { type: 'string', description: 'Command.' },
+                        },
+                        required: ['command'],
+                        additionalProperties: false,
+                    },
+                },
+            },
+        ];
+        const result = toGeminiTools(openai);
+        expect(result?.functionDeclarations).toHaveLength(2);
+        expect(result?.functionDeclarations[0].name).toBe('read_file');
+        expect(result?.functionDeclarations[1].name).toBe('bash');
+    });
+    it('marks configured Gemini declarations as NON_BLOCKING', () => {
+        const openai = [{
+                type: 'function',
+                function: {
+                    name: 'read_file',
+                    description: 'Read a file.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            file_path: { type: 'string' },
+                        },
+                        required: ['file_path'],
+                    },
+                },
+            }];
+        const result = toGeminiTools(openai, { nonBlockingFunctionNames: ['read_file'] });
+        expect(result?.functionDeclarations[0]).toMatchObject({
+            name: 'read_file',
+            behavior: 'NON_BLOCKING',
+        });
+    });
+    it('none of the declarations have additionalProperties', () => {
+        const openai = buildToolSchemas(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash']);
+        const result = toGeminiTools(openai);
+        function checkNoAdditionalProperties(obj, path) {
+            expect(obj).not.toHaveProperty('additionalProperties');
+            if (obj.properties && typeof obj.properties === 'object') {
+                for (const [key, val] of Object.entries(obj.properties)) {
+                    checkNoAdditionalProperties(val, `${path}.${key}`);
+                }
+            }
+            if (obj.items && typeof obj.items === 'object') {
+                checkNoAdditionalProperties(obj.items, `${path}.items`);
+            }
+        }
+        for (const decl of result.functionDeclarations) {
+            if (decl.parameters) {
+                checkNoAdditionalProperties(decl.parameters, decl.name);
+            }
+        }
+    });
+    it('all type names are uppercase in converted schemas', () => {
+        const openai = buildToolSchemas(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch']);
+        const result = toGeminiTools(openai);
+        function checkUppercaseTypes(obj, path) {
+            if (typeof obj.type === 'string') {
+                expect(obj.type, `type at ${path}`).toMatch(/^[A-Z]+$/);
+            }
+            if (obj.properties && typeof obj.properties === 'object') {
+                for (const [key, val] of Object.entries(obj.properties)) {
+                    checkUppercaseTypes(val, `${path}.${key}`);
+                }
+            }
+            if (obj.items && typeof obj.items === 'object') {
+                checkUppercaseTypes(obj.items, `${path}.items`);
+            }
+        }
+        for (const decl of result.functionDeclarations) {
+            if (decl.parameters) {
+                checkUppercaseTypes(decl.parameters, decl.name);
+            }
+        }
+    });
+    it('integrates with buildToolSchemas for full tool set', () => {
+        const openai = buildToolSchemas(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch']);
+        const result = toGeminiTools(openai);
+        expect(result).toBeDefined();
+        expect(result.functionDeclarations).toHaveLength(8);
+        const names = result.functionDeclarations.map((d) => d.name);
+        expect(names).toEqual([
+            'read_file', 'write_file', 'edit_file', 'list_files',
+            'search_content', 'bash', 'web_search', 'web_fetch',
+        ]);
+        // Each declaration has name, description, and parameters
+        for (const decl of result.functionDeclarations) {
+            expect(typeof decl.name).toBe('string');
+            expect(typeof decl.description).toBe('string');
+            expect(decl.parameters).toBeDefined();
+            expect(decl.parameters.type).toBe('OBJECT');
+        }
+    });
+    it('handles Pipeline expansion through buildToolSchemas', () => {
+        const openai = buildToolSchemas(['Pipeline']);
+        const result = toGeminiTools(openai);
+        expect(result).toBeDefined();
+        const names = result.functionDeclarations.map((d) => d.name);
+        expect(names).toEqual([
+            'pipeline.start', 'pipeline.status', 'pipeline.resume', 'pipeline.cancel',
+        ]);
+    });
+});

package/dist/voice/providers/index.js

@@ -0,0 +1,3 @@
+export { GeminiLiveProvider } from './gemini-live-provider.js';
+export { GeminiLiveResponder } from './gemini-live-responder.js';
+export { GeminiLiveTokenEstimator } from './gemini-live-token-estimator.js';

package/dist/voice/types.test.js

@@ -13,6 +13,12 @@ describe('Voice types', () => {
         const cfg2 = cfg;
         expect(cfg2).toBe(cfg);
     });
+    it('VoicePipelineMode accepts valid values', () => {
+        const pipeline = 'pipeline';
+        const gemini = 'gemini-live';
+        expect(pipeline).toBe('pipeline');
+        expect(gemini).toBe('gemini-live');
+    });
     it('VoiceConfig accepts minimal shape (optional fields omitted)', () => {
         const cfg = {
             enabled: false,