openplanter 0.1.0

package/dist/model.js

@@ -0,0 +1,1071 @@
+import * as https from 'node:https';
+import * as http from 'node:http';
+import { URL } from 'node:url';
+import { TOOL_DEFINITIONS, to_openai_tools, to_anthropic_tools, } from './tool-defs.js';
+// Re-export tool helpers so consumers can reach them via the model module.
+export { TOOL_DEFINITIONS, to_openai_tools, to_anthropic_tools };
+// ---------------------------------------------------------------------------
+// Error type
+// ---------------------------------------------------------------------------
+export class ModelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ModelError';
+    }
+}
+const _DEFAULT_USER_AGENT = 'OpenPlanter/0.1';
+/** Opaque conversation state owned by the model layer. */
+export class Conversation {
+    _provider_messages;
+    system_prompt;
+    turn_count;
+    stop_sequences;
+    constructor(opts) {
+        this._provider_messages = opts?._provider_messages ?? [];
+        this.system_prompt = opts?.system_prompt ?? '';
+        this.turn_count = opts?.turn_count ?? 0;
+        this.stop_sequences = opts?.stop_sequences ?? [];
+    }
+    /** Return a shallow copy of the provider messages list. */
+    getMessages() {
+        return [...this._provider_messages];
+    }
+}
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+export function _extractContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const textParts = [];
+        for (const part of content) {
+            if (typeof part !== 'object' || part === null)
+                continue;
+            const rec = part;
+            const maybeText = rec['text'];
+            if (typeof maybeText === 'string') {
+                textParts.push(maybeText);
+                continue;
+            }
+            if (rec['type'] === 'text') {
+                const nested = rec['text'];
+                if (typeof nested === 'string') {
+                    textParts.push(nested);
+                }
+            }
+        }
+        return textParts.join('\n');
+    }
+    return '';
+}
+// ---------------------------------------------------------------------------
+// HTTP JSON helper (uses native fetch)
+// ---------------------------------------------------------------------------
+async function _httpJson(url, method, headers, payload, timeoutSec = 90) {
+    const merged = { 'User-Agent': _DEFAULT_USER_AGENT, ...headers };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutSec * 1000);
+    let resp;
+    try {
+        resp = await fetch(url, {
+            method,
+            headers: merged,
+            body: payload != null ? JSON.stringify(payload) : undefined,
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof DOMException && err.name === 'AbortError') {
+            throw new ModelError(`Timeout calling ${url}`);
+        }
+        throw new ModelError(`Connection error calling ${url}: ${err}`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    const raw = await resp.text();
+    if (!resp.ok) {
+        throw new ModelError(`HTTP ${resp.status} calling ${url}: ${raw}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new ModelError(`Non-JSON response from ${url}: ${raw.slice(0, 500)}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new ModelError(`Unexpected non-object JSON from ${url}: ${typeof parsed}`);
+    }
+    return parsed;
+}
+// ---------------------------------------------------------------------------
+// SSE reader (from a Node.js IncomingMessage stream)
+// ---------------------------------------------------------------------------
+function _readSseEvents(lines, onSseEvent) {
+    const events = [];
+    let currentEvent = '';
+    let currentDataLines = [];
+    function flush() {
+        if (currentDataLines.length === 0)
+            return;
+        const joined = currentDataLines.join('\n');
+        let dataDict;
+        try {
+            dataDict = JSON.parse(joined);
+        }
+        catch {
+            dataDict = { _raw: joined };
+        }
+        if (typeof dataDict === 'object' && dataDict !== null && !Array.isArray(dataDict)) {
+            // Check for Anthropic error events
+            if (dataDict['type'] === 'error') {
+                const errObj = dataDict['error'];
+                const errMsg = typeof errObj === 'object' && errObj !== null
+                    ? errObj['message'] ?? JSON.stringify(dataDict)
+                    : JSON.stringify(dataDict);
+                throw new ModelError(`Stream error: ${errMsg}`);
+            }
+            events.push([currentEvent, dataDict]);
+            if (onSseEvent) {
+                try {
+                    onSseEvent(currentEvent, dataDict);
+                }
+                catch {
+                    // Swallow callback errors like the Python version
+                }
+            }
+        }
+        currentDataLines = [];
+        currentEvent = '';
+    }
+    for (const line of lines) {
+        if (line.startsWith('event:')) {
+            currentEvent = line.slice('event:'.length).trim();
+            continue;
+        }
+        if (line.startsWith('data:')) {
+            const dataStr = line.slice('data:'.length).trim();
+            if (dataStr === '[DONE]') {
+                break;
+            }
+            currentDataLines.push(dataStr);
+            continue;
+        }
+        // Empty line = end of SSE message
+        if (line === '') {
+            flush();
+            continue;
+        }
+    }
+    // Flush remaining data (some servers don't end with empty line)
+    flush();
+    return events;
+}
+// ---------------------------------------------------------------------------
+// SSE streaming via Node http/https modules
+// ---------------------------------------------------------------------------
+function _httpStreamSseRaw(url, method, headers, payload, firstByteTimeout, streamTimeout) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const isHttps = parsed.protocol === 'https:';
+        const transport = isHttps ? https : http;
+        const data = JSON.stringify(payload);
+        const merged = {
+            'User-Agent': _DEFAULT_USER_AGENT,
+            'Content-Length': String(Buffer.byteLength(data, 'utf-8')),
+            ...headers,
+        };
+        const reqOpts = {
+            hostname: parsed.hostname,
+            port: parsed.port || (isHttps ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method,
+            headers: merged,
+            timeout: firstByteTimeout * 1000,
+        };
+        const req = transport.request(reqOpts, (resp) => {
+            // Check for HTTP errors
+            const statusCode = resp.statusCode ?? 0;
+            if (statusCode >= 400) {
+                let body = '';
+                resp.setEncoding('utf-8');
+                resp.on('data', (chunk) => { body += chunk; });
+                resp.on('end', () => {
+                    reject(new ModelError(`HTTP ${statusCode} calling ${url}: ${body}`));
+                });
+                return;
+            }
+            // Extend timeout for stream reading
+            resp.setTimeout(streamTimeout * 1000);
+            req.setTimeout(streamTimeout * 1000);
+            const lines = [];
+            let buffer = '';
+            resp.setEncoding('utf-8');
+            resp.on('data', (chunk) => {
+                buffer += chunk;
+                const parts = buffer.split('\n');
+                // Keep the last (possibly incomplete) part in the buffer
+                buffer = parts.pop() ?? '';
+                for (const part of parts) {
+                    lines.push(part.replace(/\r$/, ''));
+                }
+            });
+            resp.on('end', () => {
+                // Flush any remaining buffer
+                if (buffer.length > 0) {
+                    lines.push(buffer.replace(/\r$/, ''));
+                }
+                resolve(lines);
+            });
+            resp.on('error', (err) => {
+                reject(err);
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('timeout'));
+        });
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.write(data);
+        req.end();
+    });
+}
+async function _httpStreamSse(url, method, headers, payload, firstByteTimeout = 10, streamTimeout = 120, maxRetries = 3, onSseEvent) {
+    let lastExc = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const lines = await _httpStreamSseRaw(url, method, headers, payload, firstByteTimeout, streamTimeout);
+            return _readSseEvents(lines, onSseEvent);
+        }
+        catch (err) {
+            // If it's a ModelError (HTTP error), rethrow immediately (don't retry)
+            if (err instanceof ModelError) {
+                throw err;
+            }
+            // Timeout or connection error — retry
+            lastExc = err;
+            continue;
+        }
+    }
+    throw new ModelError(`Timed out after ${maxRetries} attempts calling ${url}: ${lastExc}`);
+}
+// ---------------------------------------------------------------------------
+// SSE stream accumulators
+// ---------------------------------------------------------------------------
+export function _accumulateOpenaiStream(events) {
+    const textParts = [];
+    const toolCallsByIndex = new Map();
+    let finishReason = '';
+    let usage = {};
+    for (const [, chunk] of events) {
+        // Usage may appear in a dedicated chunk or alongside the last delta
+        if (chunk['usage'] && typeof chunk['usage'] === 'object') {
+            usage = chunk['usage'];
+        }
+        const choices = chunk['choices'];
+        if (!choices || !Array.isArray(choices) || choices.length === 0)
+            continue;
+        const choice = choices[0];
+        const fr = choice['finish_reason'];
+        if (fr && typeof fr === 'string') {
+            finishReason = fr;
+        }
+        const delta = (choice['delta'] ?? {});
+        if (!delta || typeof delta !== 'object')
+            continue;
+        // Text content
+        const content = delta['content'];
+        if (typeof content === 'string' && content) {
+            textParts.push(content);
+        }
+        // Tool calls (streamed incrementally)
+        const tcDeltas = delta['tool_calls'];
+        if (tcDeltas && Array.isArray(tcDeltas)) {
+            for (const tcDelta of tcDeltas) {
+                const td = tcDelta;
+                const idx = (typeof td['index'] === 'number' ? td['index'] : 0);
+                if (!toolCallsByIndex.has(idx)) {
+                    toolCallsByIndex.set(idx, {
+                        id: td['id'] ?? '',
+                        type: 'function',
+                        function: { name: '', arguments: '' },
+                    });
+                }
+                const tc = toolCallsByIndex.get(idx);
+                if (td['id'] && typeof td['id'] === 'string') {
+                    tc['id'] = td['id'];
+                }
+                const func = (td['function'] ?? {});
+                const tcFunc = tc['function'];
+                if (func['name'] && typeof func['name'] === 'string') {
+                    tcFunc['name'] = func['name'];
+                }
+                if (func['arguments'] && typeof func['arguments'] === 'string') {
+                    tcFunc['arguments'] += func['arguments'];
+                }
+            }
+        }
+    }
+    // Build the final message
+    const message = {
+        role: 'assistant',
+        content: textParts.length > 0 ? textParts.join('') : null,
+    };
+    if (toolCallsByIndex.size > 0) {
+        const sortedIndices = Array.from(toolCallsByIndex.keys()).sort((a, b) => a - b);
+        message['tool_calls'] = sortedIndices.map((i) => toolCallsByIndex.get(i));
+    }
+    else {
+        message['tool_calls'] = null;
+    }
+    const result = {
+        choices: [{ message, finish_reason: finishReason }],
+    };
+    if (Object.keys(usage).length > 0) {
+        result['usage'] = usage;
+    }
+    return result;
+}
+export function _accumulateAnthropicStream(events) {
+    const blocksByIndex = new Map();
+    let stopReason = '';
+    let usage = {};
+    for (const [eventType, data] of events) {
+        const msgType = data['type'] ?? eventType;
+        if (msgType === 'message_start') {
+            const msg = (data['message'] ?? {});
+            const msgUsage = msg['usage'];
+            if (msgUsage && typeof msgUsage === 'object') {
+                usage = { ...usage, ...msgUsage };
+            }
+        }
+        else if (msgType === 'content_block_start') {
+            const idx = typeof data['index'] === 'number' ? data['index'] : blocksByIndex.size;
+            const block = (data['content_block'] ?? {});
+            const btype = block['type'] ?? 'text';
+            if (btype === 'text') {
+                blocksByIndex.set(idx, {
+                    type: 'text',
+                    text: block['text'] ?? '',
+                });
+            }
+            else if (btype === 'tool_use') {
+                blocksByIndex.set(idx, {
+                    type: 'tool_use',
+                    id: block['id'] ?? '',
+                    name: block['name'] ?? '',
+                    input: {},
+                    _input_json: '',
+                });
+            }
+            else if (btype === 'thinking') {
+                blocksByIndex.set(idx, {
+                    type: 'thinking',
+                    thinking: block['thinking'] ?? '',
+                });
+            }
+            else {
+                blocksByIndex.set(idx, { ...block });
+            }
+        }
+        else if (msgType === 'content_block_delta') {
+            const idx = typeof data['index'] === 'number' ? data['index'] : 0;
+            const delta = (data['delta'] ?? {});
+            const deltaType = delta['type'] ?? '';
+            const block = blocksByIndex.get(idx);
+            if (block == null)
+                continue;
+            if (deltaType === 'text_delta') {
+                block['text'] =
+                    (block['text'] ?? '') +
+                        (delta['text'] ?? '');
+            }
+            else if (deltaType === 'input_json_delta') {
+                block['_input_json'] =
+                    (block['_input_json'] ?? '') +
+                        (delta['partial_json'] ?? '');
+            }
+            else if (deltaType === 'thinking_delta') {
+                block['thinking'] =
+                    (block['thinking'] ?? '') +
+                        (delta['thinking'] ?? '');
+            }
+            else if (deltaType === 'signature_delta') {
+                block['signature'] = delta['signature'] ?? '';
+            }
+        }
+        else if (msgType === 'content_block_stop') {
+            const idx = typeof data['index'] === 'number' ? data['index'] : 0;
+            const block = blocksByIndex.get(idx);
+            if (block && block['type'] === 'tool_use') {
+                const rawJson = block['_input_json'] ?? '';
+                delete block['_input_json'];
+                if (rawJson) {
+                    try {
+                        block['input'] = JSON.parse(rawJson);
+                    }
+                    catch {
+                        block['input'] = {};
+                    }
+                }
+            }
+        }
+        else if (msgType === 'message_delta') {
+            const delta = (data['delta'] ?? {});
+            if (delta['stop_reason'] && typeof delta['stop_reason'] === 'string') {
+                stopReason = delta['stop_reason'];
+            }
+            const deltaUsage = data['usage'];
+            if (deltaUsage && typeof deltaUsage === 'object') {
+                usage = { ...usage, ...deltaUsage };
+            }
+        }
+        // message_stop: end of stream, nothing to do
+    }
+    // Finalize content blocks in index order
+    const contentBlocks = [];
+    const sortedIndices = Array.from(blocksByIndex.keys()).sort((a, b) => a - b);
+    for (const idx of sortedIndices) {
+        const block = blocksByIndex.get(idx);
+        delete block['_input_json'];
+        contentBlocks.push(block);
+    }
+    return {
+        content: contentBlocks,
+        stop_reason: stopReason,
+        usage,
+    };
+}
+// ---------------------------------------------------------------------------
+// Utility functions
+// ---------------------------------------------------------------------------
+export function _parseTimestamp(value) {
+    if (typeof value === 'number') {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const text = value.trim();
+        if (!text)
+            return 0;
+        if (/^\d+$/.test(text))
+            return parseInt(text, 10);
+        // Try ISO date parsing
+        const isoCandidate = text.replace('Z', '+00:00');
+        const dt = new Date(isoCandidate);
+        if (!isNaN(dt.getTime())) {
+            return Math.floor(dt.getTime() / 1000);
+        }
+        return 0;
+    }
+    return 0;
+}
+export function _sortedModels(models) {
+    return [...models].sort((a, b) => {
+        const aTs = (typeof a['created_ts'] === 'number' ? a['created_ts'] : 0);
+        const bTs = (typeof b['created_ts'] === 'number' ? b['created_ts'] : 0);
+        if (bTs !== aTs)
+            return bTs - aTs;
+        const aId = String(a['id'] ?? '');
+        const bId = String(b['id'] ?? '');
+        return bId.localeCompare(aId);
+    });
+}
+// ---------------------------------------------------------------------------
+// Model listing functions
+// ---------------------------------------------------------------------------
+export async function listOpenaiModels(apiKey, baseUrl = 'https://api.openai.com/v1', timeoutSec = 60) {
+    const parsed = await _httpJson(baseUrl.replace(/\/+$/, '') + '/models', 'GET', {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+    }, null, timeoutSec);
+    const rows = [];
+    const data = parsed['data'];
+    if (Array.isArray(data)) {
+        for (const row of data) {
+            if (typeof row !== 'object' || row === null)
+                continue;
+            const rec = row;
+            const modelId = String(rec['id'] ?? '').trim();
+            if (!modelId)
+                continue;
+            const created = _parseTimestamp(rec['created'] ?? rec['created_at']);
+            rows.push({
+                provider: 'openai',
+                id: modelId,
+                created_ts: created,
+                raw: rec,
+            });
+        }
+    }
+    return _sortedModels(rows);
+}
+export async function listAnthropicModels(apiKey, baseUrl = 'https://api.anthropic.com/v1', timeoutSec = 60) {
+    const parsed = await _httpJson(baseUrl.replace(/\/+$/, '') + '/models', 'GET', {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'content-type': 'application/json',
+    }, null, timeoutSec);
+    const rows = [];
+    const data = parsed['data'];
+    if (Array.isArray(data)) {
+        for (const row of data) {
+            if (typeof row !== 'object' || row === null)
+                continue;
+            const rec = row;
+            const modelId = String(rec['id'] ?? '').trim();
+            if (!modelId)
+                continue;
+            const created = _parseTimestamp(rec['created_at'] ?? rec['created'] ?? rec['released_at']);
+            rows.push({
+                provider: 'anthropic',
+                id: modelId,
+                created_ts: created,
+                raw: rec,
+            });
+        }
+    }
+    return _sortedModels(rows);
+}
+export async function listOpenrouterModels(apiKey, baseUrl = 'https://openrouter.ai/api/v1', timeoutSec = 60) {
+    const parsed = await _httpJson(baseUrl.replace(/\/+$/, '') + '/models', 'GET', {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+    }, null, timeoutSec);
+    const rows = [];
+    const data = parsed['data'];
+    if (Array.isArray(data)) {
+        for (const row of data) {
+            if (typeof row !== 'object' || row === null)
+                continue;
+            const rec = row;
+            const modelId = String(rec['id'] ?? '').trim();
+            if (!modelId)
+                continue;
+            const topProvider = rec['top_provider'];
+            const topProviderCreated = typeof topProvider === 'object' && topProvider !== null
+                ? topProvider['created']
+                : null;
+            const created = _parseTimestamp(rec['created'] ??
+                rec['created_at'] ??
+                topProviderCreated ??
+                rec['updated_at']);
+            rows.push({
+                provider: 'openrouter',
+                id: modelId,
+                created_ts: created,
+                raw: rec,
+            });
+        }
+    }
+    return _sortedModels(rows);
+}
+// ---------------------------------------------------------------------------
+// OpenAI-compatible model (native tool calling)
+// ---------------------------------------------------------------------------
+export class OpenAICompatibleModel {
+    model;
+    apiKey;
+    baseUrl;
+    temperature;
+    reasoningEffort;
+    timeoutSec;
+    extraHeaders;
+    strictTools;
+    toolDefs;
+    onContentDelta;
+    constructor(opts) {
+        this.model = opts.model;
+        this.apiKey = opts.apiKey;
+        this.baseUrl = opts.baseUrl ?? 'https://api.openai.com/v1';
+        this.temperature = opts.temperature ?? 0.0;
+        this.reasoningEffort = opts.reasoningEffort ?? null;
+        this.timeoutSec = opts.timeoutSec ?? 300;
+        this.extraHeaders = opts.extraHeaders ?? {};
+        this.strictTools = opts.strictTools ?? true;
+        this.toolDefs = opts.toolDefs ?? null;
+        this.onContentDelta = opts.onContentDelta ?? null;
+    }
+    _isReasoningModel() {
+        const lower = this.model.toLowerCase();
+        if (lower.startsWith('o1-') || lower === 'o1' ||
+            lower.startsWith('o3-') || lower === 'o3' ||
+            lower.startsWith('o4-') || lower === 'o4') {
+            return true;
+        }
+        if (lower.startsWith('gpt-5')) {
+            return true;
+        }
+        return false;
+    }
+    createConversation(systemPrompt, initialUserMessage) {
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: initialUserMessage },
+        ];
+        return new Conversation({ _provider_messages: messages, system_prompt: systemPrompt });
+    }
+    async complete(conversation) {
+        const isReasoning = this._isReasoningModel();
+        const payload = {
+            model: this.model,
+            messages: conversation._provider_messages,
+            tools: to_openai_tools(this.toolDefs ?? undefined, this.strictTools),
+            tool_choice: 'auto',
+            stream: true,
+            stream_options: { include_usage: true },
+        };
+        if (conversation.stop_sequences.length > 0) {
+            payload['stop'] = conversation.stop_sequences;
+        }
+        // Reasoning models (o-series) don't support temperature.
+        if (!isReasoning) {
+            payload['temperature'] = this.temperature;
+        }
+        // Chat Completions API uses flat `reasoning_effort` (not the nested format).
+        // xAI Grok models do not support this parameter.
+        const isGrok = this.model.toLowerCase().startsWith('grok');
+        const effort = (this.reasoningEffort ?? '').trim().toLowerCase();
+        if (effort && !isGrok) {
+            payload['reasoning_effort'] = effort;
+        }
+        const url = this.baseUrl.replace(/\/+$/, '') + '/chat/completions';
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            ...this.extraHeaders,
+        };
+        // Build SSE event forwarder for streaming text deltas to TUI
+        const cb = this.onContentDelta;
+        const forwardDelta = cb
+            ? (_eventType, data) => {
+                const choices = data['choices'];
+                if (!choices || !Array.isArray(choices) || choices.length === 0)
+                    return;
+                const delta = (choices[0]['delta'] ?? {});
+                if (!delta || typeof delta !== 'object')
+                    return;
+                const content = delta['content'];
+                if (typeof content === 'string' && content) {
+                    cb('text', content);
+                }
+            }
+            : null;
+        let parsed;
+        try {
+            const events = await _httpStreamSse(url, 'POST', headers, payload, 10, this.timeoutSec, 3, forwardDelta);
+            parsed = _accumulateOpenaiStream(events);
+        }
+        catch (exc) {
+            if (!(exc instanceof ModelError))
+                throw exc;
+            const text = exc.message.toLowerCase();
+            const unsupportedReasoning = effort &&
+                (text.includes('reasoning_effort') || text.includes('reasoningeffort')) &&
+                (text.includes('unsupported_parameter') || text.includes('unknown') || text.includes('invalid argument'));
+            if (!unsupportedReasoning)
+                throw exc;
+            // Retry without reasoning_effort
+            const retryPayload = { ...payload };
+            delete retryPayload['reasoning_effort'];
+            const events = await _httpStreamSse(url, 'POST', headers, retryPayload, 10, this.timeoutSec, 3, forwardDelta);
+            parsed = _accumulateOpenaiStream(events);
+        }
+        const choices = parsed['choices'];
+        if (!choices || !Array.isArray(choices) || choices.length === 0) {
+            throw new ModelError(`Model response missing content: ${JSON.stringify(parsed)}`);
+        }
+        const choice = choices[0];
+        const message = choice['message'];
+        if (!message) {
+            throw new ModelError(`Model response missing content: ${JSON.stringify(parsed)}`);
+        }
+        const finishReason = choice['finish_reason'] ?? '';
+        // Parse tool calls
+        const rawToolCalls = message['tool_calls'];
+        const toolCalls = [];
+        if (rawToolCalls && Array.isArray(rawToolCalls)) {
+            for (const tc of rawToolCalls) {
+                const tcRec = tc;
+                const func = (tcRec['function'] ?? {});
+                const argsStr = func['arguments'] ?? '{}';
+                let args;
+                try {
+                    args = JSON.parse(argsStr);
+                }
+                catch {
+                    args = {};
+                }
+                toolCalls.push({
+                    id: tcRec['id'] ?? '',
+                    name: func['name'] ?? '',
+                    arguments: typeof args === 'object' && args !== null && !Array.isArray(args)
+                        ? args
+                        : {},
+                });
+            }
+        }
+        // Extract text content
+        let textContent = _extractContent(message['content'] ?? '') || null;
+        if (textContent !== null && !textContent.trim()) {
+            textContent = null;
+        }
+        // Extract token usage
+        const usageObj = parsed['usage'];
+        const inputTokens = typeof usageObj === 'object' && usageObj !== null
+            ? usageObj['prompt_tokens'] ?? 0
+            : 0;
+        const outputTokens = typeof usageObj === 'object' && usageObj !== null
+            ? usageObj['completion_tokens'] ?? 0
+            : 0;
+        return {
+            tool_calls: toolCalls,
+            text: textContent,
+            stop_reason: finishReason,
+            raw_response: message,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+        };
+    }
+    appendAssistantTurn(conversation, turn) {
+        // Replay the raw OpenAI message object to preserve tool_calls array
+        conversation._provider_messages.push(turn.raw_response);
+        conversation.turn_count += 1;
+    }
+    appendToolResults(conversation, results) {
+        for (const r of results) {
+            conversation._provider_messages.push({
+                role: 'tool',
+                tool_call_id: r.tool_call_id,
+                name: r.name,
+                content: r.content,
+            });
+        }
+    }
+    condenseConversation(conversation, keepRecentTurns = 4) {
+        const msgs = conversation._provider_messages;
+        // Find indices of tool-role messages.
+        const toolIndices = [];
+        for (let i = 0; i < msgs.length; i++) {
+            const m = msgs[i];
+            if (typeof m === 'object' && m !== null && m['role'] === 'tool') {
+                toolIndices.push(i);
+            }
+        }
+        if (toolIndices.length <= keepRecentTurns) {
+            return 0;
+        }
+        const toCondense = toolIndices.slice(0, -keepRecentTurns);
+        let condensed = 0;
+        const placeholder = '[earlier tool output condensed]';
+        for (const idx of toCondense) {
+            const msg = msgs[idx];
+            if (msg['content'] !== placeholder) {
+                msg['content'] = placeholder;
+                condensed += 1;
+            }
+        }
+        return condensed;
+    }
+}
+// ---------------------------------------------------------------------------
+// Anthropic model (native tool calling)
+// ---------------------------------------------------------------------------
+export class AnthropicModel {
+    model;
+    apiKey;
+    baseUrl;
+    temperature;
+    reasoningEffort;
+    maxTokens;
+    timeoutSec;
+    toolDefs;
+    onContentDelta;
+    constructor(opts) {
+        this.model = opts.model;
+        this.apiKey = opts.apiKey;
+        this.baseUrl = opts.baseUrl ?? 'https://api.anthropic.com/v1';
+        this.temperature = opts.temperature ?? 0.0;
+        this.reasoningEffort = opts.reasoningEffort ?? null;
+        this.maxTokens = opts.maxTokens ?? 16384;
+        this.timeoutSec = opts.timeoutSec ?? 300;
+        this.toolDefs = opts.toolDefs ?? null;
+        this.onContentDelta = opts.onContentDelta ?? null;
+    }
+    createConversation(systemPrompt, initialUserMessage) {
+        const messages = [
+            { role: 'user', content: initialUserMessage },
+        ];
+        return new Conversation({ _provider_messages: messages, system_prompt: systemPrompt });
+    }
+    _isOpus46() {
+        const lower = this.model.toLowerCase();
+        return lower.includes('opus-4-6') || lower.includes('opus-4.6');
+    }
+    async complete(conversation) {
+        const effort = (this.reasoningEffort ?? '').trim().toLowerCase();
+        const useThinking = ['low', 'medium', 'high'].includes(effort);
+        const payload = {
+            model: this.model,
+            max_tokens: this.maxTokens,
+            messages: conversation._provider_messages,
+            tools: to_anthropic_tools(this.toolDefs ?? undefined),
+            stream: true,
+        };
+        if (conversation.stop_sequences.length > 0) {
+            payload['stop_sequences'] = conversation.stop_sequences;
+        }
+        // Thinking is incompatible with temperature — omit it entirely.
+        if (!useThinking) {
+            payload['temperature'] = this.temperature;
+        }
+        if (useThinking) {
+            if (this._isOpus46()) {
+                // Opus 4.6: adaptive thinking (manual mode deprecated).
+                payload['thinking'] = { type: 'adaptive' };
+                payload['output_config'] = { effort };
+            }
+            else {
+                // Older models: manual thinking with explicit budget.
+                const budgetMap = { low: 1024, medium: 4096, high: 8192 };
+                const budget = budgetMap[effort];
+                if (payload['max_tokens'] <= budget) {
+                    payload['max_tokens'] = budget + 8192;
+                }
+                payload['thinking'] = { type: 'enabled', budget_tokens: budget };
+            }
+        }
+        if (conversation.system_prompt) {
+            payload['system'] = conversation.system_prompt;
+        }
+        const url = this.baseUrl.replace(/\/+$/, '') + '/messages';
+        const headers = {
+            'x-api-key': this.apiKey,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json',
+        };
+        // Build SSE event forwarder for streaming deltas to TUI
+        const cb = this.onContentDelta;
+        const forwardDelta = cb
+            ? (_eventType, data) => {
+                const msgType = data['type'] ?? _eventType;
+                if (msgType !== 'content_block_delta')
+                    return;
+                const delta = (data['delta'] ?? {});
+                const deltaType = delta['type'] ?? '';
+                if (deltaType === 'thinking_delta') {
+                    const text = delta['thinking'] ?? '';
+                    if (text)
+                        cb('thinking', text);
+                }
+                else if (deltaType === 'text_delta') {
+                    const text = delta['text'] ?? '';
+                    if (text)
+                        cb('text', text);
+                }
+            }
+            : null;
+        let parsed;
+        try {
+            const events = await _httpStreamSse(url, 'POST', headers, payload, 10, this.timeoutSec, 3, forwardDelta);
+            parsed = _accumulateAnthropicStream(events);
+        }
+        catch (exc) {
+            if (!(exc instanceof ModelError))
+                throw exc;
+            const text = exc.message.toLowerCase();
+            const unsupportedThinking = useThinking &&
+                text.includes('thinking') &&
+                (text.includes('unknown') || text.includes('unsupported') || text.includes('invalid'));
+            if (!unsupportedThinking)
+                throw exc;
+            // Retry without thinking
+            const retryPayload = { ...payload };
+            delete retryPayload['thinking'];
+            delete retryPayload['output_config'];
+            const events = await _httpStreamSse(url, 'POST', headers, retryPayload, 10, this.timeoutSec, 3, forwardDelta);
+            parsed = _accumulateAnthropicStream(events);
+        }
+        const stopReason = parsed['stop_reason'] ?? '';
+        let contentBlocks = parsed['content'];
+        if (!Array.isArray(contentBlocks)) {
+            contentBlocks = [];
+        }
+        // Parse content blocks
+        const toolCalls = [];
+        const textParts = [];
+        for (const block of contentBlocks) {
+            if (typeof block !== 'object' || block === null)
+                continue;
+            const blockRec = block;
+            const blockType = blockRec['type'] ?? '';
+            if (blockType === 'tool_use') {
+                const inputVal = blockRec['input'];
+                toolCalls.push({
+                    id: blockRec['id'] ?? '',
+                    name: blockRec['name'] ?? '',
+                    arguments: typeof inputVal === 'object' && inputVal !== null && !Array.isArray(inputVal)
+                        ? inputVal
+                        : {},
+                });
+            }
+            else if (blockType === 'text') {
+                const t = blockRec['text'];
+                if (typeof t === 'string' && t.trim()) {
+                    textParts.push(t);
+                }
+            }
+        }
+        const textContent = textParts.length > 0 ? textParts.join('\n') : null;
+        // Extract token usage
+        const usageObj = parsed['usage'];
+        const inputTokens = typeof usageObj === 'object' && usageObj !== null
+            ? usageObj['input_tokens'] ?? 0
+            : 0;
+        const outputTokens = typeof usageObj === 'object' && usageObj !== null
+            ? usageObj['output_tokens'] ?? 0
+            : 0;
+        return {
+            tool_calls: toolCalls,
+            text: textContent,
+            stop_reason: stopReason,
+            raw_response: contentBlocks,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+        };
+    }
+    appendAssistantTurn(conversation, turn) {
+        // Replay the full content block array (including thinking blocks)
+        conversation._provider_messages.push({
+            role: 'assistant',
+            content: turn.raw_response,
+        });
+        conversation.turn_count += 1;
+    }
+    appendToolResults(conversation, results) {
+        const toolResultBlocks = [];
+        for (const r of results) {
+            const block = {
+                type: 'tool_result',
+                tool_use_id: r.tool_call_id,
+                content: r.content,
+            };
+            if (r.is_error) {
+                block['is_error'] = true;
+            }
+            toolResultBlocks.push(block);
+        }
+        conversation._provider_messages.push({
+            role: 'user',
+            content: toolResultBlocks,
+        });
+    }
+    condenseConversation(conversation, keepRecentTurns = 4) {
+        const msgs = conversation._provider_messages;
+        const placeholder = '[earlier tool output condensed]';
+        // Find indices of user messages that contain tool_result blocks.
+        const toolMsgIndices = [];
+        for (let i = 0; i < msgs.length; i++) {
+            const m = msgs[i];
+            if (typeof m !== 'object' || m === null)
+                continue;
+            const rec = m;
+            if (rec['role'] !== 'user')
+                continue;
+            const content = rec['content'];
+            if (Array.isArray(content) &&
+                content.some((b) => typeof b === 'object' &&
+                    b !== null &&
+                    b['type'] === 'tool_result')) {
+                toolMsgIndices.push(i);
+            }
+        }
+        if (toolMsgIndices.length <= keepRecentTurns) {
+            return 0;
+        }
+        const toCondense = toolMsgIndices.slice(0, -keepRecentTurns);
+        let condensed = 0;
+        for (const idx of toCondense) {
+            const content = msgs[idx]['content'];
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (typeof block !== 'object' || block === null)
+                    continue;
+                const blockRec = block;
+                if (blockRec['type'] !== 'tool_result')
+                    continue;
+                if (blockRec['content'] !== placeholder) {
+                    blockRec['content'] = placeholder;
+                    condensed += 1;
+                }
+            }
+        }
+        return condensed;
+    }
+}
+// ---------------------------------------------------------------------------
+// Test / fallback models
+// ---------------------------------------------------------------------------
+/** Model that returns pre-scripted ModelTurn responses for testing. */
+export class ScriptedModel {
+    scriptedTurns;
+    constructor(scriptedTurns = []) {
+        this.scriptedTurns = [...scriptedTurns];
+    }
+    createConversation(systemPrompt, initialUserMessage) {
+        return new Conversation({
+            _provider_messages: [{ role: 'user', content: initialUserMessage }],
+            system_prompt: systemPrompt,
+        });
+    }
+    complete(_conversation) {
+        if (this.scriptedTurns.length === 0) {
+            throw new ModelError('ScriptedModel exhausted; no responses left.');
+        }
+        return this.scriptedTurns.shift();
+    }
+    appendAssistantTurn(_conversation, _turn) {
+        // no-op
+    }
+    appendToolResults(_conversation, _results) {
+        // no-op
+    }
+    condenseConversation(_conversation, _keepRecentTurns = 4) {
+        return 0;
+    }
+}
+export class EchoFallbackModel {
+    note;
+    constructor(note = 'No provider API keys configured. Set OpenAI/Anthropic/OpenRouter keys to use a live LLM.') {
+        this.note = note;
+    }
+    createConversation(systemPrompt, initialUserMessage) {
+        return new Conversation({
+            _provider_messages: [{ role: 'user', content: initialUserMessage }],
+            system_prompt: systemPrompt,
+        });
+    }
+    complete(_conversation) {
+        return {
+            tool_calls: [],
+            text: this.note,
+            stop_reason: 'end_turn',
+            raw_response: null,
+            input_tokens: 0,
+            output_tokens: 0,
+        };
+    }
+    appendAssistantTurn(_conversation, _turn) {
+        // no-op
+    }
+    appendToolResults(_conversation, _results) {
+        // no-op
+    }
+}
+//# sourceMappingURL=model.js.map