@noorm/marie-cli 0.1.18 → 0.1.25

package/dist/monolith/infrastructure/ai/providers/OpenRouterProvider.js

@@ -1,426 +1,460 @@
-import { ConfigService } from "../../config/ConfigService.js";
-import { getErrorMessage } from "../../../plumbing/utils/ErrorUtils.js";
-import { JsonUtils } from "../../../plumbing/utils/JsonUtils.js";
-import { OpenRouterStreamParser } from "./OpenRouterStreamParser.js";
-export class OpenRouterProvider {
-    apiKey;
-    baseUrl = "https://openrouter.ai/api/v1";
-    constructor(apiKey) {
-        this.apiKey = apiKey;
+import { getTokensPerChar } from "../../config/ConfigService.js";
+import { getErrorMessage, safeParseJson, extractToolCall, createStreamTagDetector, safeStringify, safeGetValues } from "../../../plumbing/utils/PlumbingCore.js";
+const BASE_URL = "https://openrouter.ai/api/v1";
+/**
+ * Translates Anthropic model names to OpenRouter format.
+ * OpenRouter expects format like "anthropic/claude-3.5-sonnet"
+ */
+function translateModelName(model) {
+    const normalized = (model || "").trim();
+    if (!normalized) {
+        return "anthropic/claude-3.5-sonnet";
     }
-    async createMessage(params) {
-        const translatedModel = this.translateModelName(params.model);
-        const response = await fetch(`${this.baseUrl}/chat/completions`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                "HTTP-Referer": "https://github.com/bozoegg/MarieCoder",
-                "X-Title": "MarieCoder VS Code Extension",
-                "Content-Type": "application/json",
-                Accept: "application/json",
-            },
-            body: JSON.stringify({
-                model: translatedModel,
-                messages: this.getOpenAiMessages(params),
-                tools: this.getOpenAiTools(params),
-                max_tokens: params.max_tokens || 1024,
-            }),
-        });
-        if (!response.ok) {
-            let errorMsg = `OpenRouter API error: ${response.status} ${response.statusText} (model: ${translatedModel})`;
-            try {
-                const errorJson = (await response.json());
-                if (errorJson.error?.message)
-                    errorMsg = `OpenRouter API error: ${errorJson.error.message} (model: ${translatedModel})`;
-            }
-            catch (e) {
-                const text = await response.text().catch(() => "");
-                if (text)
-                    errorMsg += ` - ${text}`;
-            }
-            throw new Error(errorMsg);
+    // If already in OpenRouter format, return as-is
+    if (normalized.includes("/")) {
+        return normalized;
+    }
+    // Map Anthropic model names to OpenRouter format
+    const modelMap = {
+        "claude-3-5-sonnet-20241022": "anthropic/claude-3.5-sonnet",
+        "claude-3-5-sonnet": "anthropic/claude-3.5-sonnet",
+        "claude-3-5-haiku-20241022": "anthropic/claude-3.5-haiku",
+        "claude-3-5-haiku": "anthropic/claude-3.5-haiku",
+        "claude-3-opus-20240229": "anthropic/claude-3-opus",
+        "claude-3-opus": "anthropic/claude-3-opus",
+        "claude-3-sonnet-20240229": "anthropic/claude-3-sonnet",
+        "claude-3-sonnet": "anthropic/claude-3-sonnet",
+        "claude-3-haiku-20240307": "anthropic/claude-3-haiku",
+        "claude-3-haiku": "anthropic/claude-3-haiku",
+    };
+    if (modelMap[normalized]) {
+        return modelMap[normalized];
+    }
+    // Try to convert claude models that aren't in the map.
+    if (normalized.startsWith("claude-")) {
+        const withoutDateSuffix = normalized.replace(/-20\d{6}$/, "");
+        const claudeVersioned = withoutDateSuffix.match(/^claude-(\d+)-(\d+)(-.+)$/);
+        if (claudeVersioned) {
+            const major = claudeVersioned[1];
+            const minor = claudeVersioned[2];
+            const variant = claudeVersioned[3];
+            return `anthropic/claude-${major}.${minor}${variant}`;
         }
-        const data = (await response.json());
-        if (!data.choices || data.choices.length === 0)
-            throw new Error("OpenRouter API returned no choices.");
-        const choice = data.choices[0].message;
-        if (choice.tool_calls && choice.tool_calls.length > 0) {
-            try {
-                const toolUses = choice.tool_calls.map((tc) => ({
-                    id: tc.id,
-                    name: tc.function.name,
-                    input: JsonUtils.safeParseJson(tc.function.arguments),
-                }));
-                return {
-                    role: "assistant",
-                    content: choice.content || "",
-                    tool_uses: toolUses,
-                };
+        return `anthropic/${withoutDateSuffix}`;
+    }
+    // Return as-is if we can't translate
+    return normalized;
+}
+function getOpenAiMessages(params) {
+    const messages = [];
+    if (params.system)
+        messages.push({ role: "system", content: params.system });
+    for (const msg of params.messages) {
+        if (typeof msg.content === "string") {
+            messages.push({ role: msg.role, content: msg.content });
+        }
+        else if (Array.isArray(msg.content)) {
+            let text = "";
+            const tools = [];
+            for (const block of msg.content) {
+                if (block.type === "text")
+                    text += block.text;
+                else if (block.type === "tool_use")
+                    tools.push({
+                        id: block.id,
+                        type: "function",
+                        function: {
+                            name: block.name,
+                            arguments: safeStringify(block.input),
+                        },
+                    });
+                else if (block.type === "tool_result") {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: block.tool_use_id,
+                        content: typeof block.content === "string"
+                            ? block.content
+                            : safeStringify(block.content),
+                    });
+                }
             }
-            catch (error) {
-                console.error("Failed to parse tool arguments from OpenRouter:", getErrorMessage(error));
-                return {
-                    role: "assistant",
-                    content: choice.content || `(Message error: Malformed tool arguments)`,
-                };
+            if (msg.role === "assistant" && (text || tools.length > 0)) {
+                const m = { role: "assistant", content: text || null };
+                if (tools.length > 0)
+                    m.tool_calls = tools;
+                messages.push(m);
+            }
+            else if (msg.role === "user" && text) {
+                messages.push({ role: "user", content: text });
             }
         }
-        return {
-            role: "assistant",
-            content: choice.content || "",
-        };
     }
-    async createMessageStream(params, onUpdate, signal) {
-        const controller = new AbortController();
-        let isTimeout = false;
-        const timeoutId = setTimeout(() => {
-            isTimeout = true;
-            controller.abort();
-        }, 120000);
-        let isUserAbort = false;
-        const onAbort = () => {
-            isUserAbort = true;
-            controller.abort();
-        };
-        if (signal)
-            signal.addEventListener("abort", onAbort);
-        try {
-            const translatedModel = this.translateModelName(params.model);
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    return messages;
+}
+function getOpenAiTools(params) {
+    if (!params.tools)
+        return undefined;
+    return params.tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        },
+    }));
+}
+function stripToolWrapperTags(text) {
+    if (!text)
+        return "";
+    return text
+        .replace(/<\|tool_calls_section_begin\|>/g, "")
+        .replace(/<\|tool_calls_section_end\|>/g, "")
+        .replace(/<\|tool_call_begin\|>/g, "")
+        .replace(/<\|tool_call_end\|>/g, "")
+        .replace(/<\|tool_call_argument_begin\|>/g, "")
+        .replace(/<\|tool_call_arguments_begin\|>/g, "")
+        .replace(/<tool_call>/g, "")
+        .replace(/<\/tool_call>/g, "")
+        .replace(/<tool>/g, "")
+        .replace(/<\/tool>/g, "")
+        .replace(/<function\b[^>]*>/g, "")
+        .replace(/<\/function>/g, "")
+        .replace(/<function_calls>/g, "")
+        .replace(/<\/function_calls>/g, "")
+        .trim();
+}
+function createStreamParser() {
+    const tagDetector = createStreamTagDetector();
+    let llamaToolMode = false;
+    let thinkingMode = false;
+    let llamaBufferParts = [];
+    const toolCalls = {};
+    let indexCount = 0;
+    function finalizeCurrentBuffer(events) {
+        if (llamaBufferParts.length === 0)
+            return;
+        const bufferContent = llamaBufferParts.join("");
+        const extracted = extractToolCall(bufferContent);
+        if (extracted) {
+            const id = extracted.id || `call_${Date.now()}_${indexCount}`;
+            events.push({ type: "tool_call_delta", index: indexCount, id, name: extracted.name, argumentsDelta: safeStringify(extracted.input) });
+            toolCalls[indexCount] = { id, name: extracted.name, arguments: safeStringify(extracted.input) };
+            indexCount++;
+        }
+        else {
+            const cleaned = stripToolWrapperTags(bufferContent);
+            if (cleaned)
+                events.push({ type: "content_delta", text: cleaned });
+        }
+        llamaBufferParts = [];
+        llamaToolMode = false;
+    }
+    return {
+        process(chunk, onUpdate, contentParts, reasoningParts) {
+            let currentChunk = chunk;
+            while (true) {
+                const detection = tagDetector.process(currentChunk);
+                currentChunk = "";
+                if (detection.text) {
+                    if (llamaToolMode)
+                        llamaBufferParts.push(detection.text);
+                    else if (thinkingMode) {
+                        reasoningParts.push(detection.text);
+                        onUpdate({ type: "reasoning_delta", text: detection.text });
+                    }
+                    else {
+                        contentParts.push(detection.text);
+                        onUpdate({ type: "content_delta", text: detection.text });
+                    }
+                }
+                if (detection.type === "tag") {
+                    const tag = detection.tag;
+                    if (tag === "<thought>") {
+                        thinkingMode = true;
+                        onUpdate({ type: "stage_change", stage: "thinking", label: "Thinking..." });
+                    }
+                    else if (tag === "</thought>") {
+                        thinkingMode = false;
+                        onUpdate({ type: "stage_change", stage: "responding", label: "Generating response..." });
+                    }
+                    else if (tag.startsWith("[Tool Use:") || tag.startsWith("[Tool Result:")) {
+                        if (llamaToolMode)
+                            finalizeCurrentBuffer([]); // Logic merger simplification
+                        if (tag.startsWith("[Tool Use:")) {
+                            llamaToolMode = true;
+                            llamaBufferParts.push(tag);
+                            onUpdate({ type: "stage_change", stage: "calling_tool", label: "Using tool..." });
+                        }
+                        else
+                            onUpdate({ type: "content_delta", text: tag });
+                    }
+                    else {
+                        const isEnd = ["</tool>", "<|tool_call_end|>", "</invoke>", "</function>", "</tool_code>", "</tool_call>", "</call>"].includes(tag) || tag === "<|tool_calls_section_end|>";
+                        const isStart = ["<tool>", "<|tool_call_begin|>", "<function_calls>", "<tool_code>", "<tool_call>"].includes(tag) || tag === "<|tool_calls_section_begin|>" || tag.startsWith("<function") || tag === "<invoke";
+                        if (isEnd) {
+                            llamaBufferParts.push(tag);
+                            const bufferContent = llamaBufferParts.join("");
+                            const extracted = extractToolCall(bufferContent);
+                            if (extracted) {
+                                const id = extracted.id || `call_${Date.now()}_${indexCount}`;
+                                onUpdate({ type: "tool_call_delta", index: indexCount, id, name: extracted.name, argumentsDelta: safeStringify(extracted.input) });
+                                toolCalls[indexCount] = { id, name: extracted.name, arguments: safeStringify(extracted.input) };
+                                indexCount++;
+                            }
+                            else {
+                                const cleaned = stripToolWrapperTags(bufferContent);
+                                if (cleaned)
+                                    onUpdate({ type: "content_delta", text: cleaned });
+                            }
+                            llamaToolMode = false;
+                            llamaBufferParts = [];
+                        }
+                        else if (isStart) {
+                            llamaToolMode = true;
+                            onUpdate({ type: "stage_change", stage: "calling_tool", label: "Using tool..." });
+                            llamaBufferParts.push(tag);
+                        }
+                        else if (llamaToolMode)
+                            llamaBufferParts.push(tag);
+                        else
+                            onUpdate({ type: "content_delta", text: tag });
+                    }
+                    continue;
+                }
+                break;
+            }
+        },
+        finalize(fullContent, onUpdate) {
+            const bufferContent = llamaBufferParts.join("");
+            let extracted = extractToolCall(bufferContent) || extractToolCall(fullContent);
+            if (extracted) {
+                const id = extracted.id || `call_${Date.now()}_${indexCount}_final`;
+                const collectedValues = safeGetValues(toolCalls, 50);
+                const already = collectedValues.some(tc => tc.name === extracted.name && (tc.arguments === safeStringify(extracted.input)));
+                if (!already) {
+                    onUpdate({ type: "tool_call_delta", index: indexCount, id, name: extracted.name, argumentsDelta: safeStringify(extracted.input) });
+                    toolCalls[indexCount] = { id, name: extracted.name, arguments: safeStringify(extracted.input) };
+                    indexCount++;
+                }
+                llamaBufferParts = [];
+            }
+            else if (llamaToolMode) {
+                const cleaned = stripToolWrapperTags(llamaBufferParts.join(""));
+                if (cleaned)
+                    onUpdate({ type: "content_delta", text: cleaned });
+            }
+            llamaToolMode = false;
+            llamaBufferParts = [];
+        },
+        getToolCalls: () => toolCalls
+    };
+}
+export function createOpenRouterProvider(apiKey) {
+    return {
+        async createMessage(params) {
+            const translatedModel = translateModelName(params.model);
+            const response = await fetch(`${BASE_URL}/chat/completions`, {
                 method: "POST",
                 headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "HTTP-Referer": "https://github.com/bozoegg/MarieCoder",
-                    "X-Title": "MarieCoder VS Code Extension",
+                    Authorization: `Bearer ${apiKey}`,
+                    "HTTP-Referer": "https://github.com/CardSorting/Marie-Coder-New-the-vatican",
+                    "X-Title": "DreamBees CLI",
                     "Content-Type": "application/json",
-                    Accept: "text/event-stream",
-                    "Cache-Control": "no-cache",
-                    Connection: "keep-alive",
+                    Accept: "application/json",
                 },
-                body: JSON.stringify({
+                body: safeStringify({
                     model: translatedModel,
-                    messages: this.getOpenAiMessages(params),
-                    tools: this.getOpenAiTools(params),
+                    messages: getOpenAiMessages(params),
+                    tools: getOpenAiTools(params),
                     max_tokens: params.max_tokens || 1024,
-                    stream: true,
-                    include_reasoning: true,
                 }),
-                signal: controller.signal,
             });
             if (!response.ok) {
-                throw new Error(`OpenRouter API error: ${response.status} (model: ${translatedModel})`);
-            }
-            if (!response.body)
-                throw new Error("OpenRouter API returned no body.");
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            const contentParts = [];
-            const reasoningParts = [];
-            const bufferParts = [];
-            const toolCalls = {};
-            const startTime = Date.now();
-            onUpdate({ type: "run_started", timestamp: startTime });
-            onUpdate({
-                type: "stage_change",
-                stage: "thinking",
-                label: "Processing request...",
-            });
-            const streamParser = new OpenRouterStreamParser();
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    const chunk = decoder.decode(value, { stream: true });
-                    bufferParts.push(chunk);
-                    const buffer = bufferParts.join("");
-                    const lines = buffer.split("\n");
-                    const remainder = lines.pop() || "";
-                    bufferParts.length = 0;
-                    if (remainder)
-                        bufferParts.push(remainder);
-                    for (const line of lines) {
-                        const trimmedLine = line.trim();
-                        if (!trimmedLine || trimmedLine.startsWith(":"))
-                            continue;
-                        if (trimmedLine.startsWith("data: ")) {
-                            const dataStr = trimmedLine.slice(6);
-                            if (dataStr === "[DONE]")
-                                continue;
-                            try {
-                                const data = JSON.parse(dataStr);
-                                const choice = data.choices?.[0];
-                                if (!choice)
-                                    continue;
-                                const delta = choice.delta;
-                                if (delta?.content) {
-                                    const events = streamParser.processContent(delta.content);
-                                    for (const event of events) {
-                                        if (event.type === "content_delta")
-                                            contentParts.push(event.text);
-                                        if (event.type === "reasoning_delta")
-                                            reasoningParts.push(event.text);
-                                        onUpdate(event);
-                                    }
-                                }
-                                if (delta?.tool_calls) {
-                                    onUpdate({
-                                        type: "stage_change",
-                                        stage: "calling_tool",
-                                        label: "Using tool...",
-                                    });
-                                    for (const tc of delta.tool_calls) {
-                                        const idx = tc.index;
-                                        if (!toolCalls[idx]) {
-                                            toolCalls[idx] = {
-                                                id: tc.id || "",
-                                                name: tc.function?.name || "",
-                                                argumentsParts: [],
-                                            };
-                                        }
-                                        else {
-                                            if (tc.id)
-                                                toolCalls[idx].id = tc.id;
-                                            if (tc.function?.name)
-                                                toolCalls[idx].name += tc.function.name;
-                                        }
-                                        if (tc.function?.arguments) {
-                                            toolCalls[idx].argumentsParts.push(tc.function.arguments);
-                                            onUpdate({
-                                                type: "tool_call_delta",
-                                                index: idx,
-                                                id: toolCalls[idx].id,
-                                                name: toolCalls[idx].name,
-                                                argumentsDelta: tc.function.arguments,
-                                            });
-                                        }
-                                    }
-                                }
-                                if (data.usage) {
-                                    onUpdate({
-                                        type: "usage",
-                                        usage: {
-                                            inputTokens: data.usage.prompt_tokens,
-                                            outputTokens: data.usage.completion_tokens,
-                                            totalTokens: data.usage.total_tokens,
-                                            reasoningTokens: data.usage.reasoning_tokens,
-                                        },
-                                    });
-                                }
-                            }
-                            catch (e) {
-                                // Ignore parsing errors for individual chunks
-                            }
-                        }
-                    }
+                let errorMsg = `OpenRouter API error: ${response.status} ${response.statusText} (model: ${translatedModel})`;
+                try {
+                    const errorJson = (await response.json());
+                    if (errorJson.error?.message)
+                        errorMsg = `OpenRouter API error: ${errorJson.error.message} (model: ${translatedModel})`;
                 }
+                catch (e) {
+                    const text = await response.text().catch(() => "");
+                    if (text)
+                        errorMsg += ` - ${text}`;
+                }
+                throw new Error(errorMsg);
             }
-            finally {
-                reader.releaseLock();
-            }
-            // Join all array buffers into final strings
-            const fullContent = contentParts.join("");
-            const fullReasoning = reasoningParts.join("");
-            const finalEvents = streamParser.finalize(fullContent);
-            for (const event of finalEvents)
-                onUpdate(event);
-            const endTime = Date.now();
-            onUpdate({
-                type: "run_completed",
-                timestamp: endTime,
-                durationMs: endTime - startTime,
-            });
-            const llamaCalls = streamParser.getCollectedToolCalls();
-            for (const idx in llamaCalls) {
-                const call = llamaCalls[idx];
-                toolCalls[parseInt(idx) + 1000] = {
-                    id: call.id,
-                    name: call.name,
-                    argumentsParts: [call.arguments], // Wrap string as array for consistency
-                };
-            }
-            const finalToolUses = [];
-            for (const idx in toolCalls) {
-                const tc = toolCalls[idx];
+            const data = (await response.json());
+            if (!data.choices || data.choices.length === 0)
+                throw new Error("OpenRouter API returned no choices.");
+            const choice = data.choices[0].message;
+            if (choice.tool_calls && choice.tool_calls.length > 0) {
                 try {
-                    const args = tc.argumentsParts.join("");
-                    finalToolUses.push({
+                    const toolUses = choice.tool_calls.map((tc) => ({
                         id: tc.id,
-                        name: tc.name,
-                        input: JsonUtils.safeParseJson(args),
-                    });
+                        name: tc.function.name,
+                        input: safeParseJson(tc.function.arguments).result,
+                    }));
+                    return {
+                        role: "assistant",
+                        content: choice.content || "",
+                        tool_uses: toolUses,
+                    };
                 }
-                catch (e) {
-                    // Ignore tool call parsing errors in stream
+                catch (error) {
+                    console.error("Failed to parse tool arguments from OpenRouter:", getErrorMessage(error));
+                    return {
+                        role: "assistant",
+                        content: choice.content || `(Message error: Malformed tool arguments)`,
+                    };
                 }
             }
-            const blocks = [];
-            if (fullReasoning)
-                blocks.push({ type: "thought", text: fullReasoning });
-            if (fullContent)
-                blocks.push({ type: "text", text: fullContent });
             return {
                 role: "assistant",
-                content: blocks.length > 0 ? blocks : fullContent,
-                tool_uses: finalToolUses.length > 0 ? finalToolUses : undefined,
+                content: choice.content || "",
             };
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError") {
-                // Distinguish between user manual stop and actual timeout
-                if (isUserAbort) {
-                    throw new Error("Request stopped by user");
+        },
+        async createMessageStream(params, onUpdate, signal) {
+            const controller = new AbortController();
+            let isTimeout = false;
+            const timeoutId = setTimeout(() => {
+                isTimeout = true;
+                controller.abort();
+            }, 120000);
+            let isUserAbort = false;
+            const onAbort = () => {
+                isUserAbort = true;
+                controller.abort();
+            };
+            if (signal)
+                signal.addEventListener("abort", onAbort);
+            try {
+                const translatedModel = translateModelName(params.model);
+                const response = await fetch(`${BASE_URL}/chat/completions`, {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        "HTTP-Referer": "https://github.com/CardSorting/Marie-Coder-New-the-vatican",
+                        "X-Title": "DreamBees CLI",
+                        "Content-Type": "application/json",
+                        Accept: "text/event-stream",
+                        "Cache-Control": "no-cache",
+                        Connection: "keep-alive",
+                    },
+                    body: safeStringify({
+                        model: translatedModel,
+                        messages: getOpenAiMessages(params),
+                        tools: getOpenAiTools(params),
+                        max_tokens: params.max_tokens || 1024,
+                        stream: true,
+                        include_reasoning: true,
+                    }),
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`OpenRouter API error: ${response.status} (model: ${translatedModel})`);
                 }
-                else if (isTimeout) {
-                    throw new Error("OpenRouter timeout");
+                if (!response.body)
+                    throw new Error("OpenRouter API returned no body.");
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                const contentParts = [];
+                const reasoningParts = [];
+                const bufferParts = [];
+                const toolCalls = {};
+                const startTime = Date.now();
+                onUpdate({ type: "run_started", timestamp: startTime });
+                onUpdate({
+                    type: "stage_change",
+                    stage: "thinking",
+                    label: "Processing request...",
+                });
+                const streamParser = createStreamParser();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        const chunk = decoder.decode(value, { stream: true });
+                        streamParser.process(chunk, onUpdate, contentParts, reasoningParts);
+                    }
                 }
-                else {
-                    throw new Error("Request aborted");
+                finally {
+                    reader.releaseLock();
                 }
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(timeoutId);
-            if (signal)
-                signal.removeEventListener("abort", onAbort);
-        }
-    }
-    /**
-     * Translates Anthropic model names to OpenRouter format.
-     * OpenRouter expects format like "anthropic/claude-3.5-sonnet"
-     */
-    translateModelName(model) {
-        const normalized = (model || "").trim();
-        if (!normalized) {
-            return "anthropic/claude-3.5-sonnet";
-        }
-        // If already in OpenRouter format, return as-is
-        if (normalized.includes("/")) {
-            return normalized;
-        }
-        // Map Anthropic model names to OpenRouter format
-        const modelMap = {
-            "claude-3-5-sonnet-20241022": "anthropic/claude-3.5-sonnet",
-            "claude-3-5-sonnet": "anthropic/claude-3.5-sonnet",
-            "claude-3-5-haiku-20241022": "anthropic/claude-3.5-haiku",
-            "claude-3-5-haiku": "anthropic/claude-3.5-haiku",
-            "claude-3-opus-20240229": "anthropic/claude-3-opus",
-            "claude-3-opus": "anthropic/claude-3-opus",
-            "claude-3-sonnet-20240229": "anthropic/claude-3-sonnet",
-            "claude-3-sonnet": "anthropic/claude-3-sonnet",
-            "claude-3-haiku-20240307": "anthropic/claude-3-haiku",
-            "claude-3-haiku": "anthropic/claude-3-haiku",
-        };
-        if (modelMap[normalized]) {
-            return modelMap[normalized];
-        }
-        // Try to convert claude models that aren't in the map.
-        // Examples:
-        // - claude-3-5-sonnet-20241022 => anthropic/claude-3.5-sonnet
-        // - claude-3-7-sonnet => anthropic/claude-3.7-sonnet
-        if (normalized.startsWith("claude-")) {
-            const withoutDateSuffix = normalized.replace(/-20\d{6}$/, "");
-            const claudeVersioned = withoutDateSuffix.match(/^claude-(\d+)-(\d+)(-.+)$/);
-            if (claudeVersioned) {
-                const major = claudeVersioned[1];
-                const minor = claudeVersioned[2];
-                const variant = claudeVersioned[3];
-                return `anthropic/claude-${major}.${minor}${variant}`;
-            }
-            return `anthropic/${withoutDateSuffix}`;
-        }
-        // Return as-is if we can't translate
-        return normalized;
-    }
-    getOpenAiMessages(params) {
-        const messages = [];
-        if (params.system)
-            messages.push({ role: "system", content: params.system });
-        for (const msg of params.messages) {
-            if (typeof msg.content === "string") {
-                messages.push({ role: msg.role, content: msg.content });
-            }
-            else if (Array.isArray(msg.content)) {
-                let text = "";
-                const tools = [];
-                for (const block of msg.content) {
-                    if (block.type === "text")
-                        text += block.text;
-                    else if (block.type === "tool_use")
-                        tools.push({
-                            id: block.id,
-                            type: "function",
-                            function: {
-                                name: block.name,
-                                arguments: JSON.stringify(block.input),
-                            },
-                        });
-                    else if (block.type === "tool_result") {
-                        messages.push({
-                            role: "tool",
-                            tool_call_id: block.tool_use_id,
-                            content: typeof block.content === "string"
-                                ? block.content
-                                : JSON.stringify(block.content),
-                        });
+                const fullContent = contentParts.join("");
+                streamParser.finalize(fullContent, onUpdate);
+                const endTime = Date.now();
+                onUpdate({ type: "run_completed", timestamp: endTime, durationMs: endTime - startTime });
+                const finalToolUses = [];
+                for (const tc of Object.values(streamParser.getToolCalls())) {
+                    try {
+                        finalToolUses.push({ id: tc.id, name: tc.name, input: safeParseJson(tc.arguments).result });
                     }
+                    catch { }
                 }
-                if (msg.role === "assistant" && (text || tools.length > 0)) {
-                    const m = { role: "assistant", content: text || null };
-                    if (tools.length > 0)
-                        m.tool_calls = tools;
-                    messages.push(m);
-                }
-                else if (msg.role === "user" && text) {
-                    messages.push({ role: "user", content: text });
+                const blocks = [];
+                if (reasoningParts.length > 0)
+                    blocks.push({ type: "thought", text: reasoningParts.join("") });
+                if (contentParts.length > 0)
+                    blocks.push({ type: "text", text: contentParts.join("") });
+                return {
+                    role: "assistant",
+                    content: blocks.length > 0 ? blocks : fullContent,
+                    tool_uses: finalToolUses.length > 0 ? finalToolUses : undefined,
+                };
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    // Distinguish between user manual stop and actual timeout
+                    if (isUserAbort) {
+                        throw new Error("Request stopped by user");
+                    }
+                    else if (isTimeout) {
+                        throw new Error("OpenRouter timeout");
+                    }
+                    else {
+                        throw new Error("Request aborted");
+                    }
                 }
+                throw error;
             }
-        }
-        return messages;
-    }
-    getOpenAiTools(params) {
-        if (!params.tools)
-            return undefined;
-        return params.tools.map((tool) => ({
-            type: "function",
-            function: {
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.input_schema,
-            },
-        }));
-    }
-    estimateTokens(text) {
-        return Math.ceil(text.length * ConfigService.getTokensPerChar());
-    }
-    async listModels() {
-        return [
-            { id: "anthropic/claude-3.5-sonnet", name: "Claude 3.5 Sonnet" },
-            { id: "google/gemini-2.0-flash-001", name: "Gemini 2.0 Flash" },
-        ];
-    }
-    async createEmbedding(text) {
-        const response = await fetch(`${this.baseUrl}/embeddings`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                "HTTP-Referer": "https://github.com/bozoegg/MarieCoder",
-                "X-Title": "MarieCoder VS Code Extension",
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                model: "openai/text-embedding-3-small",
-                input: text,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`OpenRouter Embedding error: ${response.status}`);
-        }
-        const data = (await response.json());
-        if (!data.data || data.data.length === 0)
-            throw new Error("OpenRouter Embedding returned no data.");
-        return data.data[0].embedding;
-    }
+            finally {
+                clearTimeout(timeoutId);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+            }
+        },
+        estimateTokens(text) {
+            return Math.ceil(text.length * getTokensPerChar());
+        },
+        async listModels() {
+            return [
+                { id: "anthropic/claude-3.5-sonnet", name: "Claude 3.5 Sonnet" },
+                { id: "google/gemini-2.0-flash-001", name: "Gemini 2.0 Flash" },
+            ];
+        },
+        async createEmbedding(text) {
+            const response = await fetch(`${BASE_URL}/embeddings`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "HTTP-Referer": "https://github.com/CardSorting/Marie-Coder-New-the-vatican",
+                    "X-Title": "DreamBees CLI",
+                    "Content-Type": "application/json",
+                },
+                body: safeStringify({
+                    model: "openai/text-embedding-3-small",
+                    input: text,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`OpenRouter Embedding error: ${response.status}`);
+            }
+            const data = (await response.json());
+            if (!data.data || data.data.length === 0)
+                throw new Error("OpenRouter Embedding returned no data.");
+            return data.data[0].embedding;
+        },
+    };
 }
 //# sourceMappingURL=OpenRouterProvider.js.map