stelo 1.0.4 → 1.0.5

package/dist/cortex.js

@@ -9,22 +9,171 @@
 // ██      ██    ██ ██   ██    ██    ██       ██ ██
 //  ██████  ██████  ██   ██    ██    ███████ ██   ██
 //
-// The missing layer between real-time AI models and the physical computer.
+// The missing layer between AI models and the physical computer.
 // Cortex gives a model eyes (screen), ears (audio), hands (mouse/keyboard),
 // and a voice — all flowing bidirectionally in real time.
 //
-// Provider-agnostic: works with Gemini Live, OpenAI Realtime, xAI, or any
-// WebSocket-based model. The Cortex doesn't care what model is behind it.
-// It just bridges senses ↔ intelligence ↔ actions.
+// Provider-agnostic: works with EVERY major AI provider out of the box.
+// One unified interface, every model on Earth.
+//
+// ┌─────────────────────────────────────────────────────────────────────┐
+// │  REAL-TIME (WebSocket, bidirectional audio)                        │
+// │    • geminiLiveProvider()     — Google Gemini Live API             │
+// │    • openAIRealtimeProvider() — OpenAI Realtime API               │
+// │                                                                   │
+// │  HTTP STREAMING (SSE, text + vision + tool calling)               │
+// │    • geminiProvider()         — Google Gemini (generateContent)   │
+// │    • openAIChatProvider()     — OpenAI Chat Completions           │
+// │    • openAIResponsesProvider()— OpenAI Responses API              │
+// │    • anthropicProvider()      — Anthropic Claude                  │
+// │    • mistralProvider()        — Mistral AI                        │
+// │    • xaiProvider()            — xAI / Grok                        │
+// │    • deepSeekProvider()       — DeepSeek                          │
+// │    • groqProvider()           — Groq (fast inference)             │
+// │    • togetherProvider()       — Together AI                       │
+// │    • fireworksProvider()      — Fireworks AI                      │
+// │    • perplexityProvider()     — Perplexity                        │
+// │    • sambanovaProvider()      — SambaNova                         │
+// │    • cerebrasProvider()       — Cerebras                          │
+// │                                                                   │
+// │  CUSTOM                                                           │
+// │    • customProvider()         — Any WebSocket model               │
+// │    • openAIChatProvider({     — Any OpenAI-compatible endpoint    │
+// │        baseUrl: '...'         (Ollama, LM Studio, vLLM, etc.)    │
+// │      })                                                           │
+// └─────────────────────────────────────────────────────────────────────┘
 //
 // ============================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cortex = void 0;
+exports.buildScreenContext = buildScreenContext;
 exports.geminiLiveProvider = geminiLiveProvider;
 exports.openAIRealtimeProvider = openAIRealtimeProvider;
 exports.customProvider = customProvider;
+exports.openAIChatProvider = openAIChatProvider;
+exports.geminiProvider = geminiProvider;
+exports.mistralProvider = mistralProvider;
+exports.xaiProvider = xaiProvider;
+exports.deepSeekProvider = deepSeekProvider;
+exports.groqProvider = groqProvider;
+exports.togetherProvider = togetherProvider;
+exports.fireworksProvider = fireworksProvider;
+exports.perplexityProvider = perplexityProvider;
+exports.sambanovaProvider = sambanovaProvider;
+exports.cerebrasProvider = cerebrasProvider;
+exports.openAIResponsesProvider = openAIResponsesProvider;
+exports.anthropicProvider = anthropicProvider;
 exports.createCortex = createCortex;
 const native = require('../index.js');
+// ═════════════════════════════════════════════════════════════════════════════
+// SEMANTIC SCREEN CONTEXT
+// Converts the live screen into a structured textual description that ANY
+// model can understand — including text-only models with no vision capability.
+// Like giving a model "eyes" that output semantic meaning, not raw pixels.
+// ═════════════════════════════════════════════════════════════════════════════
+/**
+ * Build a full semantic description of the current screen state.
+ * Returns structured text: active window, all open windows, all visible
+ * text via OCR, and clickable element positions.
+ *
+ * Works for every provider — including text-only models.
+ */
+function buildScreenContext(region) {
+    let activeWindow = null;
+    let windows = [];
+    let ocrResult = {};
+    let screenSize = { width: 0, height: 0 };
+    try {
+        activeWindow = native.windowGetActive();
+    }
+    catch { /* not on all platforms */ }
+    try {
+        windows = native.windowGetAll() ?? [];
+    }
+    catch { /* not on all platforms */ }
+    try {
+        const sz = native.screenGetSize();
+        screenSize = { width: sz.width ?? sz.w ?? 0, height: sz.height ?? sz.h ?? 0 };
+    }
+    catch { /* fallback */ }
+    try {
+        if (region) {
+            ocrResult = native.ocrRecognize(region.x, region.y, region.width, region.height);
+        }
+        else {
+            ocrResult = native.ocrRecognize();
+        }
+    }
+    catch { /* OCR might not be available */ }
+    const lines = [];
+    // Header
+    lines.push('## SCREEN CONTEXT');
+    if (screenSize.width > 0) {
+        lines.push(`Resolution: ${screenSize.width}×${screenSize.height}`);
+    }
+    if (region) {
+        lines.push(`Region: (${region.x},${region.y}) ${region.width}×${region.height}`);
+    }
+    lines.push('');
+    // Active window
+    if (activeWindow) {
+        lines.push(`### Active Window`);
+        lines.push(`Title: "${activeWindow.title}"`);
+        if (activeWindow.processName)
+            lines.push(`App: ${activeWindow.processName}`);
+        if (activeWindow.width && activeWindow.height) {
+            lines.push(`Size: ${activeWindow.width}×${activeWindow.height} at (${activeWindow.x ?? 0}, ${activeWindow.y ?? 0})`);
+        }
+        lines.push('');
+    }
+    // Other open windows
+    const otherWindows = activeWindow
+        ? windows.filter((w) => w.id !== activeWindow?.id && w.isVisible !== false).slice(0, 8)
+        : windows.slice(0, 8);
+    if (otherWindows.length > 0) {
+        lines.push(`### Open Windows`);
+        for (const w of otherWindows) {
+            lines.push(`  - "${w.title}"${w.processName ? ` (${w.processName})` : ''}`);
+        }
+        lines.push('');
+    }
+    // OCR text content
+    const fullText = ocrResult.text ?? '';
+    const words = ocrResult.words ?? [];
+    if (fullText.trim()) {
+        lines.push(`### Visible Text`);
+        lines.push(fullText.trim());
+        lines.push('');
+    }
+    // Clickable text elements with coordinates
+    const textElements = [];
+    if (words.length > 0) {
+        lines.push(`### UI Elements (text → click coordinates)`);
+        const limit = Math.min(words.length, 60);
+        for (let i = 0; i < limit; i++) {
+            const w = words[i];
+            const cx = Math.round(w.x + (w.width ?? 0) / 2);
+            const cy = Math.round(w.y + (w.height ?? 0) / 2);
+            textElements.push({ text: w.text, x: w.x, y: w.y, centerX: cx, centerY: cy });
+            lines.push(`  "${w.text}" → (${cx}, ${cy})`);
+        }
+        if (words.length > 60)
+            lines.push(`  ... and ${words.length - 60} more elements`);
+        lines.push('');
+    }
+    // Actionable summary hint
+    lines.push(`### How to interact`);
+    lines.push(`- Click: use mouse_click at the (x,y) coordinates above`);
+    lines.push(`- Find & click by text: use screen_find_and_click with the visible label`);
+    lines.push(`- Type into active element: use keyboard_type`);
+    lines.push(`- After acting, call screen_context again to see updated state`);
+    return {
+        context: lines.join('\n'),
+        activeWindow,
+        textElements,
+        fullText,
+    };
+}
 class Cortex {
     config = null;
     transport = null;
@@ -565,6 +714,207 @@ class Cortex {
             },
             nonBlocking: true,
         });
