@kruntime/komputer 0.1.0

package/dist/model.js

@@ -0,0 +1,824 @@
+import { blocksToText, textBlock } from "./content.js";
+export function echoModel(id = 'default') {
+    return {
+        id,
+        kind: 'llm',
+        capabilities: { streaming: true, toolUse: true, vision: true, audioIn: true, videoIn: true },
+        async complete(req) {
+            const last = [...req.messages].reverse().find((m) => m.role === 'user');
+            const text = last ? blocksToText(last.content || []) : '';
+            return {
+                text: `Echo(${id}): ${text}`,
+                message: { role: 'assistant', content: [textBlock(`Echo(${id}): ${text}`)] },
+                finishReason: 'stop',
+                usage: { inputTokens: text.length, outputTokens: text.length + 8 },
+            };
+        },
+        async *stream(req) {
+            const result = await this.complete(req);
+            yield { type: 'content', content: { type: 'text', text: result.text } };
+            yield { type: 'message', message: result.message, usage: result.usage, finishReason: result.finishReason };
+        },
+    };
+}
+export function toolUseModel(id = 'tool-model', toolName = 'demo.tool') {
+    return {
+        id,
+        kind: 'llm',
+        capabilities: { toolUse: true },
+        async complete() {
+            const toolUseId = `tool_${Date.now()}`;
+            return {
+                text: '',
+                finishReason: 'tool_use',
+                message: {
+                    role: 'assistant',
+                    content: [{ type: 'tool_use', id: toolUseId, name: toolName, input: { demo: true } }],
+                },
+            };
+        },
+    };
+}
+export function openaiResponsesModel(options) {
+    const baseURL = trimSlash(options.baseURL || 'https://api.openai.com/v1');
+    const fetchImpl = options.fetch || defaultFetch();
+    const wsState = openAIResponsesWebSocketState(options, baseURL);
+    return {
+        id: options.id || options.model,
+        kind: 'llm',
+        capabilities: { provider: 'openai', protocol: 'responses', transport: options.webSocket || options.transport === 'websocket' ? 'websocket' : 'http', text: true, vision: true },
+        async complete(req) {
+            const body = openAIResponsesRequestBody(options, req.messages);
+            const record = await openAIResponsesRecord(options, baseURL, fetchImpl, wsState, body);
+            return openAIResponsesResult(options, record);
+        },
+        async *stream(req) {
+            const body = openAIResponsesRequestBody(options, req.messages);
+            if (!shouldUseOpenAIResponsesWebSocket(options)) {
+                const result = openAIResponsesResult(options, await openAIResponsesRecord(options, baseURL, fetchImpl, wsState, body));
+                if (result.text)
+                    yield { type: 'content', content: textBlock(result.text), text: result.text };
+                yield { type: 'message', message: result.message, usage: result.usage, finishReason: result.finishReason, provider: result.provider };
+                return;
+            }
+            yield* openAIResponsesWebSocketStream(options, wsState, body);
+        },
+    };
+}
+export function openaiChatCompletionsModel(options) {
+    const baseURL = trimSlash(options.baseURL || 'https://api.openai.com/v1');
+    const fetchImpl = options.fetch || defaultFetch();
+    return {
+        id: options.id || options.model,
+        kind: 'llm',
+        capabilities: { provider: 'openai', protocol: 'chat-completions', text: true, vision: true },
+        async complete(req) {
+            const body = {
+                ...(options.extra || {}),
+                model: options.model,
+                messages: messagesForOpenAIChat(req.messages, options),
+            };
+            if (options.maxTokens !== undefined)
+                body.max_tokens = options.maxTokens;
+            if (options.temperature !== undefined)
+                body.temperature = options.temperature;
+            const json = await postJson(fetchImpl, `${baseURL}/chat/completions`, {
+                Authorization: `Bearer ${options.apiKey}`,
+                'Content-Type': 'application/json',
+            }, body);
+            const record = asRecord(json);
+            const firstChoice = firstOpenAIChatChoice(record);
+            const message = messageFromOpenAIChatChoice(firstChoice, options);
+            const text = extractOpenAIChatText(firstChoice);
+            return {
+                text,
+                message,
+                finishReason: normalizeFinishReason(firstChoice.finish_reason ?? record.status),
+                usage: normalizeOpenAIUsage(record.usage),
+                provider: {
+                    name: 'openai',
+                    model: options.model,
+                    requestId: stringField(record, 'id'),
+                    raw: record,
+                },
+            };
+        },
+    };
+}
+export function anthropicMessagesModel(options) {
+    const baseURL = trimSlash(options.baseURL || 'https://api.anthropic.com/v1');
+    const fetchImpl = options.fetch || defaultFetch();
+    const providerName = options.providerName || 'anthropic';
+    const protocol = options.protocol || 'messages';
+    return {
+        id: options.id || options.model,
+        kind: 'llm',
+        capabilities: { provider: providerName, protocol, text: true, vision: true },
+        async complete(req) {
+            const { system, messages } = messagesForAnthropic(req.messages);
+            const body = {
+                model: options.model,
+                max_tokens: options.maxTokens ?? 4096,
+                system: system || undefined,
+                messages,
+            };
+            const json = await postJson(fetchImpl, `${baseURL}/messages`, {
+                'x-api-key': options.apiKey,
+                'anthropic-version': '2023-06-01',
+                'Content-Type': 'application/json',
+            }, body);
+            const record = asRecord(json);
+            const text = extractAnthropicText(record);
+            return {
+                text,
+                message: messageFromAnthropic(record, providerName),
+                finishReason: normalizeFinishReason(record.stop_reason),
+                usage: normalizeAnthropicUsage(record.usage),
+                provider: {
+                    name: providerName,
+                    model: options.model,
+                    requestId: stringField(record, 'id'),
+                    raw: record,
+                },
+            };
+        },
+    };
+}
+export function deepseekMessagesModel(options) {
+    return anthropicMessagesModel({
+        ...options,
+        baseURL: options.baseURL || 'https://api.deepseek.com/anthropic',
+        providerName: 'deepseek',
+        protocol: 'anthropic-messages',
+    });
+}
+export function deepseekOpenAIModel(options) {
+    const base = openaiChatCompletionsModel({
+        ...options,
+        baseURL: options.baseURL || 'https://api.deepseek.com',
+        providerName: 'deepseek',
+        reasoningField: options.reasoningField || 'reasoning_content',
+        reasoningFieldFormat: options.reasoningFieldFormat || 'string',
+        reasoningInput: options.reasoningInput || 'omit',
+    });
+    return {
+        ...base,
+        id: options.id || options.model,
+        capabilities: { ...(base.capabilities || {}), provider: 'deepseek', protocol: 'openai-chat-completions' },
+        async complete(req) {
+            const result = await base.complete(req);
+            return {
+                ...result,
+                provider: {
+                    ...(result.provider || {}),
+                    name: 'deepseek',
+                    model: options.model,
+                },
+            };
+        },
+    };
+}
+export function minimaxOpenAIModel(options) {
+    const base = openaiChatCompletionsModel({
+        ...options,
+        baseURL: options.baseURL || 'https://api.minimax.io/v1',
+        providerName: 'minimax',
+        extra: { reasoning_split: true, ...(options.extra || {}) },
+        preserveAssistantMessage: options.preserveAssistantMessage ?? true,
+        reasoningField: options.reasoningField || 'reasoning_details',
+        reasoningFieldFormat: options.reasoningFieldFormat || 'details-array',
+        reasoningInput: options.reasoningInput || 'preserve',
+    });
+    return {
+        ...base,
+        id: options.id || options.model,
+        capabilities: { ...(base.capabilities || {}), provider: 'minimax', protocol: 'openai-chat-completions' },
+        async complete(req) {
+            const result = await base.complete(req);
+            return {
+                ...result,
+                provider: {
+                    ...(result.provider || {}),
+                    name: 'minimax',
+                    model: options.model,
+                },
+            };
+        },
+    };
+}
+export function modelset(models = {}) {
+    const resolved = {};
+    for (const [alias, model] of Object.entries(models)) {
+        resolved[alias] = typeof model === 'string'
+            ? () => {
+                const target = resolved[model];
+                if (!target)
+                    throw new Error(`model alias not bound: ${model}`);
+                return target();
+            }
+            : () => model;
+    }
+    return {
+        get(alias = 'default') {
+            const factory = resolved[alias];
+            if (!factory)
+                throw new Error(`model not bound: ${alias}`);
+            return factory();
+        },
+        aliases() {
+            return Object.keys(resolved);
+        },
+    };
+}
+export const providers = {
+    echo: echoModel,
+    toolUse: toolUseModel,
+    openaiResponses: openaiResponsesModel,
+    openaiChatCompletions: openaiChatCompletionsModel,
+    anthropicMessages: anthropicMessagesModel,
+    deepseekMessages: deepseekMessagesModel,
+    deepseekOpenAI: deepseekOpenAIModel,
+    minimaxOpenAI: minimaxOpenAIModel,
+};
+function defaultFetch() {
+    if (typeof fetch !== 'function')
+        throw new Error('global fetch is not available; pass a fetch implementation to the model provider');
+    return fetch;
+}
+async function postJson(fetchImpl, url, headers, body) {
+    const response = await fetchImpl(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw new Error(`model provider request failed: ${response.status ?? ''} ${response.statusText ?? ''} ${text}`.trim());
+    }
+    return response.json();
+}
+function openAIResponsesRequestBody(options, messages) {
+    const { instructions, input, previousResponseId } = transcriptForOpenAIResponses(messages);
+    const body = {
+        model: options.model,
+        instructions: instructions || undefined,
+        input,
+    };
+    if (options.include?.length)
+        body.include = options.include;
+    if (options.reasoning)
+        body.reasoning = options.reasoning;
+    if (options.store !== undefined)
+        body.store = options.store;
+    if (options.previousResponseId || previousResponseId)
+        body.previous_response_id = options.previousResponseId || previousResponseId;
+    return body;
+}
+async function openAIResponsesRecord(options, baseURL, fetchImpl, wsState, body) {
+    if (shouldUseOpenAIResponsesWebSocket(options)) {
+        return withOpenAIResponsesWebSocketTurn(wsState, () => collectOpenAIResponsesWebSocket(options, wsState, body));
+    }
+    return asRecord(await postJson(fetchImpl, `${baseURL}/responses`, openAIResponsesHttpHeaders(options), body));
+}
+function openAIResponsesResult(options, record) {
+    const text = extractOpenAIText(record);
+    const outputItems = Array.isArray(record.output) ? record.output.map((item) => asRecord(item)) : [];
+    const reasoningItems = openAIResponsesReasoningItems(outputItems);
+    const responseId = stringField(record, 'id');
+    return {
+        text,
+        message: {
+            role: 'assistant',
+            content: [textBlock(text)],
+            provider: {
+                anchor: true,
+                openaiResponses: {
+                    responseId,
+                    outputItems,
+                    reasoningItems,
+                    encryptedReasoningItems: reasoningItems.filter((item) => typeof item.encrypted_content === 'string'),
+                },
+            },
+        },
+        finishReason: normalizeFinishReason(record.status),
+        usage: normalizeOpenAIUsage(record.usage),
+        provider: {
+            name: 'openai',
+            model: options.model,
+            requestId: responseId,
+            cacheRef: responseId,
+            openaiResponses: {
+                responseId,
+                outputItems,
+                reasoningItems,
+                encryptedReasoningItems: reasoningItems.filter((item) => typeof item.encrypted_content === 'string'),
+            },
+            raw: record,
+        },
+    };
+}
+function shouldUseOpenAIResponsesWebSocket(options) {
+    return Boolean(options.webSocket) || options.transport === 'websocket';
+}
+function openAIResponsesWebSocketState(_options, _baseURL) {
+    return { lock: Promise.resolve() };
+}
+async function withOpenAIResponsesWebSocketTurn(state, task) {
+    const release = await acquireOpenAIResponsesWebSocketTurn(state);
+    try {
+        return await task();
+    }
+    finally {
+        release();
+    }
+}
+async function collectOpenAIResponsesWebSocket(options, state, body) {
+    let text = '';
+    const socket = await openAIResponsesSocket(options, state);
+    await socket.send({ type: 'response.create', ...body });
+    while (true) {
+        const event = await socket.receive();
+        const type = stringField(event, 'type');
+        if (type === 'response.output_text.delta') {
+            const delta = stringField(event, 'delta');
+            if (delta)
+                text += delta;
+            continue;
+        }
+        if (type === 'response.completed')
+            return responseRecordFromCompletedEvent(event, text);
+        if (isOpenAIResponsesFailureEvent(type))
+            throw openAIResponsesEventError(event);
+    }
+}
+async function* openAIResponsesWebSocketStream(options, state, body) {
+    const release = await acquireOpenAIResponsesWebSocketTurn(state);
+    let text = '';
+    try {
+        const socket = await openAIResponsesSocket(options, state);
+        await socket.send({ type: 'response.create', ...body });
+        while (true) {
+            const event = await socket.receive();
+            const type = stringField(event, 'type');
+            if (type === 'response.output_text.delta') {
+                const delta = stringField(event, 'delta') || '';
+                if (delta) {
+                    text += delta;
+                    yield { type: 'content', content: textBlock(delta), text: delta };
+                }
+                continue;
+            }
+            if (type === 'response.completed') {
+                const record = responseRecordFromCompletedEvent(event, text);
+                const result = openAIResponsesResult(options, record);
+                yield { type: 'message', message: result.message, usage: result.usage, finishReason: result.finishReason, provider: result.provider };
+                return;
+            }
+            if (isOpenAIResponsesFailureEvent(type))
+                throw openAIResponsesEventError(event);
+            yield { type: 'provider', event };
+        }
+    }
+    finally {
+        release();
+    }
+}
+async function acquireOpenAIResponsesWebSocketTurn(state) {
+    const previous = state.lock;
+    let release;
+    state.lock = previous.then(() => new Promise((resolve) => {
+        release = resolve;
+    }), () => new Promise((resolve) => {
+        release = resolve;
+    }));
+    await previous;
+    return release;
+}
+async function openAIResponsesSocket(options, state) {
+    if (!options.webSocket)
+        throw new Error('OpenAI Responses WebSocket transport requires webSocket.connect');
+    if (!state.socket) {
+        state.socket = Promise.resolve(options.webSocket.connect({
+            url: options.webSocket.url || httpUrlToWebSocketUrl(trimSlash(options.baseURL || 'https://api.openai.com/v1'), '/responses'),
+            headers: openAIResponsesHttpHeaders(options),
+        }));
+    }
+    return state.socket;
+}
+function openAIResponsesHttpHeaders(options) {
+    return {
+        Authorization: `Bearer ${options.apiKey}`,
+        'Content-Type': 'application/json',
+    };
+}
+function responseRecordFromCompletedEvent(event, streamedText) {
+    const response = cloneRecord(asRecord(event.response));
+    if (!stringField(response, 'output_text') && streamedText)
+        response.output_text = streamedText;
+    return response;
+}
+function isOpenAIResponsesFailureEvent(type) {
+    return type === 'error' || type === 'response.failed' || type === 'response.incomplete';
+}
+function openAIResponsesEventError(event) {
+    const error = asRecord(event.error);
+    const message = stringField(error, 'message') || stringField(event, 'message') || JSON.stringify(event);
+    const code = stringField(error, 'code') || stringField(event, 'code');
+    return new Error(code ? `${code}: ${message}` : message);
+}
+function httpUrlToWebSocketUrl(baseURL, suffix) {
+    const url = `${baseURL}${suffix}`;
+    if (url.startsWith('https://'))
+        return `wss://${url.slice('https://'.length)}`;
+    if (url.startsWith('http://'))
+        return `ws://${url.slice('http://'.length)}`;
+    return url;
+}
+function transcriptForOpenAIResponses(messages) {
+    const instructions = messages.filter((message) => message.role === 'system').map((message) => blocksToText(message.content)).filter(Boolean).join('\n\n');
+    const continuation = lastOpenAIResponsesContinuation(messages);
+    const textMessages = continuation ? messages.slice(continuation.index + 1) : messages;
+    const text = textMessages
+        .filter((message) => message.role !== 'system')
+        .map((message) => `${message.role}: ${blocksToText(message.content)}`)
+        .filter((line) => !line.endsWith(': '))
+        .join('\n\n');
+    if (continuation?.responseId)
+        return { instructions, input: text, previousResponseId: continuation.responseId };
+    const providerItems = messages.flatMap((message) => openAIResponsesInputItems(message));
+    if (!providerItems.length)
+        return { instructions, input: text };
+    const input = [
+        ...providerItems,
+        {
+            type: 'message',
+            role: 'user',
+            content: [{ type: 'input_text', text }],
+        },
+    ];
+    return { instructions, input };
+}
+function lastOpenAIResponsesContinuation(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const provider = asRecord(messages[index].provider);
+        const state = asRecord(provider.openaiResponses);
+        const responseId = stringField(state, 'responseId');
+        if (responseId)
+            return { index, responseId };
+    }
+    return undefined;
+}
+function openAIResponsesInputItems(message) {
+    const provider = asRecord(message.provider);
+    const state = asRecord(provider.openaiResponses);
+    const items = Array.isArray(state.reasoningItems)
+        ? state.reasoningItems
+        : Array.isArray(state.outputItems)
+            ? state.outputItems.filter((item) => asRecord(item).type === 'reasoning' || asRecord(item).type === 'compaction')
+            : [];
+    return items.map((item) => asRecord(item)).filter((item) => item.type === 'reasoning' || item.type === 'compaction');
+}
+function messagesForAnthropic(messages) {
+    const system = messages.filter((message) => message.role === 'system').map((message) => blocksToText(message.content)).filter(Boolean).join('\n\n');
+    const output = [];
+    for (const message of messages) {
+        if (message.role === 'system')
+            continue;
+        const role = message.role === 'assistant' ? 'assistant' : 'user';
+        const content = anthropicContentBlocks(message.content, role);
+        if (!content.length)
+            continue;
+        const last = output.at(-1);
+        if (last?.role === role && canMergeAnthropicContent(last.content) && canMergeAnthropicContent(content)) {
+            last.content[0].text += `\n\n${String(content[0].text)}`;
+        }
+        else {
+            output.push({ role, content });
+        }
+    }
+    if (!output.length)
+        output.push({ role: 'user', content: [{ type: 'text', text: '' }] });
+    return { system, messages: output };
+}
+function messagesForOpenAIChat(messages, options) {
+    const output = [];
+    for (const message of messages) {
+        const role = message.role === 'system' ? 'system' : message.role === 'assistant' ? 'assistant' : 'user';
+        if (message.role === 'tool' || message.content.some((block) => block.type === 'tool_result')) {
+            for (const block of message.content) {
+                if (block.type !== 'tool_result')
+                    continue;
+                output.push({
+                    role: 'tool',
+                    tool_call_id: block.toolUseId || block.id || block.name || 'tool',
+                    content: blocksToText([block]),
+                });
+            }
+            continue;
+        }
+        if (role === 'assistant') {
+            output.push(openAIChatAssistantMessage(message, options));
+            continue;
+        }
+        const text = blocksToText(message.content);
+        if (!text)
+            continue;
+        const last = output.at(-1);
+        if (last?.role === role && typeof last.content === 'string')
+            last.content += `\n\n${text}`;
+        else
+            output.push({ role, content: text });
+    }
+    if (!output.length)
+        output.push({ role: 'user', content: '' });
+    return output;
+}
+function anthropicContentBlocks(blocks, role) {
+    const output = [];
+    for (const block of blocks) {
+        if (block.type === 'text') {
+            if (block.text)
+                output.push({ type: 'text', text: block.text });
+        }
+        else if (block.type === 'thinking' && role === 'assistant') {
+            if (block.provider !== 'anthropic')
+                continue;
+            const raw = asRecord(block.raw);
+            if (raw.type === 'thinking' || raw.type === 'redacted_thinking')
+                output.push(cloneRecord(raw));
+            else if (block.signature)
+                output.push({
+                    type: 'thinking',
+                    thinking: block.text || block.thinking || '',
+                    signature: block.signature,
+                });
+        }
+        else if (block.type === 'tool_use' && role === 'assistant') {
+            output.push({ type: 'tool_use', id: block.id, name: block.name, input: block.input ?? {} });
+        }
+        else if (block.type === 'tool_result') {
+            output.push({
+                type: 'tool_result',
+                tool_use_id: block.toolUseId || block.id,
+                content: blocksToText([block]),
+                is_error: block.ok === false || block.status === 'failed',
+            });
+        }
+        else {
+            const text = blocksToText([block]);
+            if (text)
+                output.push({ type: 'text', text });
+        }
+    }
+    return output;
+}
+function canMergeAnthropicContent(content) {
+    return content.length === 1 && content[0].type === 'text' && typeof content[0].text === 'string';
+}
+function openAIChatAssistantMessage(message, options) {
+    if (options.preserveAssistantMessage) {
+        const preserved = preservedOpenAIChatAssistantMessage(message, openAIChatProviderName(options));
+        if (preserved)
+            return preserved;
+    }
+    const textBlocks = message.content.filter((block) => block.type !== 'tool_use' && block.type !== 'thinking');
+    const text = blocksToText(textBlocks);
+    const toolCalls = message.content.filter((block) => block.type === 'tool_use').map((block) => ({
+        id: block.id || idFromToolCall(String(block.name || 'tool')),
+        type: 'function',
+        function: {
+            name: block.name || 'tool',
+            arguments: JSON.stringify(block.input ?? {}),
+        },
+    }));
+    const output = { role: 'assistant', content: text || (toolCalls.length ? null : '') };
+    if (toolCalls.length)
+        output.tool_calls = toolCalls;
+    if (options.reasoningField && options.reasoningInput !== 'omit') {
+        const thinking = openAIChatReasoningInput(message, options);
+        if (thinking !== undefined)
+            output[options.reasoningField] = thinking;
+    }
+    return output;
+}
+function preservedOpenAIChatAssistantMessage(message, providerName) {
+    const provider = asRecord(message.provider);
+    const state = asRecord(provider.openaiChat);
+    if (state.providerName !== providerName)
+        return undefined;
+    const responseMessage = asRecord(state.responseMessage);
+    if (responseMessage.role !== 'assistant')
+        return undefined;
+    return cloneRecord(responseMessage);
+}
+function openAIChatReasoningInput(message, options) {
+    const provider = asRecord(message.provider);
+    const state = asRecord(provider.openaiChat);
+    if (state.providerName !== openAIChatProviderName(options))
+        return undefined;
+    const reasoning = state.reasoning;
+    if (options.reasoningFieldFormat === 'details-array') {
+        if (!Array.isArray(reasoning))
+            return undefined;
+        const details = reasoning.map((item) => {
+            const record = asRecord(item);
+            return Object.keys(record).length ? cloneRecord(record) : undefined;
+        }).filter((detail) => Boolean(detail));
+        return details.length ? details : undefined;
+    }
+    return typeof reasoning === 'string' && reasoning ? reasoning : undefined;
+}
+function extractOpenAIText(record) {
+    if (typeof record.output_text === 'string')
+        return record.output_text;
+    const output = Array.isArray(record.output) ? record.output : [];
+    const chunks = [];
+    for (const item of output) {
+        const itemRecord = asRecord(item);
+        const content = Array.isArray(itemRecord.content) ? itemRecord.content : [];
+        for (const block of content) {
+            const blockRecord = asRecord(block);
+            if (typeof blockRecord.text === 'string')
+                chunks.push(blockRecord.text);
+            if (typeof blockRecord.value === 'string')
+                chunks.push(blockRecord.value);
+        }
+    }
+    return chunks.join('');
+}
+function openAIResponsesReasoningItems(outputItems) {
+    return outputItems
+        .filter((item) => item.type === 'reasoning' || item.type === 'compaction')
+        .map((item) => ({ ...item }));
+}
+function firstOpenAIChatChoice(record) {
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    return asRecord(choices[0]);
+}
+function extractOpenAIChatText(choice) {
+    const message = asRecord(choice.message);
+    const content = message.content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const chunks = [];
+    for (const block of content) {
+        const record = asRecord(block);
+        if (typeof record.text === 'string')
+            chunks.push(record.text);
+        if (typeof record.value === 'string')
+            chunks.push(record.value);
+    }
+    return chunks.join('');
+}
+function messageFromOpenAIChatChoice(choice, options) {
+    const message = asRecord(choice.message);
+    const content = [];
+    const reasoningField = options.reasoningField;
+    const reasoning = reasoningField ? message[reasoningField] : undefined;
+    const text = extractOpenAIChatText(choice);
+    if (text)
+        content.push(textBlock(text));
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (const call of toolCalls) {
+        const record = asRecord(call);
+        const fn = asRecord(record.function);
+        const name = typeof fn.name === 'string' ? fn.name : typeof record.name === 'string' ? record.name : 'tool';
+        content.push({
+            type: 'tool_use',
+            id: typeof record.id === 'string' ? record.id : idFromToolCall(name),
+            name,
+            input: parseToolCallArguments(fn.arguments),
+        });
+    }
+    return {
+        role: 'assistant',
+        content: content.length ? content : [textBlock('')],
+        provider: {
+            openaiChat: {
+                providerName: openAIChatProviderName(options),
+                responseMessage: cloneRecord(message),
+                reasoning: cloneReasoningValue(reasoning),
+                reasoningField,
+                reasoningFieldFormat: options.reasoningFieldFormat || 'string',
+            },
+        },
+    };
+}
+function extractAnthropicText(record) {
+    const content = Array.isArray(record.content) ? record.content : [];
+    return content.map((block) => {
+        const item = asRecord(block);
+        return item.type === 'text' && typeof item.text === 'string' ? item.text : '';
+    }).join('');
+}
+function messageFromAnthropic(record, providerName = 'anthropic') {
+    const content = Array.isArray(record.content) ? record.content : [];
+    const blocks = [];
+    const privateThinking = [];
+    for (const block of content) {
+        const item = asRecord(block);
+        if (item.type === 'text' && typeof item.text === 'string')
+            blocks.push(textBlock(item.text));
+        else if (item.type === 'thinking' || item.type === 'redacted_thinking') {
+            if (providerName === 'anthropic') {
+                blocks.push({
+                    type: 'thinking',
+                    text: item.type === 'thinking' && typeof item.thinking === 'string' ? item.thinking : '',
+                    signature: item.signature,
+                    provider: 'anthropic',
+                    raw: cloneRecord(item),
+                });
+            }
+            else {
+                privateThinking.push(cloneRecord(item));
+            }
+        }
+        else if (item.type === 'tool_use')
+            blocks.push({ type: 'tool_use', id: stringField(item, 'id'), name: stringField(item, 'name'), input: item.input ?? {} });
+    }
+    return {
+        role: 'assistant',
+        content: blocks.length ? blocks : [textBlock('')],
+        provider: privateThinking.length
+            ? { messages: { providerName, thinkingBlocks: privateThinking } }
+            : undefined,
+    };
+}
+function normalizeOpenAIUsage(value) {
+    const usage = asRecord(value);
+    if (!Object.keys(usage).length)
+        return undefined;
+    return {
+        inputTokens: numberField(usage, 'input_tokens') ?? numberField(usage, 'prompt_tokens'),
+        outputTokens: numberField(usage, 'output_tokens') ?? numberField(usage, 'completion_tokens'),
+        totalTokens: numberField(usage, 'total_tokens'),
+        cachedInputTokens: numberField(asRecord(usage.input_tokens_details), 'cached_tokens') ?? numberField(usage, 'prompt_cache_hit_tokens'),
+    };
+}
+function openAIChatProviderName(options) {
+    return options.providerName || 'openai';
+}
+function cloneReasoningValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => {
+            const record = asRecord(item);
+            return Object.keys(record).length ? cloneRecord(record) : item;
+        });
+    return undefined;
+}
+function normalizeAnthropicUsage(value) {
+    const usage = asRecord(value);
+    if (!Object.keys(usage).length)
+        return undefined;
+    return {
+        inputTokens: numberField(usage, 'input_tokens'),
+        outputTokens: numberField(usage, 'output_tokens'),
+        cachedInputTokens: numberField(usage, 'cache_read_input_tokens'),
+    };
+}
+function normalizeFinishReason(value) {
+    if (value === 'completed' || value === 'end_turn' || value === 'stop_sequence' || value === 'stop')
+        return 'stop';
+    if (value === 'max_tokens' || value === 'length' || value === 'incomplete')
+        return 'length';
+    if (value === 'tool_use' || value === 'tool_calls')
+        return 'tool_use';
+    if (value === 'content_filter')
+        return 'content_filter';
+    return 'unknown';
+}
+function parseToolCallArguments(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function idFromToolCall(name) {
+    return `tool_${name.replace(/[^A-Za-z0-9_-]+/g, '_') || 'call'}`;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function cloneRecord(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function numberField(record, key) {
+    const value = record[key];
+    return typeof value === 'number' ? value : undefined;
+}
+function trimSlash(value) {
+    return value.replace(/\/+$/, '');
+}
+//# sourceMappingURL=model.js.map