@backtest-kit/ollama 0.0.1

package/build/index.mjs

@@ -0,0 +1,2905 @@
+import { json, event, validateToolArguments, RoundRobin, addCompletion, addOutline, validate } from 'agent-swarm-kit';
+import { scoped } from 'di-scoped';
+import { createActivator } from 'di-kit';
+import MarkdownIt from 'markdown-it';
+import sanitizeHtml from 'sanitize-html';
+import { lint } from 'markdownlint/promise';
+import { applyFixes } from 'markdownlint';
+import { ToolRegistry, memoize, singleshot, randomString, fetchApi, str } from 'functools-kit';
+import OpenAI from 'openai';
+import { AIMessage, SystemMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import { ChatXAI } from '@langchain/xai';
+import { jsonrepair } from 'jsonrepair';
+import fs from 'fs/promises';
+import { InferenceClient } from '@huggingface/inference';
+import { ChatOpenAI } from '@langchain/openai';
+import { get, set } from 'lodash-es';
+import { Ollama } from 'ollama';
+import { zodResponseFormat } from 'openai/helpers/zod';
+import { z } from 'zod';
+
+var CompletionName;
+(function (CompletionName) {
+    CompletionName["RunnerCompletion"] = "runner_completion";
+    CompletionName["RunnerStreamCompletion"] = "runner_stream_completion";
+    CompletionName["RunnerOutlineCompletion"] = "runner_outline_completion";
+})(CompletionName || (CompletionName = {}));
+var CompletionName$1 = CompletionName;
+
+const ContextService = scoped(class {
+    constructor(context) {
+        this.context = context;
+    }
+});
+
+const NOOP_LOGGER = {
+    log() {
+    },
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+};
+class LoggerService {
+    constructor() {
+        this._commonLogger = NOOP_LOGGER;
+        this.log = async (topic, ...args) => {
+            await this._commonLogger.log(topic, ...args);
+        };
+        this.debug = async (topic, ...args) => {
+            await this._commonLogger.debug(topic, ...args);
+        };
+        this.info = async (topic, ...args) => {
+            await this._commonLogger.info(topic, ...args);
+        };
+        this.warn = async (topic, ...args) => {
+            await this._commonLogger.warn(topic, ...args);
+        };
+        this.setLogger = (logger) => {
+            this._commonLogger = logger;
+        };
+    }
+}
+
+const { provide, inject, init, override } = createActivator("ollama");
+
+const commonServices$1 = {
+    loggerService: Symbol("loggerService"),
+};
+const baseServices$1 = {
+    contextService: Symbol('contextService'),
+};
+const privateServices$1 = {
+    runnerPrivateService: Symbol('runnerPrivateService'),
+    outlinePrivateService: Symbol('outlinePrivateService'),
+};
+const publicServices$1 = {
+    runnerPublicService: Symbol('runnerPublicService'),
+    outlinePublicService: Symbol('outlinePublicService'),
+};
+const TYPES = {
+    ...commonServices$1,
+    ...baseServices$1,
+    ...privateServices$1,
+    ...publicServices$1,
+};
+
+var OutlineName;
+(function (OutlineName) {
+    OutlineName["SignalOutline"] = "signal_outline";
+})(OutlineName || (OutlineName = {}));
+var OutlineName$1 = OutlineName;
+
+const toLintMarkdown = async (content) => {
+    if (!content) {
+        return "";
+    }
+    const { content: errors } = await lint({ strings: { content } });
+    if (!errors.length) {
+        return content;
+    }
+    const value = applyFixes(content, errors);
+    return value ? value : content;
+};
+globalThis.toLintMarkdown = toLintMarkdown;
+
+const toPlainString = async (content) => {
+    if (!content) {
+        return "";
+    }
+    const markdown = await toLintMarkdown(content);
+    const md = new MarkdownIt({
+        html: false,
+        breaks: true,
+        linkify: true,
+        typographer: true,
+    });
+    let telegramHtml = md.render(markdown);
+    telegramHtml = sanitizeHtml(telegramHtml, {
+        allowedTags: [
+            "b",
+            "i",
+            "a",
+            "code",
+            "pre",
+            "s",
+            "u",
+            "tg-spoiler",
+            "blockquote",
+            "br",
+        ],
+        allowedAttributes: {
+            a: ["href"],
+        },
+        transformTags: {
+            h1: "",
+            h2: "",
+            h3: "",
+            h4: "",
+            h5: "",
+            h6: "",
+            a: "",
+            strong: "",
+            em: "",
+            p: () => "",
+            ul: () => "",
+            li: () => "• ",
+            ol: () => "",
+            hr: () => "\n",
+            br: () => "\n",
+            div: () => "",
+        },
+    });
+    return telegramHtml.replaceAll(/\n[\s\n]*\n/g, "\n").trim();
+};
+
+class OutlinePrivateService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getCompletion = async (messages) => {
+            this.loggerService.log("outlinePrivateService getCompletion", {
+                messages,
+            });
+            const { data, resultId, error } = await json(OutlineName$1.SignalOutline, messages);
+            if (error) {
+                throw new Error(error);
+            }
+            if (data.position === "wait") {
+                return null;
+            }
+            return {
+                id: resultId,
+                position: data.position,
+                minuteEstimatedTime: +data.minute_estimated_time,
+                priceStopLoss: +data.price_stop_loss,
+                priceTakeProfit: +data.price_take_profit,
+                note: await toPlainString(data.risk_note),
+                priceOpen: +data.price_open,
+            };
+        };
+    }
+}
+
+class RunnerPrivateService {
+    constructor() {
+        this.contextService = inject(TYPES.contextService);
+        this.loggerService = inject(TYPES.loggerService);
+        this._registry = new ToolRegistry("runner_registry");
+        this.getRunner = memoize(([inference]) => `${inference}`, (inference) => {
+            const Runner = this._registry.get(inference);
+            return new Runner(this.contextService, this.loggerService);
+        });
+        this.getCompletion = async (params) => {
+            this.loggerService.log("runnerPrivateService getCompletion");
+            const runner = this.getRunner(this.contextService.context.inference);
+            return await runner.getCompletion(params);
+        };
+        this.getStreamCompletion = async (params) => {
+            this.loggerService.log("runnerPrivateService getStreamCompletion");
+            const runner = this.getRunner(this.contextService.context.inference);
+            return await runner.getStreamCompletion(params);
+        };
+        this.getOutlineCompletion = async (params) => {
+            this.loggerService.log("runnerPrivateService getOutlineCompletion");
+            const runner = this.getRunner(this.contextService.context.inference);
+            return await runner.getOutlineCompletion(params);
+        };
+        this.registerRunner = (name, runner) => {
+            this._registry = this._registry.register(name, runner);
+        };
+    }
+}
+
+class OutlinePublicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.outlinePrivateService = inject(TYPES.outlinePrivateService);
+        this.getCompletion = async (messages, inference, model, apiKey) => {
+            this.loggerService.log("outlinePublicService getCompletion", {
+                messages,
+                model,
+                apiKey,
+                inference,
+            });
+            return await ContextService.runInContext(async () => {
+                return await this.outlinePrivateService.getCompletion(messages);
+            }, {
+                apiKey: apiKey,
+                inference,
+                model,
+            });
+        };
+    }
+}
+
+class RunnerPublicService {
+    constructor() {
+        this.runnerPrivateService = inject(TYPES.runnerPrivateService);
+        this.loggerService = inject(TYPES.loggerService);
+        this.getCompletion = async (params, context) => {
+            this.loggerService.log("runnerPublicService getCompletion");
+            return await ContextService.runInContext(async () => {
+                return await this.runnerPrivateService.getCompletion(params);
+            }, context);
+        };
+        this.getStreamCompletion = async (params, context) => {
+            this.loggerService.log("runnerPublicService getStreamCompletion");
+            return await ContextService.runInContext(async () => {
+                return await this.runnerPrivateService.getStreamCompletion(params);
+            }, context);
+        };
+        this.getOutlineCompletion = async (params, context) => {
+            this.loggerService.log("runnerPublicService getOutlineCompletion");
+            return await ContextService.runInContext(async () => {
+                return await this.runnerPrivateService.getOutlineCompletion(params);
+            }, context);
+        };
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+}
+{
+    provide(TYPES.contextService, () => new ContextService());
+}
+{
+    provide(TYPES.runnerPrivateService, () => new RunnerPrivateService());
+    provide(TYPES.outlinePrivateService, () => new OutlinePrivateService());
+}
+{
+    provide(TYPES.runnerPublicService, () => new RunnerPublicService());
+    provide(TYPES.outlinePublicService, () => new OutlinePublicService());
+}
+
+var InferenceName;
+(function (InferenceName) {
+    InferenceName["OllamaInference"] = "ollama_inference";
+    InferenceName["GrokInference"] = "grok_inference";
+    InferenceName["HfInference"] = "hf_inference";
+    InferenceName["ClaudeInference"] = "claude_inference";
+    InferenceName["GPT5Inference"] = "gpt5_inference";
+    InferenceName["DeepseekInference"] = "deepseek_inference";
+    InferenceName["MistralInference"] = "mistral_inference";
+    InferenceName["PerplexityInference"] = "perplexity_inference";
+    InferenceName["CohereInference"] = "cohere_inference";
+    InferenceName["AlibabaInference"] = "alibaba_inference";
+})(InferenceName || (InferenceName = {}));
+var InferenceName$1 = InferenceName;
+
+const getGrok = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        getGrok.clear();
+        throw new Error("Grok provider does not support token rotation");
+    }
+    return new OpenAI({
+        baseURL: "https://api.x.ai/v1",
+        apiKey: apiKey,
+    });
+});
+
+const CC_ENABLE_DEBUG = "CC_ENABLE_DEBUG" in process.env ? !!parseInt(process.env.CC_ENABLE_DEBUG) : false;
+
+class CustomChat extends ChatXAI {
+    async getNumTokens(content) {
+        if (typeof content !== "string") {
+            return 0;
+        }
+        return Math.ceil(content.length / 4);
+    }
+}
+const getChat$1 = (model, apiKey) => new CustomChat({
+    apiKey,
+    model,
+    streaming: true,
+});
+let GrokProvider$1 = class GrokProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const grok = getGrok();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("grokProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await grok.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: tools,
+            response_format: {
+                type: "text",
+            },
+        });
+        const result = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_grok_provider.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Grok provider does not support token rotation");
+        }
+        const chat = getChat$1(this.contextService.context.model, this.contextService.context.apiKey);
+        const { agentName, messages: rawMessages, mode, tools: rawTools, clientId, } = params;
+        this.logger.log("grokProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Validate and format tools
+        const tools = rawTools?.map(({ type, function: f }) => ({
+            type: "function",
+            function: {
+                name: f.name,
+                description: f.description || "",
+                parameters: f.parameters || { type: "object", properties: {} },
+            },
+        }));
+        // Bind tools to chat instance if tools are provided
+        const chatInstance = tools?.length ? chat.bindTools(tools) : chat;
+        // Map raw messages to LangChain messages
+        const messages = rawMessages.map(({ role, tool_calls, tool_call_id, content }) => {
+            if (role === "assistant") {
+                return new AIMessage({
+                    content,
+                    tool_calls: tool_calls?.map(({ function: f, id }) => ({
+                        id: id || randomString(),
+                        name: f.name,
+                        args: f.arguments,
+                    })),
+                });
+            }
+            if (role === "system") {
+                return new SystemMessage({ content });
+            }
+            if (role === "user") {
+                return new HumanMessage({ content });
+            }
+            if (role === "developer") {
+                return new SystemMessage({ content });
+            }
+            if (role === "tool") {
+                return new ToolMessage({
+                    tool_call_id: tool_call_id || randomString(),
+                    content,
+                });
+            }
+            throw new Error(`Unsupported message role: ${role}`);
+        });
+        let textContent = "";
+        let toolCalls = [];
+        // Handle streaming response
+        const stream = await chatInstance.stream(messages);
+        // Aggregate tool calls and content from stream, emit chunks
+        for await (const chunk of stream) {
+            if (chunk.content) {
+                textContent += chunk.content;
+                await event(clientId, "llm-new-token", chunk.content); // Emit content chunk
+            }
+            if (chunk.tool_calls?.length) {
+                toolCalls = [...toolCalls, ...chunk.tool_calls];
+            }
+        }
+        // Process content if it's an array of parts
+        const finalContent = Array.isArray(textContent)
+            ? textContent
+                .filter((part) => part.type === "text")
+                .map((c) => c.text)
+                .join("")
+            : textContent;
+        await event(clientId, "llm-completion", {
+            content: finalContent.trim(),
+            agentName,
+        });
+        // Format tool calls for return
+        const formattedToolCalls = toolCalls.map(({ name, id, args }) => ({
+            id: id || randomString(),
+            type: "function",
+            function: {
+                name,
+                arguments: args,
+            },
+        }));
+        const result = {
+            content: finalContent,
+            mode,
+            agentName,
+            role: "assistant",
+            tool_calls: formattedToolCalls,
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_grok_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        this.logger.log("grokProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Grok provider does not support token rotation");
+        }
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const { choices: [{ message: { refusal, content }, },], } = await fetchApi("https://api.x.ai/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.contextService.context.apiKey}`,
+            },
+            body: JSON.stringify({
+                messages,
+                context: this.contextService.context,
+                max_tokens: 5000,
+                response_format: format,
+            }),
+        });
+        if (refusal) {
+            throw new Error(refusal);
+        }
+        const json = jsonrepair(content);
+        const result = {
+            role: "assistant",
+            content: json,
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_grok_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+};
+
+const MAX_ATTEMPTS$5 = 5;
+class HuggingFaceChat extends ChatOpenAI {
+    async getNumTokens(content) {
+        if (typeof content !== "string") {
+            return 0;
+        }
+        return Math.ceil(content.length / 4);
+    }
+}
+const getChat = (model, apiKey) => new HuggingFaceChat({
+    configuration: {
+        baseURL: "https://router.huggingface.co/v1",
+        apiKey,
+    },
+    model,
+    streaming: true,
+});
+const getInference = (apiKey) => new InferenceClient(apiKey);
+class HfProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Hf provider does not support token rotation");
+        }
+        const inference = getInference(this.contextService.context.apiKey);
+        const { agentName, clientId, messages: rawMessages, mode, tools: rawTools } = params;
+        this.logger.log("hfProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        const messages = rawMessages.map(({ role, content, tool_calls, tool_call_id }) => {
+            if (role === "tool") {
+                return {
+                    role: "tool",
+                    content,
+                    tool_call_id: tool_call_id,
+                };
+            }
+            if (role === "assistant" && tool_calls) {
+                return {
+                    role: "assistant",
+                    content,
+                    tool_calls: tool_calls.map((tc) => ({
+                        id: tc.id,
+                        type: tc.type,
+                        function: {
+                            name: tc.function.name,
+                            arguments: typeof tc.function.arguments === "string"
+                                ? tc.function.arguments
+                                : JSON.stringify(tc.function.arguments),
+                        },
+                    })),
+                };
+            }
+            return {
+                role: role,
+                content,
+            };
+        });
+        const tools = rawTools?.map(({ function: f }) => ({
+            type: "function",
+            function: {
+                name: f.name,
+                description: f.description,
+                parameters: f.parameters,
+            },
+        }));
+        const completion = await inference.chatCompletion({
+            model: this.contextService.context.model,
+            messages,
+            ...(tools && { tools }),
+        });
+        const choice = completion.choices[0];
+        const text = choice.message.content || "";
+        const tool_calls = choice.message.tool_calls || [];
+        const result = {
+            content: text,
+            mode,
+            agentName: agentName,
+            role: "assistant",
+            tool_calls: tool_calls.map(({ id, type, function: f }) => ({
+                id: id,
+                type: type,
+                function: {
+                    name: f.name,
+                    arguments: typeof f.arguments === "string"
+                        ? JSON.parse(f.arguments)
+                        : f.arguments,
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_hf_provider.txt", JSON.stringify({
+                params,
+                answer: result,
+            }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Hf provider does not support token rotation");
+        }
+        const chat = getChat(this.contextService.context.model, this.contextService.context.apiKey);
+        const { agentName, messages: rawMessages, mode, tools: rawTools, clientId, } = params;
+        this.logger.log("hfProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        const tools = rawTools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        const chatInstance = tools ? chat.bindTools(tools) : chat;
+        const { content, tool_calls } = await chatInstance.invoke(rawMessages.map(({ role, tool_calls, tool_call_id, content }) => {
+            if (role === "assistant") {
+                return new AIMessage({
+                    tool_calls: tool_calls?.map(({ function: f, id }) => ({
+                        id: id,
+                        name: f.name,
+                        args: f.arguments,
+                    })),
+                    content,
+                });
+            }
+            if (role === "system") {
+                return new SystemMessage({
+                    content,
+                });
+            }
+            if (role === "user") {
+                return new HumanMessage({
+                    content,
+                });
+            }
+            if (role === "developer") {
+                return new SystemMessage({
+                    content,
+                });
+            }
+            if (role === "tool") {
+                return new ToolMessage({
+                    tool_call_id: tool_call_id,
+                    content,
+                });
+            }
+            return "";
+        }), {
+            callbacks: [
+                {
+                    handleLLMNewToken(token) {
+                        event(clientId, "llm-new-token", token);
+                    },
+                },
+            ],
+        });
+        const text = typeof content === "string"
+            ? content
+            : content
+                .filter((part) => part.type === "text")
+                .map((c) => c.text)
+                .join("");
+        await event(clientId, "llm-completion", {
+            content: text.trim(),
+            agentName,
+        });
+        const result = {
+            content: text,
+            mode,
+            agentName,
+            role: "assistant",
+            tool_calls: tool_calls?.map(({ name, id, args }) => ({
+                id: id ?? randomString(),
+                type: "function",
+                function: {
+                    name,
+                    arguments: args,
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_hf_provider_stream.txt", JSON.stringify({
+                params,
+                answer: result,
+            }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        this.logger.log("hfProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Hf provider does not support token rotation");
+        }
+        // Create tool definition based on format schema
+        const schema = "json_schema" in format
+            ? get(format, "json_schema.schema", format)
+            : format;
+        const toolDefinition = {
+            type: "function",
+            function: {
+                name: "provide_answer",
+                description: "Предоставить ответ в требуемом формате",
+                parameters: schema,
+            },
+        };
+        // Add system instruction for tool usage
+        const systemMessage = {
+            role: "system",
+            content: "ОБЯЗАТЕЛЬНО используй инструмент provide_answer для предоставления ответа. НЕ отвечай обычным текстом. ВСЕГДА вызывай инструмент provide_answer с правильными параметрами.",
+        };
+        const messages = [
+            systemMessage,
+            ...rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+                role,
+                tool_call_id,
+                content,
+                tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                    ...rest,
+                    function: {
+                        name: f.name,
+                        arguments: JSON.stringify(f.arguments),
+                    },
+                })),
+            })),
+        ];
+        let attempt = 0;
+        const addToolRequestMessage = singleshot(() => {
+            messages.push({
+                role: "user",
+                content: "Пожалуйста, используй инструмент provide_answer для предоставления ответа. Не отвечай обычным текстом.",
+            });
+        });
+        while (attempt < MAX_ATTEMPTS$5) {
+            const { choices: [{ message }], } = await fetchApi("https://router.huggingface.co/v1/chat/completions", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.contextService.context.apiKey}`,
+                },
+                body: JSON.stringify({
+                    messages,
+                    model: this.contextService.context.model,
+                    tools: [toolDefinition],
+                    tool_choice: {
+                        type: "function",
+                        function: { name: "provide_answer" },
+                    },
+                }),
+            });
+            const { refusal, tool_calls, reasoning_content } = message;
+            if (refusal) {
+                console.error(`Attempt ${attempt + 1}: Model send refusal`);
+                attempt++;
+                continue;
+            }
+            if (!tool_calls?.length) {
+                console.error(`Attempt ${attempt + 1}: Model did not use tool, adding user message`);
+                addToolRequestMessage();
+                attempt++;
+                continue;
+            }
+            if (tool_calls && tool_calls.length > 0) {
+                const toolCall = tool_calls[0];
+                if (toolCall.function?.name === "provide_answer") {
+                    // Parse JSON with repair
+                    let parsedArguments;
+                    try {
+                        const json = jsonrepair(toolCall.function.arguments);
+                        parsedArguments = JSON.parse(json);
+                    }
+                    catch (error) {
+                        console.error(`Attempt ${attempt + 1}: Failed to parse tool arguments:`, error);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    const validation = validateToolArguments(parsedArguments, schema);
+                    if (!validation.success) {
+                        console.error(`Attempt ${attempt + 1}: ${validation.error}`);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    set(validation.data, "_thinking", reasoning_content);
+                    set(validation.data, "_context", this.contextService.context);
+                    const result = {
+                        role: "assistant",
+                        content: JSON.stringify(validation.data),
+                    };
+                    // Debug logging
+                    if (CC_ENABLE_DEBUG) {
+                        await fs.appendFile("./debug_hf_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+                    }
+                    return result;
+                }
+            }
+            console.error(`Attempt ${attempt + 1}: Model send refusal`);
+            attempt++;
+        }
+        throw new Error("Model failed to use tool after maximum attempts");
+    }
+}
+
+class OllamaWrapper {
+    constructor(_config) {
+        this._config = _config;
+        this._chatFn = RoundRobin.create(lib.contextService.context.apiKey, (token) => {
+            const ollama = new Ollama({
+                ...this._config,
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            return async (request) => {
+                if (request.stream === true) {
+                    return await ollama.chat(request);
+                }
+                else {
+                    return await ollama.chat(request);
+                }
+            };
+        });
+        if (!lib.contextService.context.apiKey) {
+            throw new Error("OllamaRotate required apiKey[] to process token rotation");
+        }
+    }
+    async chat(request) {
+        return await this._chatFn(request);
+    }
+}
+const getOllamaRotate = singleshot(() => new OllamaWrapper({
+    host: "https://ollama.com",
+}));
+
+const getOllama = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        return getOllamaRotate();
+    }
+    if (!apiKey) {
+        return new Ollama();
+    }
+    return new Ollama({
+        host: "https://ollama.com",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+    });
+});
+
+const MAX_ATTEMPTS$4 = 3;
+class OllamaProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const { agentName, messages: rawMessages, mode, tools, clientId } = params;
+        const ollama = getOllama();
+        this.logger.log("ollamaProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        const messages = [...rawMessages];
+        const response = await ollama.chat({
+            model: this.contextService.context.model,
+            messages: messages.map((message) => ({
+                content: message.content,
+                role: message.role,
+                tool_calls: message.tool_calls?.map((call) => ({
+                    function: call.function,
+                })),
+            })),
+            tools,
+        });
+        const message = response.message;
+        const result = {
+            ...message,
+            tool_calls: response.message.tool_calls?.map((call) => ({
+                function: call.function,
+                type: "function",
+                id: randomString(),
+            })),
+            mode,
+            agentName,
+            role: response.message.role,
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_ollama_provider.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        const { agentName, messages: rawMessages, mode, tools, clientId } = params;
+        const ollama = getOllama();
+        this.logger.log("ollamaProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        const messages = rawMessages.map((message) => ({
+            content: message.content,
+            role: message.role,
+            tool_calls: message.tool_calls?.map((call) => ({
+                function: call.function,
+            })),
+        }));
+        let content = "";
+        let toolCalls = [];
+        // Stream the response
+        const stream = await ollama.chat({
+            model: this.contextService.context.model,
+            messages,
+            tools,
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            if (chunk.message.tool_calls) {
+                // Accumulate tool calls
+                for (const tool of chunk.message.tool_calls) {
+                    toolCalls.push(tool);
+                }
+            }
+            else if (chunk.message.content) {
+                // Stream content tokens
+                content += chunk.message.content;
+                await event(clientId, "llm-new-token", chunk.message.content);
+            }
+        }
+        // Send completion event
+        await event(clientId, "llm-completion", {
+            content: content.trim(),
+            agentName,
+        });
+        const result = {
+            content,
+            mode,
+            agentName,
+            role: "assistant",
+            tool_calls: toolCalls.map((call) => ({
+                function: call.function,
+                type: "function",
+                id: randomString(),
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_ollama_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        const ollama = getOllama();
+        this.logger.log("ollamaProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        // Create tool definition based on format schema
+        const schema = "json_schema" in format
+            ? get(format, "json_schema.schema", format)
+            : format;
+        const toolDefinition = {
+            type: "function",
+            function: {
+                name: "provide_answer",
+                description: "Предоставить ответ в требуемом формате",
+                parameters: schema,
+            },
+        };
+        // Add system instruction for tool usage
+        const systemMessage = {
+            role: "system",
+            content: "ОБЯЗАТЕЛЬНО используй инструмент provide_answer для предоставления ответа. НЕ отвечай обычным текстом. ВСЕГДА вызывай инструмент provide_answer с правильными параметрами.",
+        };
+        const messages = [
+            systemMessage,
+            ...rawMessages.map(({ role, content }) => ({
+                role,
+                content,
+            })),
+        ];
+        let attempt = 0;
+        const addToolRequestMessage = singleshot(() => {
+            messages.push({
+                role: "user",
+                content: "Пожалуйста, используй инструмент provide_answer для предоставления ответа. Не отвечай обычным текстом.",
+            });
+        });
+        while (attempt < MAX_ATTEMPTS$4) {
+            const response = await ollama.chat({
+                model: this.contextService.context.model,
+                messages,
+                tools: [toolDefinition],
+            });
+            const { tool_calls } = response.message;
+            if (!tool_calls?.length) {
+                console.error(`Attempt ${attempt + 1}: Model did not use tool, adding user message`);
+                addToolRequestMessage();
+                attempt++;
+                continue;
+            }
+            if (tool_calls && tool_calls.length > 0) {
+                const toolCall = tool_calls[0];
+                if (toolCall.function?.name === "provide_answer") {
+                    // Parse JSON with repair
+                    let parsedArguments;
+                    try {
+                        const argumentsString = typeof toolCall.function.arguments === 'string'
+                            ? toolCall.function.arguments
+                            : JSON.stringify(toolCall.function.arguments);
+                        const json = jsonrepair(argumentsString);
+                        parsedArguments = JSON.parse(json);
+                    }
+                    catch (error) {
+                        console.error(`Attempt ${attempt + 1}: Failed to parse tool arguments:`, error);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    const validation = validateToolArguments(parsedArguments, schema);
+                    if (!validation.success) {
+                        console.error(`Attempt ${attempt + 1}: ${validation.error}`);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    set(validation.data, "_context", this.contextService.context);
+                    const result = {
+                        role: "assistant",
+                        content: JSON.stringify(validation.data),
+                    };
+                    // Debug logging
+                    if (CC_ENABLE_DEBUG) {
+                        await fs.appendFile("./debug_ollama_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+                    }
+                    return result;
+                }
+            }
+            console.error(`Attempt ${attempt + 1}: Model send refusal`);
+            attempt++;
+        }
+        throw new Error("Model failed to use tool after maximum attempts");
+    }
+}
+
+const getClaude = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        getClaude.clear();
+        throw new Error("Claude provider does not support token rotation");
+    }
+    return new OpenAI({
+        baseURL: "https://api.anthropic.com/v1/",
+        apiKey,
+    });
+});
+
+const MAX_ATTEMPTS$3 = 5;
+class GrokProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const claude = getClaude();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("claudeProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        // Prepare request options
+        const requestOptions = {
+            model: this.contextService.context.model,
+            messages: messages,
+            response_format: {
+                type: "text",
+            },
+        };
+        // Only add tools if they exist and have at least one item
+        if (tools && tools.length > 0) {
+            requestOptions.tools = tools;
+        }
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await claude.chat.completions.create(requestOptions);
+        const result = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_claude_provider.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        const openai = getClaude();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("claudeProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        // Map tools to OpenAI format
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await openai.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools,
+        });
+        // Emit events to mimic streaming behavior
+        if (content) {
+            await event(clientId, "llm-completion", {
+                content: content.trim(),
+                agentName,
+            });
+        }
+        const result = {
+            content: content || "",
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_gpt5_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        const claude = getClaude();
+        this.logger.log("claudeProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        // Create tool definition based on format schema
+        const schema = "json_schema" in format
+            ? get(format, "json_schema.schema", format)
+            : format;
+        const toolDefinition = {
+            type: "function",
+            function: {
+                name: "provide_answer",
+                description: "Предоставить ответ в требуемом формате",
+                parameters: schema,
+            },
+        };
+        // Add system instruction for tool usage
+        const systemMessage = {
+            role: "system",
+            content: "ОБЯЗАТЕЛЬНО используй инструмент provide_answer для предоставления ответа. НЕ отвечай обычным текстом. ВСЕГДА вызывай инструмент provide_answer с правильными параметрами.",
+        };
+        const messages = [
+            systemMessage,
+            ...rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+                role,
+                tool_call_id,
+                content,
+                tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                    ...rest,
+                    function: {
+                        name: f.name,
+                        arguments: JSON.stringify(f.arguments),
+                    },
+                })),
+            })),
+        ];
+        let attempt = 0;
+        const addToolRequestMessage = singleshot(() => {
+            messages.push({
+                role: "user",
+                content: "Пожалуйста, используй инструмент provide_answer для предоставления ответа. Не отвечай обычным текстом.",
+            });
+        });
+        while (attempt < MAX_ATTEMPTS$3) {
+            // Prepare request options
+            const requestOptions = {
+                model: this.contextService.context.model,
+                messages: messages,
+                tools: [toolDefinition],
+                tool_choice: {
+                    type: "function",
+                    function: { name: "provide_answer" },
+                },
+            };
+            const { choices: [{ message }], } = await claude.chat.completions.create(requestOptions);
+            const { refusal, tool_calls } = message;
+            if (refusal) {
+                console.error(`Attempt ${attempt + 1}: Model send refusal`);
+                attempt++;
+                continue;
+            }
+            if (!tool_calls?.length) {
+                console.error(`Attempt ${attempt + 1}: Model did not use tool, adding user message`);
+                addToolRequestMessage();
+                attempt++;
+                continue;
+            }
+            if (tool_calls && tool_calls.length > 0) {
+                const toolCall = tool_calls[0];
+                if (toolCall.function?.name === "provide_answer") {
+                    // Parse JSON with repair
+                    let parsedArguments;
+                    try {
+                        const json = jsonrepair(toolCall.function.arguments);
+                        parsedArguments = JSON.parse(json);
+                    }
+                    catch (error) {
+                        console.error(`Attempt ${attempt + 1}: Failed to parse tool arguments:`, error);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    const validation = validateToolArguments(parsedArguments, schema);
+                    if (!validation.success) {
+                        console.error(`Attempt ${attempt + 1}: ${validation.error}`);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    set(validation.data, "_context", this.contextService.context);
+                    const result = {
+                        role: "assistant",
+                        content: JSON.stringify(validation.data),
+                    };
+                    // Debug logging
+                    if (CC_ENABLE_DEBUG) {
+                        await fs.appendFile("./debug_claude_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+                    }
+                    return result;
+                }
+            }
+            console.error(`Attempt ${attempt + 1}: Model send refusal`);
+            attempt++;
+        }
+        throw new Error("Model failed to use tool after maximum attempts");
+    }
+}
+
+const getOpenAi = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        getOpenAi.clear();
+        throw new Error("OpenAI provider does not support token rotation");
+    }
+    return new OpenAI({
+        apiKey: apiKey,
+    });
+});
+
+class GPT5Provider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const openai = getOpenAi();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("gpt5Provider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await openai.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: tools,
+        });
+        const result = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_gpt5_provider.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        const openai = getOpenAi();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("gpt5Provider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        // Map tools to OpenAI format
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await openai.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools,
+        });
+        // Emit events to mimic streaming behavior
+        if (content) {
+            await event(clientId, "llm-completion", {
+                content: content.trim(),
+                agentName,
+            });
+        }
+        const result = {
+            content: content || "",
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_gpt5_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        const openai = getOpenAi();
+        this.logger.log("gpt5Provider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        // Extract response format
+        const response_format = "json_schema" in format
+            ? format
+            : { type: "json_schema", json_schema: { schema: format } };
+        const completion = await openai.chat.completions.create({
+            messages: messages,
+            model: this.contextService.context.model,
+            response_format: response_format,
+        });
+        const choice = completion.choices[0];
+        if (choice.message.refusal) {
+            throw new Error(choice.message.refusal);
+        }
+        const json = jsonrepair(choice.message.content || "");
+        const result = {
+            role: "assistant",
+            content: json,
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_gpt5_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+}
+
+const getDeepseek = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        getDeepseek.clear();
+        throw new Error("Deepseek provider does not support token rotation");
+    }
+    return new OpenAI({
+        baseURL: "https://api.deepseek.com",
+        apiKey: apiKey,
+    });
+});
+
+const MAX_ATTEMPTS$2 = 3;
+class DeepseekProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const deepseek = getDeepseek();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("deepseekProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await deepseek.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+        });
+        const result = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_deepseek_provider.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        const deepseek = getDeepseek();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("deepseekProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        // Map tools to OpenAI format
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await deepseek.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+        });
+        // Emit events to mimic streaming behavior
+        if (content) {
+            await event(clientId, "llm-completion", {
+                content: content.trim(),
+                agentName,
+            });
+        }
+        const result = {
+            content: content || "",
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_deepseek_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        const deepseek = getDeepseek();
+        this.logger.log("deepseekProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        // Create tool definition based on format schema
+        const schema = "json_schema" in format
+            ? get(format, "json_schema.schema", format)
+            : format;
+        const toolDefinition = {
+            type: "function",
+            function: {
+                name: "provide_answer",
+                description: "Предоставить ответ в требуемом формате",
+                parameters: schema,
+            },
+        };
+        // Add system instruction for tool usage
+        const systemMessage = {
+            role: "system",
+            content: "ОБЯЗАТЕЛЬНО используй инструмент provide_answer для предоставления ответа. НЕ отвечай обычным текстом. ВСЕГДА вызывай инструмент provide_answer с правильными параметрами.",
+        };
+        const messages = [
+            systemMessage,
+            ...rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+                role,
+                tool_call_id,
+                content,
+                tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                    ...rest,
+                    function: {
+                        name: f.name,
+                        arguments: JSON.stringify(f.arguments),
+                    },
+                })),
+            })),
+        ];
+        let attempt = 0;
+        const addToolRequestMessage = singleshot(() => {
+            messages.push({
+                role: "user",
+                content: "Пожалуйста, используй инструмент provide_answer для предоставления ответа. Не отвечай обычным текстом.",
+            });
+        });
+        while (attempt < MAX_ATTEMPTS$2) {
+            // Prepare request options
+            const requestOptions = {
+                model: this.contextService.context.model,
+                messages: messages,
+                tools: [toolDefinition],
+                tool_choice: {
+                    type: "function",
+                    function: { name: "provide_answer" },
+                },
+            };
+            const { choices: [{ message }], } = await deepseek.chat.completions.create(requestOptions);
+            const { refusal, tool_calls } = message;
+            if (refusal) {
+                console.error(`Attempt ${attempt + 1}: Model send refusal`);
+                attempt++;
+                continue;
+            }
+            if (!tool_calls?.length) {
+                console.error(`Attempt ${attempt + 1}: Model did not use tool, adding user message`);
+                addToolRequestMessage();
+                attempt++;
+                continue;
+            }
+            if (tool_calls && tool_calls.length > 0) {
+                const toolCall = tool_calls[0];
+                if (toolCall.function?.name === "provide_answer") {
+                    // Parse JSON with repair
+                    let parsedArguments;
+                    try {
+                        const json = jsonrepair(toolCall.function.arguments);
+                        parsedArguments = JSON.parse(json);
+                    }
+                    catch (error) {
+                        console.error(`Attempt ${attempt + 1}: Failed to parse tool arguments:`, error);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    const validation = validateToolArguments(parsedArguments, schema);
+                    if (!validation.success) {
+                        console.error(`Attempt ${attempt + 1}: ${validation.error}`);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    set(validation.data, "_context", this.contextService.context);
+                    const result = {
+                        role: "assistant",
+                        content: JSON.stringify(validation.data),
+                    };
+                    // Debug logging
+                    if (CC_ENABLE_DEBUG) {
+                        await fs.appendFile("./debug_deepseek_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+                    }
+                    return result;
+                }
+            }
+            console.error(`Attempt ${attempt + 1}: Model send refusal`);
+            attempt++;
+        }
+        throw new Error("Model failed to use tool after maximum attempts");
+    }
+}
+
+const getMistral = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        getMistral.clear();
+        throw new Error("Mistral provider does not support token rotation");
+    }
+    return new OpenAI({
+        baseURL: "https://api.mistral.ai/v1",
+        apiKey: apiKey,
+    });
+});
+
+const MAX_ATTEMPTS$1 = 3;
+class MistralProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const mistral = getMistral();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("mistralProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await mistral.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+        });
+        const result = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_mistral_provider.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        const mistral = getMistral();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("mistralProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        // Map tools to OpenAI format
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        const { choices: [{ message: { content, role, tool_calls }, },], } = await mistral.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+        });
+        // Emit events to mimic streaming behavior
+        if (content) {
+            await event(clientId, "llm-completion", {
+                content: content.trim(),
+                agentName,
+            });
+        }
+        const result = {
+            content: content || "",
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_mistral_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        const mistral = getMistral();
+        this.logger.log("mistralProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        // Create tool definition based on format schema
+        const schema = "json_schema" in format
+            ? get(format, "json_schema.schema", format)
+            : format;
+        const toolDefinition = {
+            type: "function",
+            function: {
+                name: "provide_answer",
+                description: "Предоставить ответ в требуемом формате",
+                parameters: schema,
+            },
+        };
+        // Add system instruction for tool usage
+        const systemMessage = {
+            role: "system",
+            content: "ОБЯЗАТЕЛЬНО используй инструмент provide_answer для предоставления ответа. НЕ отвечай обычным текстом. ВСЕГДА вызывай инструмент provide_answer с правильными параметрами.",
+        };
+        const messages = [
+            systemMessage,
+            ...rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+                role,
+                tool_call_id,
+                content,
+                tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                    ...rest,
+                    function: {
+                        name: f.name,
+                        arguments: JSON.stringify(f.arguments),
+                    },
+                })),
+            })),
+        ];
+        let attempt = 0;
+        const addToolRequestMessage = singleshot(() => {
+            messages.push({
+                role: "user",
+                content: "Пожалуйста, используй инструмент provide_answer для предоставления ответа. Не отвечай обычным текстом.",
+            });
+        });
+        while (attempt < MAX_ATTEMPTS$1) {
+            // Prepare request options
+            const requestOptions = {
+                model: this.contextService.context.model,
+                messages: messages,
+                tools: [toolDefinition],
+                tool_choice: {
+                    type: "function",
+                    function: { name: "provide_answer" },
+                },
+            };
+            const { choices: [{ message }], } = await mistral.chat.completions.create(requestOptions);
+            const { refusal, tool_calls } = message;
+            if (refusal) {
+                console.error(`Attempt ${attempt + 1}: Model send refusal`);
+                attempt++;
+                continue;
+            }
+            if (!tool_calls?.length) {
+                console.error(`Attempt ${attempt + 1}: Model did not use tool, adding user message`);
+                addToolRequestMessage();
+                attempt++;
+                continue;
+            }
+            if (tool_calls && tool_calls.length > 0) {
+                const toolCall = tool_calls[0];
+                if (toolCall.function?.name === "provide_answer") {
+                    // Parse JSON with repair
+                    let parsedArguments;
+                    try {
+                        const json = jsonrepair(toolCall.function.arguments);
+                        parsedArguments = JSON.parse(json);
+                    }
+                    catch (error) {
+                        console.error(`Attempt ${attempt + 1}: Failed to parse tool arguments:`, error);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    const validation = validateToolArguments(parsedArguments, schema);
+                    if (!validation.success) {
+                        console.error(`Attempt ${attempt + 1}: ${validation.error}`);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    set(validation.data, "_context", this.contextService.context);
+                    const result = {
+                        role: "assistant",
+                        content: JSON.stringify(validation.data),
+                    };
+                    // Debug logging
+                    if (CC_ENABLE_DEBUG) {
+                        await fs.appendFile("./debug_mistral_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+                    }
+                    return result;
+                }
+            }
+            console.error(`Attempt ${attempt + 1}: Model send refusal`);
+            attempt++;
+        }
+        throw new Error("Model failed to use tool after maximum attempts");
+    }
+}
+
+const getPerplexity = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        getPerplexity.clear();
+        throw new Error("Perplexity provider does not support token rotation");
+    }
+    return new OpenAI({
+        baseURL: "https://api.perplexity.ai",
+        apiKey: apiKey,
+    });
+});
+
+class PerplexityProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const perplexity = getPerplexity();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("perplexityProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Filter and sort messages like in example.ts
+        const messages = rawMessages
+            .filter(({ role }) => role === "user" || role === "assistant")
+            .map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const systemPrompt = rawMessages
+            .filter(({ role }) => role === "system")
+            .reduce((acm, { content }) => str.newline(acm, content), "");
+        if (systemPrompt) {
+            messages.unshift({
+                role: "system",
+                content: systemPrompt,
+            });
+        }
+        // Merge consecutive assistant messages
+        for (let i = messages.length - 1; i > 0; i--) {
+            if (messages[i].role === "assistant" &&
+                messages[i - 1].role === "assistant") {
+                messages[i - 1].content = str.newline(messages[i - 1].content, messages[i].content);
+                // Merge tool_calls if they exist
+                if (messages[i].tool_calls || messages[i - 1].tool_calls) {
+                    messages[i - 1].tool_calls = [
+                        ...(messages[i - 1].tool_calls || []),
+                        ...(messages[i].tool_calls || []),
+                    ];
+                }
+                messages.splice(i, 1);
+            }
+        }
+        // Merge consecutive user messages
+        for (let i = messages.length - 1; i > 0; i--) {
+            if (messages[i].role === "user" && messages[i - 1].role === "user") {
+                messages[i - 1].content = str.newline(messages[i - 1].content, messages[i].content);
+                messages.splice(i, 1);
+            }
+        }
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                description: f.description ?? "", // Perplexity API requires description
+                parameters: f.parameters,
+            },
+        }));
+        const result = await perplexity.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+            tool_choice: "auto",
+        });
+        const { choices: [{ message: { content, role, tool_calls }, },], } = result;
+        const finalResult = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_perplexity_provider.txt", JSON.stringify({ params, answer: finalResult }, null, 2) + "\n\n");
+        }
+        return finalResult;
+    }
+    async getStreamCompletion(params) {
+        const { clientId, agentName, mode } = params;
+        this.logger.log("perplexityProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        const result = {
+            content: "Выбранная в настройках языковая модель не поддерживает tool_calling",
+            mode,
+            agentName,
+            role: "assistant",
+        };
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        const perplexity = getPerplexity();
+        this.logger.log("perplexityProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        // Filter and sort messages like GPT5Provider
+        const messages = rawMessages
+            .filter(({ role }) => role === "user" || role === "assistant")
+            .map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const systemPrompt = rawMessages
+            .filter(({ role }) => role === "system")
+            .reduce((acm, { content }) => str.newline(acm, content), "");
+        if (systemPrompt) {
+            messages.unshift({
+                role: "system",
+                content: systemPrompt,
+            });
+        }
+        // Merge consecutive assistant messages
+        for (let i = messages.length - 1; i > 0; i--) {
+            if (messages[i].role === "assistant" &&
+                messages[i - 1].role === "assistant") {
+                messages[i - 1].content = str.newline(messages[i - 1].content, messages[i].content);
+                // Merge tool_calls if they exist
+                if (messages[i].tool_calls || messages[i - 1].tool_calls) {
+                    messages[i - 1].tool_calls = [
+                        ...(messages[i - 1].tool_calls || []),
+                        ...(messages[i].tool_calls || []),
+                    ];
+                }
+                messages.splice(i, 1);
+            }
+        }
+        // Merge consecutive user messages
+        for (let i = messages.length - 1; i > 0; i--) {
+            if (messages[i].role === "user" && messages[i - 1].role === "user") {
+                messages[i - 1].content = str.newline(messages[i - 1].content, messages[i].content);
+                messages.splice(i, 1);
+            }
+        }
+        // Extract response format like GPT5Provider
+        const response_format = "json_schema" in format
+            ? format
+            : { type: "json_schema", json_schema: { schema: format } };
+        const completion = await perplexity.chat.completions.create({
+            messages: messages,
+            model: this.contextService.context.model,
+            response_format: response_format,
+        });
+        const choice = completion.choices[0];
+        if (choice.message.refusal) {
+            throw new Error(choice.message.refusal);
+        }
+        const json = jsonrepair(choice.message.content || "");
+        const result = {
+            role: "assistant",
+            content: json,
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_perplexity_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+}
+
+const getCohere = singleshot(() => {
+    const apiKey = lib.contextService.context.apiKey;
+    if (Array.isArray(apiKey)) {
+        getCohere.clear();
+        throw new Error("Cohere provider does not support token rotation");
+    }
+    return new OpenAI({
+        baseURL: "https://api.cohere.ai/compatibility/v1",
+        apiKey: apiKey,
+    });
+});
+
+class CohereProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const cohere = getCohere();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("cohereProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Filter and sort messages - INCLUDE TOOL MESSAGES for Cohere
+        const messages = rawMessages
+            .filter(({ role }) => role === "user" || role === "assistant" || role === "tool")
+            .map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const systemPrompt = rawMessages
+            .filter(({ role }) => role === "system")
+            .reduce((acm, { content }) => str.newline(acm, content), "");
+        if (systemPrompt) {
+            messages.unshift({
+                role: "system",
+                content: systemPrompt,
+            });
+        }
+        // DO NOT merge consecutive assistant messages in Cohere - breaks tool calling flow
+        // Cohere requires strict tool_calls -> tool_responses sequence
+        // Only merge consecutive user messages (safe)
+        for (let i = messages.length - 1; i > 0; i--) {
+            if (messages[i].role === "user" && messages[i - 1].role === "user") {
+                messages[i - 1].content = str.newline(messages[i - 1].content, messages[i].content);
+                messages.splice(i, 1);
+            }
+        }
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                description: f.description ?? "", // Cohere API requires description
+                parameters: f.parameters,
+            },
+        }));
+        const result = await cohere.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+            tool_choice: "auto",
+        });
+        const { choices: [{ message: { content, role, tool_calls }, },], } = result;
+        const finalResult = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_cohere_provider.txt", JSON.stringify({ params, answer: finalResult }, null, 2) + "\n\n");
+        }
+        return finalResult;
+    }
+    async getStreamCompletion(params) {
+        const cohere = getCohere();
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("cohereProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        // Filter and sort messages - INCLUDE TOOL MESSAGES for Cohere
+        const messages = rawMessages
+            .filter(({ role }) => role === "user" || role === "assistant" || role === "tool")
+            .map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const systemPrompt = rawMessages
+            .filter(({ role }) => role === "system")
+            .reduce((acm, { content }) => str.newline(acm, content), "");
+        if (systemPrompt) {
+            messages.unshift({
+                role: "system",
+                content: systemPrompt,
+            });
+        }
+        // DO NOT merge consecutive assistant messages in Cohere - breaks tool calling flow
+        // Cohere requires strict tool_calls -> tool_responses sequence
+        // Merge consecutive user messages
+        for (let i = messages.length - 1; i > 0; i--) {
+            if (messages[i].role === "user" && messages[i - 1].role === "user") {
+                messages[i - 1].content = str.newline(messages[i - 1].content, messages[i].content);
+                messages.splice(i, 1);
+            }
+        }
+        // Map tools to OpenAI format
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                description: f.description ?? "", // Cohere API requires description
+                parameters: f.parameters,
+            },
+        }));
+        const completion = await cohere.chat.completions.create({
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+            tool_choice: "auto",
+        });
+        const { choices: [{ message: { content, role, tool_calls }, },], } = completion;
+        // Emit events to mimic streaming behavior
+        if (content) {
+            await event(clientId, "llm-completion", {
+                content: content.trim(),
+                agentName,
+            });
+        }
+        const result = {
+            content: content || "",
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_cohere_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        const cohere = getCohere();
+        this.logger.log("cohereProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        // Filter and sort messages like GPT5Provider
+        const messages = rawMessages
+            .filter(({ role }) => role === "user" || role === "assistant")
+            .map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const systemPrompt = rawMessages
+            .filter(({ role }) => role === "system")
+            .reduce((acm, { content }) => str.newline(acm, content), "");
+        if (systemPrompt) {
+            messages.unshift({
+                role: "system",
+                content: systemPrompt,
+            });
+        }
+        // DO NOT merge consecutive assistant messages in Cohere - breaks tool calling flow
+        // Cohere requires strict tool_calls -> tool_responses sequence
+        // Merge consecutive user messages
+        for (let i = messages.length - 1; i > 0; i--) {
+            if (messages[i].role === "user" && messages[i - 1].role === "user") {
+                messages[i - 1].content = str.newline(messages[i - 1].content, messages[i].content);
+                messages.splice(i, 1);
+            }
+        }
+        // Extract response format like GPT5Provider
+        const response_format = "json_schema" in format
+            ? format
+            : { type: "json_schema", json_schema: { schema: format } };
+        const completion = await cohere.chat.completions.create({
+            messages: messages,
+            model: this.contextService.context.model,
+            response_format: response_format,
+        });
+        const choice = completion.choices[0];
+        if (choice.message.refusal) {
+            throw new Error(choice.message.refusal);
+        }
+        const json = jsonrepair(choice.message.content || "");
+        const result = {
+            role: "assistant",
+            content: json,
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_cohere_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+}
+
+const MAX_ATTEMPTS = 3;
+const BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
+class AlibabaProvider {
+    constructor(contextService, logger) {
+        this.contextService = contextService;
+        this.logger = logger;
+    }
+    async getCompletion(params) {
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("alibabaProvider getCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Alibaba provider does not support token rotation");
+        }
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        // Prepare request body with enable_thinking parameter
+        const requestBody = {
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+            enable_thinking: false,
+        };
+        // Use fetchApi from functools-kit
+        const responseData = await fetchApi(`${BASE_URL}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${this.contextService.context.apiKey}`,
+            },
+            body: JSON.stringify(requestBody),
+        });
+        const { choices: [{ message: { content, role, tool_calls }, },], } = responseData;
+        const result = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_alibaba_provider.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getStreamCompletion(params) {
+        const { clientId, agentName, messages: rawMessages, mode, tools } = params;
+        this.logger.log("alibabaProvider getStreamCompletion", {
+            agentName,
+            mode,
+            clientId,
+            context: this.contextService.context,
+        });
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Alibaba provider does not support token rotation");
+        }
+        // Map raw messages to OpenAI format
+        const messages = rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+            role,
+            tool_call_id,
+            content,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.stringify(f.arguments),
+                },
+            })),
+        }));
+        const formattedTools = tools?.map(({ type, function: f }) => ({
+            type: type,
+            function: {
+                name: f.name,
+                parameters: f.parameters,
+            },
+        }));
+        // Prepare request body with enable_thinking parameter
+        const requestBody = {
+            model: this.contextService.context.model,
+            messages: messages,
+            tools: formattedTools?.length ? formattedTools : undefined,
+            enable_thinking: false,
+        };
+        // Use fetchApi from functools-kit
+        const responseData = await fetchApi(`${BASE_URL}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${this.contextService.context.apiKey}`,
+            },
+            body: JSON.stringify(requestBody),
+        });
+        const { choices: [{ message: { content, role, tool_calls }, },], } = responseData;
+        // Emit events to mimic streaming behavior
+        if (content) {
+            await event(clientId, "llm-completion", {
+                content: content.trim(),
+                agentName,
+            });
+        }
+        const result = {
+            content: content,
+            mode,
+            agentName,
+            role,
+            tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                ...rest,
+                function: {
+                    name: f.name,
+                    arguments: JSON.parse(f.arguments),
+                },
+            })),
+        };
+        // Debug logging
+        if (CC_ENABLE_DEBUG) {
+            await fs.appendFile("./debug_alibaba_provider_stream.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+        }
+        return result;
+    }
+    async getOutlineCompletion(params) {
+        const { messages: rawMessages, format } = params;
+        this.logger.log("alibabaProvider getOutlineCompletion", {
+            context: this.contextService.context,
+        });
+        if (Array.isArray(this.contextService.context.apiKey)) {
+            throw new Error("Alibaba provider does not support token rotation");
+        }
+        // Create tool definition based on format schema
+        const schema = "json_schema" in format
+            ? get(format, "json_schema.schema", format)
+            : format;
+        const toolDefinition = {
+            type: "function",
+            function: {
+                name: "provide_answer",
+                description: "Предоставить ответ в требуемом формате",
+                parameters: schema,
+            },
+        };
+        // Add system instruction for tool usage
+        const systemMessage = {
+            role: "system",
+            content: "ОБЯЗАТЕЛЬНО используй инструмент provide_answer для предоставления ответа. НЕ отвечай обычным текстом. ВСЕГДА вызывай инструмент provide_answer с правильными параметрами.",
+        };
+        const messages = [
+            systemMessage,
+            ...rawMessages.map(({ role, tool_call_id, tool_calls, content }) => ({
+                role,
+                tool_call_id,
+                content,
+                tool_calls: tool_calls?.map(({ function: f, ...rest }) => ({
+                    ...rest,
+                    function: {
+                        name: f.name,
+                        arguments: JSON.stringify(f.arguments),
+                    },
+                })),
+            })),
+        ];
+        let attempt = 0;
+        const addToolRequestMessage = singleshot(() => {
+            messages.push({
+                role: "user",
+                content: "Пожалуйста, используй инструмент provide_answer для предоставления ответа. Не отвечай обычным текстом.",
+            });
+        });
+        while (attempt < MAX_ATTEMPTS) {
+            // Prepare request body with enable_thinking parameter
+            const requestBody = {
+                model: this.contextService.context.model,
+                messages: messages,
+                tools: [toolDefinition],
+                tool_choice: {
+                    type: "function",
+                    function: { name: "provide_answer" },
+                },
+                enable_thinking: false,
+            };
+            // Use fetchApi from functools-kit
+            const responseData = await fetchApi(`${BASE_URL}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${this.contextService.context.apiKey}`,
+                },
+                body: JSON.stringify(requestBody),
+            });
+            const { choices: [{ message }], } = responseData;
+            const { refusal, tool_calls } = message;
+            if (refusal) {
+                console.error(`Attempt ${attempt + 1}: Model send refusal`);
+                attempt++;
+                continue;
+            }
+            if (!tool_calls?.length) {
+                console.error(`Attempt ${attempt + 1}: Model did not use tool, adding user message`);
+                addToolRequestMessage();
+                attempt++;
+                continue;
+            }
+            if (tool_calls && tool_calls.length > 0) {
+                const toolCall = tool_calls[0];
+                if (toolCall.function?.name === "provide_answer") {
+                    // Parse JSON with repair
+                    let parsedArguments;
+                    try {
+                        const json = jsonrepair(toolCall.function.arguments);
+                        parsedArguments = JSON.parse(json);
+                    }
+                    catch (error) {
+                        console.error(`Attempt ${attempt + 1}: Failed to parse tool arguments:`, error);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    const validation = validateToolArguments(parsedArguments, schema);
+                    if (!validation.success) {
+                        console.error(`Attempt ${attempt + 1}: ${validation.error}`);
+                        addToolRequestMessage();
+                        attempt++;
+                        continue;
+                    }
+                    set(validation.data, "_context", this.contextService.context);
+                    const result = {
+                        role: "assistant",
+                        content: JSON.stringify(validation.data),
+                    };
+                    // Debug logging
+                    if (CC_ENABLE_DEBUG) {
+                        await fs.appendFile("./debug_alibaba_provider_outline.txt", JSON.stringify({ params, answer: result }, null, 2) + "\n\n");
+                    }
+                    return result;
+                }
+            }
+            console.error(`Attempt ${attempt + 1}: Model send refusal`);
+            attempt++;
+        }
+        throw new Error("Model failed to use tool after maximum attempts");
+    }
+}
+
+const commonServices = {
+    loggerService: inject(TYPES.loggerService),
+};
+const baseServices = {
+    contextService: inject(TYPES.contextService),
+};
+const privateServices = {
+    runnerPrivateService: inject(TYPES.runnerPrivateService),
+    outlinePrivateService: inject(TYPES.outlinePrivateService),
+};
+const publicServices = {
+    runnerPublicService: inject(TYPES.runnerPublicService),
+    outlinePublicService: inject(TYPES.outlinePublicService),
+};
+const engine = {
+    ...commonServices,
+    ...baseServices,
+    ...privateServices,
+    ...publicServices,
+};
+init();
+{
+    engine.runnerPrivateService.registerRunner(InferenceName.OllamaInference, OllamaProvider);
+    engine.runnerPrivateService.registerRunner(InferenceName.GrokInference, GrokProvider$1);
+    engine.runnerPrivateService.registerRunner(InferenceName.HfInference, HfProvider);
+    engine.runnerPrivateService.registerRunner(InferenceName.ClaudeInference, GrokProvider);
+    engine.runnerPrivateService.registerRunner(InferenceName.GPT5Inference, GPT5Provider);
+    engine.runnerPrivateService.registerRunner(InferenceName.DeepseekInference, DeepseekProvider);
+    engine.runnerPrivateService.registerRunner(InferenceName.MistralInference, MistralProvider);
+    engine.runnerPrivateService.registerRunner(InferenceName.PerplexityInference, PerplexityProvider);
+    engine.runnerPrivateService.registerRunner(InferenceName.CohereInference, CohereProvider);
+    engine.runnerPrivateService.registerRunner(InferenceName.AlibabaInference, AlibabaProvider);
+}
+Object.assign(globalThis, { engine });
+var lib = engine;
+
+addCompletion({
+    completionName: CompletionName.RunnerOutlineCompletion,
+    getCompletion: async (params) => {
+        return await engine.runnerPrivateService.getOutlineCompletion(params);
+    },
+    json: true,
+});
+
+addCompletion({
+    completionName: CompletionName.RunnerStreamCompletion,
+    getCompletion: async (params) => {
+        return await engine.runnerPrivateService.getStreamCompletion(params);
+    },
+});
+
+addCompletion({
+    completionName: CompletionName.RunnerCompletion,
+    getCompletion: async (params) => {
+        return await engine.runnerPrivateService.getCompletion(params);
+    },
+});
+
+const SignalSchema = z.object({
+    position: z
+        .enum(["long", "short", "wait"])
+        .describe(str.newline("Position direction (ALWAYS required):", "long: market shows consistent bullish signals, uptrend or growth potential", "short: market shows consistent bearish signals, downtrend or decline potential", "wait: conflicting signals between timeframes OR unfavorable trading conditions")),
+    price_open: z
+        .number()
+        .describe(str.newline("Position opening price in USD", "Use the current market price at the time of analysis")),
+    price_stop_loss: z
+        .number()
+        .describe(str.newline("Stop-loss price in USD", "For LONG: price below price_open (protection against decline)", "For SHORT: price above price_open (protection against rise)", "NEVER set SL in 'empty space' without technical justification")),
+    price_take_profit: z
+        .number()
+        .describe(str.newline("Take-profit price in USD", "For LONG: price above price_open (growth target)", "For SHORT: price below price_open (decline target)", "NEVER set TP based on trend without technical justification")),
+    minute_estimated_time: z
+        .number()
+        .describe(str.newline("Estimated time to reach Take Profit in minutes", "Calculated based on HONEST technical analysis, using:", "ATR, ADX, MACD, Momentum, Slope and other metrics")),
+    risk_note: z
+        .string()
+        .describe(str.newline("Description of current market situation risks:", "", "Analyze and specify applicable risks:", "1. Whale manipulations (volume spikes, long shadows, pin bars, candle engulfing, false breakouts)", "2. Order book (order book walls, spoofing, bid/ask imbalance, low liquidity)", "3. P&L history (recurring mistakes on similar patterns)", "4. Time factors (trading session, low liquidity, upcoming events)", "5. Correlations (overall market trend, conflicting trends across timeframes)", "6. Technical risks (indicator divergences, weak volumes, critical levels)", "7. Gaps and anomalies (price gaps, unfilled gaps, movements without volume)", "", "Provide SPECIFIC numbers, percentages and probabilities.")),
+});
+
+addOutline({
+    outlineName: OutlineName.SignalOutline,
+    completion: CompletionName.RunnerOutlineCompletion,
+    format: zodResponseFormat(SignalSchema, "position_open_decision"),
+    getOutlineHistory: async ({ history, param: messages = [] }) => {
+        await history.push(messages);
+    },
+    validations: [
+        {
+            validate: ({ data }) => {
+                if (!data.position) {
+                    throw new Error("The position field is not filled");
+                }
+            },
+            docDescription: "Validates that position direction (long/short/wait) is specified.",
+        },
+        {
+            validate: ({ data }) => {
+                if (!data.risk_note) {
+                    throw new Error("The risk_note field is not filled");
+                }
+            },
+            docDescription: "Validates that risk description is provided.",
+        },
+        {
+            validate: ({ data }) => {
+                if (!data.price_open || data.price_open <= 0) {
+                    throw new Error("The price_open field must contain a positive price");
+                }
+            },
+            docDescription: "Validates that opening price is specified and positive.",
+        },
+        {
+            validate: ({ data }) => {
+                if (data.position !== "wait" &&
+                    (!data.price_stop_loss || data.price_stop_loss <= 0)) {
+                    throw new Error("When position='long' or 'short', the price_stop_loss field is required and must be positive");
+                }
+            },
+            docDescription: "Validates that stop-loss is specified when opening a position.",
+        },
+        {
+            validate: ({ data }) => {
+                if (data.position !== "wait" &&
+                    (!data.price_take_profit || data.price_take_profit <= 0)) {
+                    throw new Error("When position='long' or 'short', the price_take_profit field is required and must be positive");
+                }
+            },
+            docDescription: "Validates that take-profit is specified when opening a position.",
+        },
+        {
+            validate: ({ data }) => {
+                if (data.position === "long") {
+                    if (data.price_stop_loss >= data.price_open) {
+                        throw new Error("For LONG position, price_stop_loss must be below price_open");
+                    }
+                    if (data.price_take_profit <= data.price_open) {
+                        throw new Error("For LONG position, price_take_profit must be above price_open");
+                    }
+                }
+            },
+            docDescription: "Validates price correctness for LONG position.",
+        },
+        {
+            validate: ({ data }) => {
+                if (data.position === "short") {
+                    if (data.price_stop_loss <= data.price_open) {
+                        throw new Error("For SHORT position, price_stop_loss must be above price_open");
+                    }
+                    if (data.price_take_profit >= data.price_open) {
+                        throw new Error("For SHORT position, price_take_profit must be below price_open");
+                    }
+                }
+            },
+            docDescription: "Validates price correctness for SHORT position.",
+        },
+        {
+            validate: ({ data }) => {
+                if (data.position !== "wait" &&
+                    (!data.minute_estimated_time || data.minute_estimated_time <= 0)) {
+                    throw new Error("When position='long' or 'short', the minute_estimated_time field is required and must be positive");
+                }
+            },
+            docDescription: "Validates that estimated time to TP is specified when opening a position.",
+        },
+        {
+            validate: ({ data }) => {
+                if (data.position !== "wait" && data.minute_estimated_time > 360) {
+                    throw new Error("Estimated time to reach TP exceeds 6 hours (360 minutes). Use position='wait' for low volatility conditions");
+                }
+            },
+            docDescription: "Validates that estimated time to reach TP does not exceed 6 hours.",
+        },
+    ],
+});
+
+validate({
+    CompletionName: CompletionName$1,
+    OutlineName: OutlineName$1,
+});
+
+const ollama = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.OllamaInference, model, apiKey);
+};
+const grok = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.GrokInference, model, apiKey);
+};
+const hf = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.HfInference, model, apiKey);
+};
+const claude = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.ClaudeInference, model, apiKey);
+};
+const gpt5 = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.GPT5Inference, model, apiKey);
+};
+const deepseek = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.DeepseekInference, model, apiKey);
+};
+const mistral = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.MistralInference, model, apiKey);
+};
+const perplexity = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.PerplexityInference, model, apiKey);
+};
+const cohere = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.CohereInference, model, apiKey);
+};
+const alibaba = async (messages, model, apiKey) => {
+    return await lib.outlinePublicService.getCompletion(messages, InferenceName$1.AlibabaInference, model, apiKey);
+};
+
+const setLogger = (logger) => {
+    lib.loggerService.setLogger(logger);
+};
+
+export { alibaba, claude, cohere, deepseek, gpt5, grok, hf, engine as lib, mistral, ollama, perplexity, setLogger };