+        // ── Semantic Screen Understanding ─────────────────────────────────────
+        // These tools give the model a HUMAN-LIKE understanding of the screen —
+        // not raw pixels, but structured semantic context: what windows are open,
+        // what text is visible, where UI elements are, what changed.
+        // Works for every model, including text-only models with no vision.
+        this.registerTool('screen_context', (region) => {
+            return buildScreenContext(region);
+        }, {
+            description: 'Get a full semantic understanding of the current screen — visible text, active window, all open windows, and UI element positions. Use this to understand what is on screen before clicking or typing. Works without vision capability.',
+            parameters: {
+                region: {
+                    type: 'object',
+                    description: 'Optional screen region to read (x, y, width, height). Omit for full screen.',
+                    properties: {
+                        x: { type: 'number' },
+                        y: { type: 'number' },
+                        width: { type: 'number' },
+                        height: { type: 'number' },
+                    },
+                },
+            },
+        });
+        this.registerTool('screen_find_text', (text) => {
+            try {
+                const result = native.ocrFindText(text);
+                if (!result)
+                    return { found: false, text };
+                const cx = Math.round(result.x + result.width / 2);
+                const cy = Math.round(result.y + result.height / 2);
+                return {
+                    found: true,
+                    text,
+                    x: result.x,
+                    y: result.y,
+                    width: result.width,
+                    height: result.height,
+                    centerX: cx,
+                    centerY: cy,
+                    clickTarget: `(${cx}, ${cy})`,
+                };
+            }
+            catch {
+                return { found: false, text, error: 'OCR unavailable' };
+            }
+        }, {
+            description: 'Find specific text on screen and get its exact pixel position. Returns center coordinates ready to click. Use this to locate buttons, labels, or any visible text.',
+            parameters: {
+                text: { type: 'string', description: 'The text to find on screen', required: true },
+            },
+        });
+        this.registerTool('screen_find_and_click', async (text) => {
+            try {
+                const result = native.ocrFindText(text);
+                if (!result)
+                    return { success: false, error: `Text "${text}" not found on screen` };
+                const cx = Math.round(result.x + result.width / 2);
+                const cy = Math.round(result.y + result.height / 2);
+                native.mouseClickAt(cx, cy, 'left', false);
+                return { success: true, clicked: text, x: cx, y: cy };
+            }
+            catch {
+                return { success: false, error: 'OCR unavailable' };
+            }
+        }, {
+            description: 'Find text on screen by OCR and click it directly. The easiest way to click buttons and UI elements by their visible label.',
+            parameters: {
+                text: { type: 'string', description: 'Visible text of the element to click', required: true },
+            },
+        });
+        this.registerTool('text_select_all', () => {
+            native.keyboardHotkey(['ctrl', 'a']);
+            return { success: true };
+        }, {
+            description: 'Select all text in the focused element (Ctrl+A)',
+        });
+        this.registerTool('text_select_word', () => {
+            native.mouseDoubleClick('left');
+            return { success: true };
+        }, {
+            description: 'Double-click to select a single word under the cursor',
+        });
+        this.registerTool('text_select_line', () => {
+            native.keyboardPress('Home');
+            native.keyboardHotkey(['shift', 'End']);
+            return { success: true };
+        }, {
+            description: 'Select the entire current line (Home then Shift+End)',
+        });
+        this.registerTool('text_cut', () => {
+            native.keyboardHotkey(['ctrl', 'x']);
+            return { success: true };
+        }, {
+            description: 'Cut selected text to clipboard (Ctrl+X)',
+        });
+        this.registerTool('text_copy', () => {
+            native.keyboardHotkey(['ctrl', 'c']);
+            return { success: true };
+        }, {
+            description: 'Copy selected text to clipboard (Ctrl+C)',
+        });
+        this.registerTool('text_paste', () => {
+            native.keyboardHotkey(['ctrl', 'v']);
+            return { success: true };
+        }, {
+            description: 'Paste clipboard contents (Ctrl+V)',
+        });
+        this.registerTool('text_undo', () => {
+            native.keyboardHotkey(['ctrl', 'z']);
+            return { success: true };
+        }, {
+            description: 'Undo the last action (Ctrl+Z)',
+        });
+        this.registerTool('text_redo', () => {
+            native.keyboardHotkey(['ctrl', 'y']);
+            return { success: true };
+        }, {
+            description: 'Redo the last undone action (Ctrl+Y)',
+        });
+        this.registerTool('text_replace', (find, replace) => {
+            // Read clipboard state, write find text, then type replacement
+            // Use clipboard to avoid slow key-by-key typing for find dialogs
+            const original = (() => { try {
+                return native.clipboardRead();
+            }
+            catch {
+                return '';
+            } })();
+            native.clipboardWrite(replace);
+            // Try Ctrl+H (most apps: find+replace)
+            native.keyboardHotkey(['ctrl', 'h']);
+            return { success: true, hint: `Opened Find & Replace. Find: "${find}", Replace: "${replace}" staged in clipboard.` };
+        }, {
+            description: 'Open the Find & Replace dialog in the active window and stage replacement text in clipboard',
+            parameters: {
+                find: { type: 'string', description: 'Text to find', required: true },
+                replace: { type: 'string', description: 'Replacement text', required: true },
+            },
+        });
+        this.registerTool('window_screenshot_context', (titleSubstring) => {
+            try {
+                // Get a specific window's context if title given, otherwise active
+                const windows = native.windowGetAll();
+                const target = titleSubstring
+                    ? windows.find((w) => w.title.toLowerCase().includes(titleSubstring.toLowerCase()) && w.isVisible)
+                    : native.windowGetActive();
+                if (!target)
+                    return { error: 'Window not found' };
+                // OCR the window region
+                const ocr = (() => {
+                    try {
+                        return native.ocrRecognize(target.x, target.y, target.width, target.height);
+                    }
+                    catch {
+                        return { text: '', words: [] };
+                    }
+                })();
+                return {
+                    title: target.title,
+                    process: target.processName,
+                    bounds: { x: target.x, y: target.y, width: target.width, height: target.height },
+                    text: ocr.text ?? '',
+                    wordCount: (ocr.words ?? []).length,
+                    words: (ocr.words ?? []).slice(0, 50).map((w) => ({
+                        text: w.text,
+                        x: w.x,
+                        y: w.y,
+                    })),
+                };
+            }
+            catch (e) {
+                return { error: e.message };
+            }
+        }, {
+            description: 'Get OCR text and element positions from a specific window. More focused than screen_context for a single app.',
+            parameters: {
+                titleSubstring: { type: 'string', description: 'Part of the window title to target. Omit for active window.' },
+            },
+        });
+        this.registerTool('scroll_to_text', async (text) => {
+            // Try to scroll until the text appears
+            for (let attempt = 0; attempt < 8; attempt++) {
+                try {
+                    const result = native.ocrFindText(text);
+                    if (result) {
+                        const cx = Math.round(result.x + result.width / 2);
+                        const cy = Math.round(result.y + result.height / 2);
+                        return { found: true, x: cx, y: cy };
+                    }
+                }
+                catch { /* ocr miss */ }
+                native.mouseScroll(3, 'down');
+                await new Promise(r => setTimeout(r, 300));
+            }
+            return { found: false, text };
+        }, {
+            description: 'Scroll down the page until text becomes visible, then return its position',
+            parameters: {
+                text: { type: 'string', description: 'Text to scroll until visible', required: true },
+            },
+            nonBlocking: true,
+        });
     }
     /**
      * Get all registered tool names.
@@ -1546,6 +1896,1006 @@ function customProvider(custom) {
     };
 }
 // ═════════════════════════════════════════════════════════════════════════════
+// SCHEMA TRANSLATION — Universal tool definition → provider-native format
+// ═════════════════════════════════════════════════════════════════════════════
+/**
+ * Convert Stelo ToolDefinition parameters to a standard JSON Schema "object"
+ * envelope, stripping Stelo's per-property `required: boolean` and building
+ * the spec-compliant `required: string[]` at the object level.
+ */
+function buildJsonSchemaObject(params) {
+    if (!params || Object.keys(params).length === 0) {
+        return { type: 'object', properties: {} };
+    }
+    const properties = {};
+    const required = [];
+    for (const [key, val] of Object.entries(params)) {
+        const { required: isReq, ...rest } = val;
+        properties[key] = rest;
+        if (isReq === true)
+            required.push(key);
+    }
+    const schema = { type: 'object', properties };
+    if (required.length > 0)
+        schema.required = required;
+    return schema;
+}
+/** Convert ToolDefinition[] → OpenAI Chat Completions tools format. */
+function toolsToOpenAIChat(tools) {
+    return tools
+        .filter(t => !t.name.startsWith('__'))
+        .map(t => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: buildJsonSchemaObject(t.parameters),
+        },
+    }));
+}
+/** Convert ToolDefinition[] → OpenAI Responses API tools format (flat, no function wrapper). */
+function toolsToOpenAIResponses(tools) {
+    return tools
+        .filter(t => !t.name.startsWith('__'))
+        .map(t => ({
+        type: 'function',
+        name: t.name,
+        description: t.description,
+        parameters: buildJsonSchemaObject(t.parameters),
+    }));
+}
+/** Convert ToolDefinition[] → Anthropic Claude tools format. */
+function toolsToAnthropic(tools) {
+    return tools
+        .filter(t => !t.name.startsWith('__'))
+        .map(t => ({
+        name: t.name,
+        description: t.description,
+        input_schema: buildJsonSchemaObject(t.parameters),
+    }));
+}
+// ═════════════════════════════════════════════════════════════════════════════
+// HTTP SSE STREAMING INFRASTRUCTURE
+// ═════════════════════════════════════════════════════════════════════════════
+/**
+ * Parse Server-Sent Events from a fetch Response.
+ * Handles both OpenAI-style (data-only) and Anthropic-style (event + data) SSE.
+ * Yields parsed JSON objects from `data:` lines (skipping `[DONE]`).
+ * If an `event:` line precedes a data line, its value is set as `type` on the
+ * parsed object when the object doesn't already have a `type` field.
+ */
+async function* parseSSE(response) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let currentEvent;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed === '') {
+                currentEvent = undefined;
+                continue;
+            }
+            if (trimmed.startsWith('event:')) {
+                currentEvent = trimmed.slice(trimmed.indexOf(':') + 1).trim();
+            }
+            else if (trimmed.startsWith('data:')) {
+                const data = trimmed.slice(trimmed.indexOf(':') + 1).trim();
+                if (data === '[DONE]')
+                    return;
+                try {
+                    const parsed = JSON.parse(data);
+                    if (currentEvent && !parsed.type)
+                        parsed.type = currentEvent;
+                    yield parsed;
+                }
+                catch { /* skip non-JSON data lines */ }
+            }
+        }
+    }
+}
+// ═════════════════════════════════════════════════════════════════════════════
+// OPENAI-COMPATIBLE CHAT PROVIDER (HTTP + SSE Streaming)
+// ═════════════════════════════════════════════════════════════════════════════
+//
+// Works with: OpenAI, Mistral, xAI/Grok, DeepSeek, Groq, Together, Fireworks,
+// Perplexity, SambaNova, Cerebras, LM Studio, Ollama, vLLM, and any endpoint
+// that speaks the OpenAI Chat Completions format.
+//
+/**
+ * Create a provider for any OpenAI-compatible Chat Completions API.
+ * This is the universal HTTP provider — one implementation, every endpoint.
+ *
+ * @example
+ * ```typescript
+ * // OpenAI
+ * await cortex.connect({
+ *   provider: openAIChatProvider(),
+ *   connection: { apiKey: 'sk-...', model: 'gpt-4.1' },
+ * });
+ *
+ * // Mistral
+ * await cortex.connect({
+ *   provider: openAIChatProvider({ baseUrl: 'https://api.mistral.ai/v1', name: 'mistral' }),
+ *   connection: { apiKey: 'your-key', model: 'mistral-large-latest' },
+ * });
+ *
+ * // Local Ollama
+ * await cortex.connect({
+ *   provider: openAIChatProvider({ baseUrl: 'http://localhost:11434/v1', name: 'ollama' }),
+ *   connection: { apiKey: 'ollama', model: 'llama3.1' },
+ * });
+ * ```
+ */
+function openAIChatProvider(options) {
+    return {
+        name: options?.name ?? 'openai-chat',
+        async connect(config, handlers) {
+            const baseUrl = (options?.baseUrl ?? config.providerOptions?.baseUrl ?? 'https://api.openai.com/v1').replace(/\/$/, '');
+            const maxTokens = config.providerOptions?.maxTokens ?? 8192;
+            const temperature = config.providerOptions?.temperature;
+            const messages = [];
+            if (config.systemInstruction) {
+                messages.push({ role: 'system', content: config.systemInstruction });
+            }
+            const tools = config.tools ? toolsToOpenAIChat(config.tools) : [];
+            let abortController = null;
+            let closed = false;
+            let pendingImage = null;
+            // Tool response batching for parallel tool calls
+            const toolResponseQueue = [];
+            let toolFlushTimer = null;
+            async function makeRequest() {
+                if (closed)
+                    return;
+                abortController = new AbortController();
+                const body = {
+                    model: config.model,
+                    messages,
+                    stream: true,
+                    stream_options: { include_usage: true },
+                    max_tokens: maxTokens,
+                };
+                if (tools.length > 0)
+                    body.tools = tools;
+                if (temperature !== undefined)
+                    body.temperature = temperature;
+                if (config.providerOptions?.parallelToolCalls !== undefined) {
+                    body.parallel_tool_calls = config.providerOptions.parallelToolCalls;
+                }
+                const headers = {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                    ...(config.providerOptions?.headers ?? {}),
+                };
+                try {
+                    const response = await fetch(`${baseUrl}/chat/completions`, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify(body),
+                        signal: abortController.signal,
+                    });
+                    if (!response.ok) {
+                        const errText = await response.text();
+                        handlers.error(new Error(`${baseUrl} ${response.status}: ${errText}`));
+                        return;
+                    }
+                    const accToolCalls = new Map();
+                    let assistantText = '';
+                    for await (const chunk of parseSSE(response)) {
+                        const delta = chunk.choices?.[0]?.delta;
+                        const finishReason = chunk.choices?.[0]?.finish_reason;
+                        if (delta?.content) {
+                            handlers.text(delta.content, false);
+                            assistantText += delta.content;
+                        }
+                        // Accumulate streamed tool calls
+                        if (delta?.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                const idx = tc.index ?? 0;
+                                if (!accToolCalls.has(idx))
+                                    accToolCalls.set(idx, { id: '', name: '', args: '' });
+                                const acc = accToolCalls.get(idx);
+                                if (tc.id)
+                                    acc.id = tc.id;
+                                if (tc.function?.name)
+                                    acc.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    acc.args += tc.function.arguments;
+                            }
+                        }
+                        if (finishReason === 'stop') {
+                            handlers.text('', true);
+                            if (assistantText) {
+                                messages.push({ role: 'assistant', content: assistantText });
+                            }
+                        }
+                        else if (finishReason === 'tool_calls' || finishReason === 'function_call') {
+                            // All tool calls complete — add assistant message, fire handlers
+                            const assistantMsg = { role: 'assistant', content: null, tool_calls: [] };
+                            for (const [, tc] of [...accToolCalls.entries()].sort((a, b) => a[0] - b[0])) {
+                                assistantMsg.tool_calls.push({
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: { name: tc.name, arguments: tc.args },
+                                });
+                                try {
+                                    handlers.toolCall(tc.id, tc.name, JSON.parse(tc.args || '{}'));
+                                }
+                                catch {
+                                    handlers.toolCall(tc.id, tc.name, {});
+                                }
+                            }
+                            messages.push(assistantMsg);
+                            accToolCalls.clear();
+                        }
+                        if (chunk.usage) {
+                            handlers.usage(chunk.usage.total_tokens ?? 0, chunk.usage.prompt_tokens ?? 0, chunk.usage.completion_tokens ?? 0);
+                        }
+                    }
+                    handlers.turnComplete();
+                }
+                catch (err) {
+                    if (err.name !== 'AbortError') {
+                        handlers.error(err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+                finally {
+                    abortController = null;
+                }
+            }
+            function flushToolResponses() {
+                if (toolResponseQueue.length === 0)
+                    return;
+                for (const { callId, result } of toolResponseQueue) {
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: callId,
+                        content: typeof result === 'string' ? result : JSON.stringify(result),
+                    });
+                }
+                toolResponseQueue.length = 0;
+                makeRequest();
+            }
+            const transport = {
+                sendAudio(_pcm, _sampleRate) {
+                    // HTTP Chat Completions does not support native audio streaming.
+                    // Use OpenAI Realtime or Gemini Live for audio.
+                },
+                sendVideo(jpeg) {
+                    pendingImage = jpeg;
+                },
+                sendText(text, role) {
+                    if (closed)
+                        return;
+                    if (role === 'system') {
+                        messages.push({ role: 'system', content: text });
+                    }
+                    else if (pendingImage) {
+                        messages.push({
+                            role: 'user',
+                            content: [
+                                { type: 'image_url', image_url: { url: `data:image/jpeg;base64,${pendingImage.toString('base64')}` } },
+                                { type: 'text', text },
+                            ],
+                        });
+                        pendingImage = null;
+                    }
+                    else {
+                        messages.push({ role: 'user', content: text });
+                    }
+                    makeRequest();
+                },
+                sendToolResponse(callId, result) {
+                    if (closed)
+                        return;
+                    toolResponseQueue.push({ callId, result });
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    toolFlushTimer = setTimeout(flushToolResponses, 50);
+                },
+                sendActivityStart() { },
+                sendActivityEnd() { },
+                interrupt() {
+                    if (abortController) {
+                        abortController.abort();
+                        handlers.interrupted();
+                    }
+                },
+                async close() {
+                    closed = true;
+                    if (abortController)
+                        abortController.abort();
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    handlers.close('closed');
+                },
+            };
+            return transport;
+        },
+    };
+}
+// ═════════════════════════════════════════════════════════════════════════════
+// GOOGLE GEMINI PROVIDER (HTTP + SSE Streaming)
+// ═════════════════════════════════════════════════════════════════════════════
+//
+// For the generateContent / streamGenerateContent REST API.
+// Use this when you don't need real-time audio (for audio, use geminiLiveProvider).
+//
+/**
+ * Google Gemini HTTP streaming provider (generateContent API).
+ * Uses SSE streaming. Supports tool calling, vision, thinking, and all Gemini models.
+ *
+ * @example
+ * ```typescript
+ * await cortex.connect({
+ *   provider: geminiProvider(),
+ *   connection: {
+ *     apiKey: 'YOUR_GEMINI_KEY',
+ *     model: 'gemini-2.5-flash',
+ *     systemInstruction: 'You are a desktop assistant.',
+ *   },
+ * });
+ * ```
+ */
+function geminiProvider() {
+    return {
+        name: 'gemini',
+        async connect(config, handlers) {
+            const apiVersion = config.providerOptions?.apiVersion ?? 'v1beta';
+            const host = config.providerOptions?.host ?? 'generativelanguage.googleapis.com';
+            const baseUrl = `https://${host}/${apiVersion}`;
+            // Conversation history (Gemini uses "user" and "model" roles)
+            const contents = [];
+            let abortController = null;
+            let closed = false;
+            let pendingImage = null;
+            // Build tool declarations
+            const toolsBlock = [];
+            if (config.tools && config.tools.length > 0) {
+                const functionTools = config.tools.filter(t => t.name !== '__googleSearch' && t.name !== '__codeExecution');
+                const useGoogleSearch = config.tools.some(t => t.name === '__googleSearch');
+                const useCodeExecution = config.tools.some(t => t.name === '__codeExecution');
+                if (functionTools.length > 0) {
+                    toolsBlock.push({
+                        function_declarations: functionTools.map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.parameters ? {
+                                type: 'OBJECT',
+                                properties: Object.fromEntries(Object.entries(t.parameters).map(([k, v]) => [k, cleanSchemaForGemini(v)])),
+                                required: Object.entries(t.parameters).filter(([, v]) => v.required).map(([k]) => k),
+                            } : undefined,
+                        })),
+                    });
+                }
+                if (useGoogleSearch)
+                    toolsBlock.push({ googleSearch: {} });
+                if (useCodeExecution)
+                    toolsBlock.push({ codeExecution: {} });
+            }
+            // Tool response batching
+            const toolResponseQueue = [];
+            let toolFlushTimer = null;
+            // Map callId → function name for tool responses
+            const callIdToName = new Map();
+            async function makeRequest() {
+                if (closed || contents.length === 0)
+                    return;
+                abortController = new AbortController();
+                const body = { contents };
+                if (config.systemInstruction) {
+                    body.system_instruction = { parts: [{ text: config.systemInstruction }] };
+                }
+                if (toolsBlock.length > 0)
+                    body.tools = toolsBlock;
+                const generationConfig = {};
+                if (config.providerOptions?.maxTokens)
+                    generationConfig.maxOutputTokens = config.providerOptions.maxTokens;
+                if (config.providerOptions?.temperature !== undefined)
+                    generationConfig.temperature = config.providerOptions.temperature;
+                if (config.providerOptions?.thinkingLevel) {
+                    generationConfig.thinking_config = { thinking_level: config.providerOptions.thinkingLevel };
+                }
+                if (Object.keys(generationConfig).length > 0)
+                    body.generationConfig = generationConfig;
+                const url = `${baseUrl}/models/${config.model}:streamGenerateContent?key=${config.apiKey}&alt=sse`;
+                try {
+                    const response = await fetch(url, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(body),
+                        signal: abortController.signal,
+                    });
+                    if (!response.ok) {
+                        const errText = await response.text();
+                        handlers.error(new Error(`Gemini ${response.status}: ${errText}`));
+                        return;
+                    }
+                    const modelParts = [];
+                    let textBuffer = '';
+                    for await (const chunk of parseSSE(response)) {
+                        const candidate = chunk.candidates?.[0];
+                        if (!candidate)
+                            continue;
+                        if (candidate.content?.parts) {
+                            for (const part of candidate.content.parts) {
+                                if (part.text !== undefined) {
+                                    handlers.text(part.text, false);
+                                    textBuffer += part.text;
+                                }
+                                if (part.functionCall) {
+                                    const callId = `gemini_${Date.now()}_${part.functionCall.name}`;
+                                    callIdToName.set(callId, part.functionCall.name);
+                                    modelParts.push({ functionCall: part.functionCall });
+                                    handlers.toolCall(callId, part.functionCall.name, part.functionCall.args ?? {});
+                                }
+                                if (part.thought) {
+                                    handlers.thought(typeof part.thought === 'string' ? part.thought : part.thought.text ?? '');
+                                }
+                            }
+                        }
+                        if (candidate.finishReason) {
+                            if (textBuffer) {
+                                modelParts.push({ text: textBuffer });
+                                handlers.text('', true);
+                            }
+                        }
+                        if (chunk.usageMetadata) {
+                            handlers.usage(chunk.usageMetadata.totalTokenCount ?? 0, chunk.usageMetadata.promptTokenCount ?? 0, chunk.usageMetadata.candidatesTokenCount ?? 0);
+                        }
+                    }
+                    // Add model turn to conversation history
+                    if (modelParts.length > 0) {
+                        contents.push({ role: 'model', parts: modelParts });
+                    }
+                    handlers.turnComplete();
+                }
+                catch (err) {
+                    if (err.name !== 'AbortError') {
+                        handlers.error(err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+                finally {
+                    abortController = null;
+                }
+            }
+            function flushToolResponses() {
+                if (toolResponseQueue.length === 0)
+                    return;
+                // Gemini: tool responses go as a user turn with functionResponse parts
+                const parts = toolResponseQueue.map(({ name, result }) => ({
+                    functionResponse: {
+                        name,
+                        response: typeof result === 'string' ? { output: result } : { output: JSON.stringify(result) },
+                    },
+                }));
+                toolResponseQueue.length = 0;
+                contents.push({ role: 'user', parts });
+                makeRequest();
+            }
+            const transport = {
+                sendAudio(_pcm, _sampleRate) {
+                    // HTTP Gemini doesn't support streaming audio. Use geminiLiveProvider.
+                },
+                sendVideo(jpeg) { pendingImage = jpeg; },
+                sendText(text, role) {
+                    if (closed)
+                        return;
+                    const parts = [];
+                    if (pendingImage) {
+                        parts.push({
+                            inlineData: {
+                                mimeType: 'image/jpeg',
+                                data: pendingImage.toString('base64'),
+                            },
+                        });
+                        pendingImage = null;
+                    }
+                    parts.push({ text: role === 'system' ? `[System]: ${text}` : text });
+                    contents.push({ role: 'user', parts });
+                    makeRequest();
+                },
+                sendToolResponse(callId, result) {
+                    if (closed)
+                        return;
+                    const name = callIdToName.get(callId) ?? callId;
+                    callIdToName.delete(callId);
+                    toolResponseQueue.push({ name, result });
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    toolFlushTimer = setTimeout(flushToolResponses, 50);
+                },
+                sendActivityStart() { },
+                sendActivityEnd() { },
+                interrupt() {
+                    if (abortController) {
+                        abortController.abort();
+                        handlers.interrupted();
+                    }
+                },
+                async close() {
+                    closed = true;
+                    if (abortController)
+                        abortController.abort();
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    handlers.close('closed');
+                },
+            };
+            return transport;
+        },
+    };
+}
+// ─── Pre-configured OpenAI-compatible provider shortcuts ────────────────────
+/** Mistral AI provider. */
+function mistralProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.mistral.ai/v1', name: 'mistral' });
+}
+/** xAI / Grok provider. */
+function xaiProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.x.ai/v1', name: 'xai' });
+}
+/** DeepSeek provider. */
+function deepSeekProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.deepseek.com', name: 'deepseek' });
+}
+/** Groq provider (fast inference). */
+function groqProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.groq.com/openai/v1', name: 'groq' });
+}
+/** Together AI provider. */
+function togetherProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.together.xyz/v1', name: 'together' });
+}
+/** Fireworks AI provider. */
+function fireworksProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.fireworks.ai/inference/v1', name: 'fireworks' });
+}
+/** Perplexity provider. */
+function perplexityProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.perplexity.ai', name: 'perplexity' });
+}
+/** SambaNova provider. */
+function sambanovaProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.sambanova.ai/v1', name: 'sambanova' });
+}
+/** Cerebras provider (fast inference). */
+function cerebrasProvider() {
+    return openAIChatProvider({ baseUrl: 'https://api.cerebras.ai/v1', name: 'cerebras' });
+}
+// ═════════════════════════════════════════════════════════════════════════════
+// OPENAI RESPONSES API PROVIDER (HTTP + SSE Streaming)
+// ═════════════════════════════════════════════════════════════════════════════
+/**
+ * Provider for OpenAI's newer Responses API (stateful conversation chaining).
+ *
+ * @example
+ * ```typescript
+ * await cortex.connect({
+ *   provider: openAIResponsesProvider(),
+ *   connection: { apiKey: 'sk-...', model: 'gpt-4.1' },
+ * });
+ * ```
+ */
+function openAIResponsesProvider() {
+    return {
+        name: 'openai-responses',
+        async connect(config, handlers) {
+            const baseUrl = (config.providerOptions?.baseUrl ?? 'https://api.openai.com/v1').replace(/\/$/, '');
+            const tools = config.tools ? toolsToOpenAIResponses(config.tools) : [];
+            let abortController = null;
+            let closed = false;
+            let previousResponseId = null;
+            let pendingImage = null;
+            // Tool response batching
+            const toolResponseQueue = [];
+            let toolFlushTimer = null;
+            async function makeRequest(input) {
+                if (closed)
+                    return;
+                abortController = new AbortController();
+                const body = {
+                    model: config.model,
+                    input,
+                    stream: true,
+                };
+                if (config.systemInstruction)
+                    body.instructions = config.systemInstruction;
+                if (tools.length > 0)
+                    body.tools = tools;
+                if (previousResponseId)
+                    body.previous_response_id = previousResponseId;
+                if (config.providerOptions?.maxTokens)
+                    body.max_output_tokens = config.providerOptions.maxTokens;
+                if (config.providerOptions?.temperature !== undefined)
+                    body.temperature = config.providerOptions.temperature;
+                const headers = {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                };
+                try {
+                    const response = await fetch(`${baseUrl}/responses`, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify(body),
+                        signal: abortController.signal,
+                    });
+                    if (!response.ok) {
+                        const errText = await response.text();
+                        handlers.error(new Error(`OpenAI Responses ${response.status}: ${errText}`));
+                        return;
+                    }
+                    // Map item_id → { callId, name } for function calls
+                    const itemToCallId = new Map();
+                    for await (const event of parseSSE(response)) {
+                        switch (event.type) {
+                            case 'response.output_item.added':
+                                if (event.item?.type === 'function_call') {
+                                    itemToCallId.set(event.item.id, {
+                                        callId: event.item.call_id,
+                                        name: event.item.name,
+                                    });
+                                }
+                                break;
+                            case 'response.text.delta':
+                            case 'response.output_text.delta':
+                                if (event.delta)
+                                    handlers.text(event.delta, false);
+                                break;
+                            case 'response.text.done':
+                            case 'response.output_text.done':
+                                handlers.text('', true);
+                                break;
+                            case 'response.output_item.done':
+                                if (event.item?.type === 'function_call') {
+                                    try {
+                                        const args = JSON.parse(event.item.arguments ?? '{}');
+                                        handlers.toolCall(event.item.call_id, event.item.name, args);
+                                    }
+                                    catch {
+                                        handlers.toolCall(event.item.call_id, event.item.name ?? '', {});
+                                    }
+                                }
+                                break;
+                            case 'response.function_call_arguments.done': {
+                                // Fallback: if we didn't get output_item.done for function calls
+                                const mapping = itemToCallId.get(event.item_id);
+                                if (mapping) {
+                                    try {
+                                        const args = JSON.parse(event.arguments ?? '{}');
+                                        handlers.toolCall(mapping.callId, mapping.name, args);
+                                    }
+                                    catch {
+                                        handlers.toolCall(mapping.callId, mapping.name, {});
+                                    }
+                                }
+                                break;
+                            }
+                            case 'response.completed':
+                                if (event.response?.id)
+                                    previousResponseId = event.response.id;
+                                if (event.response?.usage) {
+                                    handlers.usage(event.response.usage.total_tokens ?? 0, event.response.usage.input_tokens ?? 0, event.response.usage.output_tokens ?? 0);
+                                }
+                                handlers.turnComplete();
+                                break;
+                            case 'response.failed':
+                            case 'error':
+                                handlers.error(new Error(`OpenAI Responses: ${event.error?.message ?? event.response?.error?.message ?? JSON.stringify(event)}`));
+                                break;
+                            case 'response.audio.delta':
+                                if (event.delta)
+                                    handlers.audio(Buffer.from(event.delta, 'base64'), 24000);
+                                break;
+                            case 'response.audio_transcript.delta':
+                                if (event.delta)
+                                    handlers.transcript(event.delta, 'model', false);
+                                break;
+                            case 'response.audio_transcript.done':
+                                if (event.transcript)
+                                    handlers.transcript(event.transcript, 'model', true);
+                                break;
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err.name !== 'AbortError') {
+                        handlers.error(err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+                finally {
+                    abortController = null;
+                }
+            }
+            function flushToolResponses() {
+                if (toolResponseQueue.length === 0)
+                    return;
+                const input = toolResponseQueue.map(({ callId, result }) => ({
+                    type: 'function_call_output',
+                    call_id: callId,
+                    output: typeof result === 'string' ? result : JSON.stringify(result),
+                }));
+                toolResponseQueue.length = 0;
+                makeRequest(input);
+            }
+            const transport = {
+                sendAudio(_pcm, _sampleRate) {
+                    // Responses API does not support realtime audio streaming.
+                    // Use OpenAI Realtime provider for audio.
+                },
+                sendVideo(jpeg) { pendingImage = jpeg; },
+                sendText(text, role) {
+                    if (closed)
+                        return;
+                    const input = [];
+                    if (pendingImage) {
+                        input.push({
+                            role: role === 'system' ? 'developer' : 'user',
+                            content: [
+                                { type: 'input_image', image_url: `data:image/jpeg;base64,${pendingImage.toString('base64')}` },
+                                { type: 'input_text', text },
+                            ],
+                        });
+                        pendingImage = null;
+                    }
+                    else {
+                        input.push({ role: role === 'system' ? 'developer' : 'user', content: text });
+                    }
+                    makeRequest(input);
+                },
+                sendToolResponse(callId, result) {
+                    if (closed)
+                        return;
+                    toolResponseQueue.push({ callId, result });
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    toolFlushTimer = setTimeout(flushToolResponses, 50);
+                },
+                sendActivityStart() { },
+                sendActivityEnd() { },
+                interrupt() {
+                    if (abortController) {
+                        abortController.abort();
+                        handlers.interrupted();
+                    }
+                },
+                async close() {
+                    closed = true;
+                    if (abortController)
+                        abortController.abort();
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    handlers.close('closed');
+                },
+            };
+            return transport;
+        },
+    };
+}
+// ═════════════════════════════════════════════════════════════════════════════
+// ANTHROPIC CLAUDE PROVIDER (HTTP + SSE Streaming)
+// ═════════════════════════════════════════════════════════════════════════════
+/**
+ * Anthropic Claude Messages API provider.
+ * Supports tool calling, vision (images), and extended thinking.
+ *
+ * @example
+ * ```typescript
+ * await cortex.connect({
+ *   provider: anthropicProvider(),
+ *   connection: {
+ *     apiKey: 'sk-ant-...',
+ *     model: 'claude-sonnet-4-20250514',
+ *     systemInstruction: 'You are a desktop assistant.',
+ *     providerOptions: { maxTokens: 4096 },
+ *   },
+ * });
+ * ```
+ */
+function anthropicProvider() {
+    return {
+        name: 'anthropic',
+        async connect(config, handlers) {
+            const baseUrl = (config.providerOptions?.baseUrl ?? 'https://api.anthropic.com').replace(/\/$/, '');
+            const apiVersion = config.providerOptions?.apiVersion ?? '2023-06-01';
+            const maxTokens = config.providerOptions?.maxTokens ?? 8192;
+            const messages = [];
+            const tools = config.tools ? toolsToAnthropic(config.tools) : [];
+            let abortController = null;
+            let closed = false;
+            let pendingImage = null;
+            // Tool response batching (Claude requires all tool_results in one user message)
+            const toolResponseQueue = [];
+            let toolFlushTimer = null;
+            async function makeRequest() {
+                if (closed || messages.length === 0)
+                    return;
+                abortController = new AbortController();
+                const body = {
+                    model: config.model,
+                    max_tokens: maxTokens,
+                    messages,
+                    stream: true,
+                };
+                if (config.systemInstruction)
+                    body.system = config.systemInstruction;
+                if (tools.length > 0)
+                    body.tools = tools;
+                if (config.providerOptions?.temperature !== undefined)
+                    body.temperature = config.providerOptions.temperature;
+                const headers = {
+                    'Content-Type': 'application/json',
+                    'x-api-key': config.apiKey,
+                    'anthropic-version': apiVersion,
+                    ...(config.providerOptions?.headers ?? {}),
+                };
+                try {
+                    const response = await fetch(`${baseUrl}/v1/messages`, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify(body),
+                        signal: abortController.signal,
+                    });
+                    if (!response.ok) {
+                        const errText = await response.text();
+                        handlers.error(new Error(`Anthropic ${response.status}: ${errText}`));
+                        return;
+                    }
+                    let currentToolId = '';
+                    let currentToolName = '';
+                    let toolJsonBuffer = '';
+                    let textBuffer = '';
+                    const assistantContent = [];
+                    for await (const event of parseSSE(response)) {
+                        switch (event.type) {
+                            case 'content_block_start':
+                                if (event.content_block?.type === 'tool_use') {
+                                    currentToolId = event.content_block.id;
+                                    currentToolName = event.content_block.name;
+                                    toolJsonBuffer = '';
+                                }
+                                else if (event.content_block?.type === 'text') {
+                                    textBuffer = '';
+                                }
+                                break;
+                            case 'content_block_delta':
+                                if (event.delta?.type === 'text_delta') {
+                                    handlers.text(event.delta.text, false);
+                                    textBuffer += event.delta.text;
+                                }
+                                else if (event.delta?.type === 'input_json_delta') {
+                                    toolJsonBuffer += event.delta.partial_json;
+                                }
+                                else if (event.delta?.type === 'thinking_delta') {
+                                    handlers.thought(event.delta.thinking);
+                                }
+                                break;
+                            case 'content_block_stop':
+                                if (currentToolId) {
+                                    try {
+                                        const args = toolJsonBuffer ? JSON.parse(toolJsonBuffer) : {};
+                                        assistantContent.push({
+                                            type: 'tool_use',
+                                            id: currentToolId,
+                                            name: currentToolName,
+                                            input: args,
+                                        });
+                                        handlers.toolCall(currentToolId, currentToolName, args);
+                                    }
+                                    catch { /* parse error */ }
+                                    currentToolId = '';
+                                    currentToolName = '';
+                                    toolJsonBuffer = '';
+                                }
+                                else if (textBuffer) {
+                                    assistantContent.push({ type: 'text', text: textBuffer });
+                                    handlers.text('', true);
+                                    textBuffer = '';
+                                }
+                                break;
+                            case 'message_delta':
+                                if (event.usage) {
+                                    handlers.usage((event.usage.input_tokens ?? 0) + (event.usage.output_tokens ?? 0), event.usage.input_tokens ?? 0, event.usage.output_tokens ?? 0);
+                                }
+                                break;
+                            case 'message_stop':
+                                if (assistantContent.length > 0) {
+                                    messages.push({ role: 'assistant', content: assistantContent });
+                                }
+                                handlers.turnComplete();
+                                break;
+                            case 'error':
+                                handlers.error(new Error(`Anthropic: ${event.error?.message ?? JSON.stringify(event)}`));
+                                break;
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err.name !== 'AbortError') {
+                        handlers.error(err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+                finally {
+                    abortController = null;
+                }
+            }
+            function flushToolResponses() {
+                if (toolResponseQueue.length === 0)
+                    return;
+                // Anthropic: all tool results go in one user message as tool_result blocks
+                const content = toolResponseQueue.map(({ callId, result }) => ({
+                    type: 'tool_result',
+                    tool_use_id: callId,
+                    content: typeof result === 'string' ? result : JSON.stringify(result),
+                }));
+                toolResponseQueue.length = 0;
+                messages.push({ role: 'user', content });
+                makeRequest();
+            }
+            const transport = {
+                sendAudio(_pcm, _sampleRate) {
+                    // Claude does not process raw audio natively.
+                },
+                sendVideo(jpeg) { pendingImage = jpeg; },
+                sendText(text, role) {
+                    if (closed)
+                        return;
+                    const content = [];
+                    if (pendingImage) {
+                        content.push({
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: 'image/jpeg',
+                                data: pendingImage.toString('base64'),
+                            },
+                        });
+                        pendingImage = null;
+                    }
+                    content.push({
+                        type: 'text',
+                        text: role === 'system' ? `[System]: ${text}` : text,
+                    });
+                    messages.push({ role: 'user', content });
+                    makeRequest();
+                },
+                sendToolResponse(callId, result) {
+                    if (closed)
+                        return;
+                    toolResponseQueue.push({ callId, result });
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    toolFlushTimer = setTimeout(flushToolResponses, 50);
+                },
+                sendActivityStart() { },
+                sendActivityEnd() { },
+                interrupt() {
+                    if (abortController) {
+                        abortController.abort();
+                        handlers.interrupted();
+                    }
+                },
+                async close() {
+                    closed = true;
+                    if (abortController)
+                        abortController.abort();
+                    if (toolFlushTimer)
+                        clearTimeout(toolFlushTimer);
+                    handlers.close('closed');
+                },
+            };
+            return transport;
+        },
+    };
+}
+// ═════════════════════════════════════════════════════════════════════════════
 // FACTORY
 // ═════════════════════════════════════════════════════════════════════════════
 /** Create a new Cortex instance. */