@orion-agents/orion-code 0.1.0

package/dist/services/llm.js

@@ -0,0 +1,740 @@
+"use strict";
+/**
+ * orion code - LLM 服务层
+ *
+ * 封装 OpenAI 兼容 API，支持流式和非流式调用。
+ * 兼容 OpenAI、Claude (via proxy)、本地 Ollama 等。
+ * 支持工具调用（function calling）和 agentic 循环。
+ * 支持重试机制和 fallback model。
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMService = exports.FallbackTriggeredError = exports.LLMProviderError = void 0;
+const openai_1 = __importDefault(require("openai"));
+const crypto_1 = require("crypto");
+const provider_diagnostics_1 = require("./provider-diagnostics");
+var provider_diagnostics_2 = require("./provider-diagnostics");
+Object.defineProperty(exports, "LLMProviderError", { enumerable: true, get: function () { return provider_diagnostics_2.LLMProviderError; } });
+/** Fallback 触发错误 */
+class FallbackTriggeredError extends Error {
+    constructor(originalModel, fallbackModel) {
+        super(`Fallback triggered: ${originalModel} -> ${fallbackModel}`);
+        this.originalModel = originalModel;
+        this.fallbackModel = fallbackModel;
+        this.name = 'FallbackTriggeredError';
+    }
+}
+exports.FallbackTriggeredError = FallbackTriggeredError;
+// ============================================================================
+// 重试机制
+// ============================================================================
+/** 默认重试配置 */
+const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 500,
+    maxDelayMs: 10000,
+};
+/** 529 错误最大重试次数（触发 fallback） */
+const MAX_529_RETRIES = 3;
+/** 判断错误是否可重试 */
+function isRetryableError(error) {
+    return (0, provider_diagnostics_1.diagnoseProviderError)(error).retryable;
+}
+function isRateLimitError(error) {
+    return (0, provider_diagnostics_1.diagnoseProviderError)(error).type === 'rate_limit';
+}
+function createAbortError() {
+    const error = new Error('Operation cancelled');
+    error.name = 'AbortError';
+    return error;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError();
+    }
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+/** 从错误中提取 retry-after 时间 */
+function getRetryAfterMs(error) {
+    if (error instanceof openai_1.default.APIError && error.headers) {
+        const headers = error.headers;
+        let retryAfter = null;
+        // headers may be Headers object or plain object
+        if (headers && typeof headers === 'object') {
+            if ('get' in headers && typeof headers.get === 'function') {
+                retryAfter = headers.get('retry-after');
+            }
+            else if ('retry-after' in headers) {
+                retryAfter = headers['retry-after'];
+            }
+        }
+        if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds))
+                return seconds * 1000;
+        }
+    }
+    return null;
+}
+/** 指数退避计算 */
+function exponentialBackoff(attempt, baseDelayMs, maxDelayMs) {
+    const delay = baseDelayMs * Math.pow(2, attempt - 1);
+    return maxDelayMs ? Math.min(delay, maxDelayMs) : delay;
+}
+/** Sleep 函数 */
+function sleep(ms, abortSignal) {
+    if (!abortSignal) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    return new Promise((resolve, reject) => {
+        if (abortSignal.aborted) {
+            reject(createAbortError());
+            return;
+        }
+        const timeout = setTimeout(() => {
+            abortSignal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(createAbortError());
+        };
+        abortSignal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/** 带重试的操作 */
+async function withRetry(operation, config) {
+    let lastError;
+    for (let attempt = 1; attempt <= config.maxRetries + 1; attempt++) {
+        try {
+            throwIfAborted(config.abortSignal);
+            return await operation();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (!isRetryableError(error)) {
+                throw lastError;
+            }
+            if (attempt > config.maxRetries) {
+                throw lastError;
+            }
+            let delayMs = exponentialBackoff(attempt, config.baseDelayMs, config.maxDelayMs);
+            const retryAfter = getRetryAfterMs(error);
+            if (retryAfter !== null) {
+                delayMs = retryAfter;
+            }
+            else if (isRateLimitError(error)) {
+                delayMs = Math.max(delayMs, Math.min(2000, config.baseDelayMs * 4));
+            }
+            config.onRetry?.(attempt, lastError, delayMs);
+            await sleep(delayMs, config.abortSignal);
+        }
+    }
+    throw lastError ?? new Error('Unknown error');
+}
+// ============================================================================
+// LLMService
+// ============================================================================
+// ============================================================================
+// Agent 内部参数默认值（用户无需配置）
+// ============================================================================
+const DEFAULT_MAX_TOKENS = 8192; // 代码场景需要足够长的输出
+const DEFAULT_TEMPERATURE = 0.1; // 代码场景需要确定性输出
+const DEFAULT_MAX_RETRIES = DEFAULT_RETRY_CONFIG.maxRetries;
+const DEFAULT_RETRY_DELAY = DEFAULT_RETRY_CONFIG.baseDelayMs;
+function toNonNegativeFiniteNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+        return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed) && parsed >= 0)
+            return parsed;
+    }
+    return undefined;
+}
+/** Extract non-standard billing fields used by OpenAI-compatible providers. */
+function extractProviderCost(usage, response) {
+    return [
+        usage?.cost,
+        usage?.total_cost,
+        usage?.cost_usd,
+        response?.cost,
+        response?.total_cost,
+        response?.cost_usd,
+    ]
+        .map(toNonNegativeFiniteNumber)
+        .find(value => value !== undefined);
+}
+function extractLLMUsage(usage, response, requestId) {
+    const cachedPromptTokens = toNonNegativeFiniteNumber(usage?.prompt_tokens_details?.cached_tokens
+        ?? usage?.input_tokens_details?.cached_tokens);
+    return {
+        promptTokens: toNonNegativeFiniteNumber(usage?.prompt_tokens ?? usage?.input_tokens) ?? 0,
+        completionTokens: toNonNegativeFiniteNumber(usage?.completion_tokens ?? usage?.output_tokens) ?? 0,
+        ...(cachedPromptTokens !== undefined ? { cachedPromptTokens } : {}),
+        ...(extractProviderCost(usage, response) !== undefined
+            ? { costUsd: extractProviderCost(usage, response) }
+            : {}),
+        requestId: requestId || (0, crypto_1.randomUUID)(),
+    };
+}
+class LLMService {
+    constructor(config) {
+        this.consecutive529Errors = 0;
+        this.usingFallback = false;
+        this.usageObservers = new Set();
+        // v0.2.25: disable SDK built-in retry (maxRetries=0). Orion Code owns retry policy.
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl,
+            timeout: config.timeout ?? 60000,
+            maxRetries: 0,
+            dangerouslyAllowBrowser: true,
+        });
+        // Agent 内部控制参数，不由用户配置
+        this.config = {
+            model: config.model,
+            fallbackModel: config.fallbackModel ?? '',
+            maxTokens: DEFAULT_MAX_TOKENS,
+            temperature: DEFAULT_TEMPERATURE,
+            timeout: config.timeout ?? 60000,
+            maxRetries: DEFAULT_MAX_RETRIES,
+            retryBaseDelay: DEFAULT_RETRY_DELAY,
+        };
+        this.lastRequestDiagnostics = this.createRequestDiagnostics();
+    }
+    /** 是否正在使用 fallback model */
+    isUsingFallback() {
+        return this.usingFallback;
+    }
+    getLastRequestDiagnostics() {
+        return {
+            ...this.lastRequestDiagnostics,
+            retryErrorTypes: [...this.lastRequestDiagnostics.retryErrorTypes],
+        };
+    }
+    /** Observe every successful provider call, including compact summaries. */
+    subscribeUsage(observer) {
+        this.usageObservers.add(observer);
+        return () => this.usageObservers.delete(observer);
+    }
+    /** 触发 fallback */
+    triggerFallback() {
+        if (this.config.fallbackModel && !this.usingFallback) {
+            this.usingFallback = true;
+            this.config.model = this.config.fallbackModel;
+            this.consecutive529Errors = 0;
+        }
+    }
+    /** 重置为原始 model */
+    resetToPrimary() {
+        this.usingFallback = false;
+        this.consecutive529Errors = 0;
+    }
+    /**
+     * 非流式对话
+     */
+    async chat(messages, tools) {
+        const params = {
+            model: this.config.model,
+            messages: this.toOpenAIMessages(messages),
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+        };
+        if (tools && tools.length > 0) {
+            params.tools = tools;
+        }
+        // v0.2.25: Use resilience coordinator when available.
+        let response;
+        try {
+            if (this.resilience) {
+                const result = await this.resilience.execute({ logicalRequestId: `chat-${Date.now()}`, operation: 'root_chat', providerKey: 'default', requestedModel: this.config.model }, async () => ({ response: await this.client.chat.completions.create(params) }));
+                response = result.result;
+            }
+            else {
+                response = await this.client.chat.completions.create(params);
+            }
+        }
+        catch (error) {
+            // v0.2.25: ProviderRetryExhaustedError is a recoverable turn failure.
+            if (error instanceof Error && error.name === 'ProviderRetryExhaustedError')
+                throw error;
+            if (isAbortError(error))
+                throw error;
+            throw (0, provider_diagnostics_1.toLLMProviderError)(error);
+        }
+        const message = response.choices?.[0]?.message;
+        const content = message?.content ?? '';
+        const toolCalls = message?.tool_calls?.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: {
+                name: tc.function.name,
+                arguments: tc.function.arguments,
+            },
+        }));
+        const usage = response.usage
+            ? extractLLMUsage(response.usage, response, response.id)
+            : undefined;
+        if (usage)
+            this.publishUsage(usage, response.model ?? this.config.model, 'chat');
+        return {
+            content,
+            usage,
+            model: response.model,
+            toolCalls,
+        };
+    }
+    /**
+     * 流式对话（带重试）
+     */
+    async chatStream(messages, callbacks, tools, options) {
+        const onChunk = typeof callbacks === 'function' ? callbacks : callbacks?.onChunk;
+        const onThinking = typeof callbacks === 'object' ? callbacks?.onThinking : undefined;
+        const requestDiagnostics = this.createRequestDiagnostics();
+        this.lastRequestDiagnostics = requestDiagnostics;
+        const retryConfig = {
+            maxRetries: this.config.maxRetries,
+            baseDelayMs: this.config.retryBaseDelay,
+            maxDelayMs: 10000,
+            abortSignal: options?.abortSignal,
+            onRetry: (_attempt, error, delayMs) => {
+                const diagnostic = (0, provider_diagnostics_1.diagnoseProviderError)(error);
+                requestDiagnostics.retryCount++;
+                requestDiagnostics.retryDelayMs += delayMs;
+                requestDiagnostics.retryErrorTypes.push(diagnostic.type);
+                requestDiagnostics.lastRetryErrorType = diagnostic.type;
+                requestDiagnostics.lastRetryStatus = diagnostic.status;
+                // Provider overload/busy errors can often recover by retrying or using fallback.
+                if (diagnostic.status === 529 || diagnostic.type === 'provider_busy' || diagnostic.type === 'rate_limit') {
+                    this.consecutive529Errors++;
+                    if (this.consecutive529Errors >= MAX_529_RETRIES && this.config.fallbackModel && !this.usingFallback) {
+                        const originalModel = this.config.model;
+                        this.triggerFallback();
+                        if (this.config.model !== originalModel) {
+                            requestDiagnostics.fallbackTriggered = true;
+                            requestDiagnostics.fallbackFromModel = originalModel;
+                            requestDiagnostics.fallbackToModel = this.config.model;
+                        }
+                    }
+                }
+                requestDiagnostics.finalModel = this.config.model;
+                requestDiagnostics.usingFallback = this.usingFallback;
+            },
+        };
+        try {
+            // v0.2.26: Use resilience coordinator when available for streaming too.
+            if (this.resilience) {
+                const streamResult = await this.resilience.execute({
+                    logicalRequestId: `stream-${Date.now()}`,
+                    operation: 'root_chat_stream',
+                    providerKey: 'default',
+                    requestedModel: this.config.model,
+                    abortSignal: options?.abortSignal,
+                }, async (_attempt, signal) => {
+                    throwIfAborted(signal);
+                    const params = {
+                        model: this.config.model,
+                        messages: this.toOpenAIMessages(messages),
+                        max_tokens: this.config.maxTokens,
+                        temperature: this.config.temperature,
+                        stream: true,
+                        stream_options: { include_usage: true },
+                    };
+                    if (tools && tools.length > 0) {
+                        params.tools = tools;
+                    }
+                    onThinking?.();
+                    const requestOptions = signal ? { signal } : undefined;
+                    const stream = await this.client.chat.completions.create(params, requestOptions);
+                    let content = '';
+                    let usedModel = this.config.model;
+                    let usage;
+                    let providerRequestId;
+                    const toolCallsMap = new Map();
+                    for await (const chunk of stream) {
+                        throwIfAborted(signal);
+                        // Debug: log raw chunk when tool_calls present
+                        if (process.env.ORION_CODE_DEBUG_TOOLS === 'true') {
+                            const delta = chunk.choices?.[0]?.delta;
+                            if (delta?.tool_calls || chunk.choices?.[0]?.message?.tool_calls) {
+                                console.log('[DEBUG] Raw chunk:', JSON.stringify(chunk, null, 2));
+                            }
+                        }
+                        const delta = chunk.choices?.[0]?.delta;
+                        const text = delta?.content ?? '';
+                        if (text) {
+                            content += text;
+                            onChunk?.(text);
+                        }
+                        for (const tc of delta?.tool_calls ?? []) {
+                            const idx = tc.index ?? 0;
+                            const existing = toolCallsMap.get(idx);
+                            if (!existing) {
+                                toolCallsMap.set(idx, {
+                                    id: tc.id ?? `call_${idx}`,
+                                    type: 'function',
+                                    function: { name: tc.function?.name ?? '', arguments: tc.function?.arguments ?? '' },
+                                });
+                            }
+                            else {
+                                if (tc.id)
+                                    existing.id = tc.id;
+                                if (tc.function?.name)
+                                    existing.function.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    existing.function.arguments += tc.function.arguments;
+                            }
+                        }
+                        const msg = chunk.choices?.[0]?.message;
+                        if (msg?.tool_calls && !delta?.tool_calls) {
+                            for (const msgTc of msg.tool_calls) {
+                                const existing = toolCallsMap.get(msgTc.index ?? 0);
+                                if (!existing && msgTc.id) {
+                                    toolCallsMap.set(msgTc.index ?? 0, {
+                                        id: msgTc.id,
+                                        type: 'function',
+                                        function: { name: msgTc.function?.name ?? '', arguments: msgTc.function?.arguments ?? '' },
+                                    });
+                                }
+                                else if (existing && msgTc.function?.arguments) {
+                                    existing.function.arguments += msgTc.function.arguments;
+                                }
+                            }
+                        }
+                        if (chunk.usage) {
+                            usage = extractLLMUsage(chunk.usage, chunk, chunk.id ?? providerRequestId);
+                        }
+                        if (chunk.id)
+                            providerRequestId = chunk.id;
+                        if (chunk.model) {
+                            usedModel = chunk.model;
+                        }
+                    }
+                    const toolCalls = Array.from(toolCallsMap.entries())
+                        .sort(([a], [b]) => Number(a) - Number(b))
+                        .map(([, value]) => value);
+                    for (const tc of toolCalls) {
+                        if (!tc.function.arguments || tc.function.arguments.trim() === '') {
+                            tc.function.arguments = '{}';
+                        }
+                        else {
+                            try {
+                                const parsed = JSON.parse(tc.function.arguments);
+                                tc.function.arguments = JSON.stringify(parsed);
+                            }
+                            catch {
+                                tc.function.arguments = '{}';
+                            }
+                        }
+                    }
+                    if (usage)
+                        this.publishUsage(usage, usedModel, 'chat_stream');
+                    return {
+                        response: {
+                            content,
+                            model: usedModel,
+                            usage,
+                            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                        },
+                        usage: usage ? {
+                            promptTokens: usage.promptTokens,
+                            completionTokens: usage.completionTokens,
+                            totalTokens: usage.promptTokens + usage.completionTokens,
+                        } : undefined,
+                        providerRequestId,
+                    };
+                });
+                // Unpack resilience result
+                const response = streamResult.result;
+                this.consecutive529Errors = 0;
+                requestDiagnostics.finalModel = response.model;
+                requestDiagnostics.usingFallback = this.usingFallback;
+                this.lastRequestDiagnostics = {
+                    ...requestDiagnostics,
+                    retryErrorTypes: [...requestDiagnostics.retryErrorTypes],
+                };
+                return response;
+            }
+            // Legacy path: without resilience coordinator
+            else {
+                const response = await withRetry(async () => {
+                    throwIfAborted(options?.abortSignal);
+                    const params = {
+                        model: this.config.model,
+                        messages: this.toOpenAIMessages(messages),
+                        max_tokens: this.config.maxTokens,
+                        temperature: this.config.temperature,
+                        stream: true,
+                        stream_options: { include_usage: true },
+                    };
+                    if (tools && tools.length > 0) {
+                        params.tools = tools;
+                    }
+                    onThinking?.();
+                    const requestOptions = options?.abortSignal ? { signal: options.abortSignal } : undefined;
+                    const stream = await this.client.chat.completions.create(params, requestOptions);
+                    let content = '';
+                    let usedModel = this.config.model;
+                    let usage;
+                    let providerRequestId;
+                    const toolCallsMap = new Map();
+                    for await (const chunk of stream) {
+                        throwIfAborted(options?.abortSignal);
+                        // Debug: log raw chunk when tool_calls present (for diagnosing API compatibility)
+                        if (process.env.ORION_CODE_DEBUG_TOOLS === 'true') {
+                            const delta = chunk.choices?.[0]?.delta;
+                            if (delta?.tool_calls || chunk.choices?.[0]?.message?.tool_calls) {
+                                console.log('[DEBUG] Raw chunk:', JSON.stringify(chunk, null, 2));
+                            }
+                        }
+                        const delta = chunk.choices?.[0]?.delta;
+                        const text = delta?.content ?? '';
+                        if (text) {
+                            content += text;
+                            onChunk?.(text);
+                        }
+                        // Handle tool_calls from delta (OpenAI standard streaming format).
+                        // A single stream chunk may contain multiple tool call deltas.
+                        for (const tc of delta?.tool_calls ?? []) {
+                            const idx = tc.index ?? 0;
+                            const existing = toolCallsMap.get(idx);
+                            if (!existing) {
+                                toolCallsMap.set(idx, {
+                                    id: tc.id ?? `call_${idx}`,
+                                    type: 'function',
+                                    function: { name: tc.function?.name ?? '', arguments: tc.function?.arguments ?? '' },
+                                });
+                            }
+                            else {
+                                if (tc.id)
+                                    existing.id = tc.id;
+                                if (tc.function?.name)
+                                    existing.function.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    existing.function.arguments += tc.function.arguments;
+                            }
+                        }
+                        // Handle tool_calls from message (some APIs like DashScope may use this format)
+                        const msg = chunk.choices?.[0]?.message;
+                        if (msg?.tool_calls && !delta?.tool_calls) {
+                            for (const msgTc of msg.tool_calls) {
+                                const existing = toolCallsMap.get(msgTc.index ?? 0);
+                                if (!existing && msgTc.id) {
+                                    toolCallsMap.set(msgTc.index ?? 0, {
+                                        id: msgTc.id,
+                                        type: 'function',
+                                        function: { name: msgTc.function?.name ?? '', arguments: msgTc.function?.arguments ?? '' },
+                                    });
+                                }
+                                else if (existing && msgTc.function?.arguments) {
+                                    existing.function.arguments += msgTc.function.arguments;
+                                }
+                            }
+                        }
+                        if (chunk.usage) {
+                            usage = extractLLMUsage(chunk.usage, chunk, chunk.id ?? providerRequestId);
+                        }
+                        if (chunk.id)
+                            providerRequestId = chunk.id;
+                        if (chunk.model) {
+                            usedModel = chunk.model;
+                        }
+                    }
+                    const toolCalls = Array.from(toolCallsMap.entries())
+                        .sort(([a], [b]) => Number(a) - Number(b))
+                        .map(([, value]) => value);
+                    for (const tc of toolCalls) {
+                        if (!tc.function.arguments || tc.function.arguments.trim() === '') {
+                            tc.function.arguments = '{}';
+                        }
+                        else {
+                            try {
+                                const parsed = JSON.parse(tc.function.arguments);
+                                tc.function.arguments = JSON.stringify(parsed);
+                            }
+                            catch {
+                                tc.function.arguments = '{}';
+                            }
+                        }
+                    }
+                    if (usage)
+                        this.publishUsage(usage, usedModel, 'chat_stream');
+                    this.consecutive529Errors = 0;
+                    requestDiagnostics.finalModel = usedModel;
+                    requestDiagnostics.usingFallback = this.usingFallback;
+                    this.lastRequestDiagnostics = {
+                        ...requestDiagnostics,
+                        retryErrorTypes: [...requestDiagnostics.retryErrorTypes],
+                    };
+                    return {
+                        content,
+                        model: usedModel,
+                        usage,
+                        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                    };
+                }, retryConfig);
+                requestDiagnostics.finalModel = response.model;
+                requestDiagnostics.usingFallback = this.usingFallback;
+                this.lastRequestDiagnostics = {
+                    ...requestDiagnostics,
+                    retryErrorTypes: [...requestDiagnostics.retryErrorTypes],
+                };
+                return response;
+            } // end legacy else branch
+        }
+        catch (error) {
+            requestDiagnostics.finalModel = this.config.model;
+            requestDiagnostics.usingFallback = this.usingFallback;
+            this.lastRequestDiagnostics = {
+                ...requestDiagnostics,
+                retryErrorTypes: [...requestDiagnostics.retryErrorTypes],
+            };
+            if (isAbortError(error))
+                throw error;
+            throw (0, provider_diagnostics_1.toLLMProviderError)(error);
+        }
+    }
+    publishUsage(usage, model, operation) {
+        for (const observer of this.usageObservers) {
+            try {
+                observer({ usage, model, operation });
+            }
+            catch {
+                // Telemetry/accounting observers must not fail the model request.
+            }
+        }
+    }
+    /**
+     * 带工具调用的 agentic 循环
+     */
+    async chatWithTools(messages, tools, toolExecutor, callbacks, maxIterations = 10) {
+        let iteration = 0;
+        while (iteration < maxIterations) {
+            iteration++;
+            const response = await this.chatStream(messages, {
+                onChunk: callbacks?.onChunk,
+                onThinking: iteration === 1 ? callbacks?.onThinking : undefined,
+            }, tools);
+            const assistantMsg = {
+                role: 'assistant',
+                content: response.content,
+            };
+            if (response.toolCalls) {
+                assistantMsg.tool_calls = response.toolCalls;
+            }
+            messages.push(assistantMsg);
+            if (response.toolCalls && response.toolCalls.length > 0) {
+                for (const tc of response.toolCalls) {
+                    let args;
+                    try {
+                        args = JSON.parse(tc.function.arguments);
+                    }
+                    catch {
+                        // Malformed JSON arguments from LLM — use empty object as fallback.
+                        args = {};
+                    }
+                    const result = await toolExecutor(tc.function.name, args);
+                    messages.push({
+                        role: 'tool',
+                        content: result,
+                        tool_call_id: tc.id,
+                    });
+                }
+                continue;
+            }
+            return response;
+        }
+        return {
+            content: '达到了最大执行步数限制，未能完成。请简化任务。',
+            model: this.config.model,
+        };
+    }
+    /**
+     * 切换模型
+     */
+    setModel(model) {
+        this.config.model = model;
+    }
+    /**
+     * 获取当前模型
+     */
+    getModel() {
+        return this.config.model;
+    }
+    /** Maximum completion tokens requested from the provider for each call. */
+    getMaxTokens() {
+        return this.config.maxTokens;
+    }
+    /**
+     * 获取当前配置摘要
+     */
+    getConfigSummary() {
+        return {
+            model: this.config.model,
+            fallback: this.config.fallbackModel || '(none)',
+            maxTokens: String(this.config.maxTokens),
+            temperature: String(this.config.temperature),
+            timeout: String(this.config.timeout),
+            maxRetries: String(this.config.maxRetries),
+        };
+    }
+    // ---- Internal ----
+    createRequestDiagnostics() {
+        return {
+            retryCount: 0,
+            retryDelayMs: 0,
+            retryErrorTypes: [],
+            fallbackTriggered: false,
+            finalModel: this.config.model,
+            usingFallback: this.usingFallback,
+        };
+    }
+    /** 转换为 OpenAI SDK 消息格式 */
+    toOpenAIMessages(messages) {
+        return messages.map(msg => {
+            if (msg.role === 'tool') {
+                return {
+                    role: 'tool',
+                    content: msg.content,
+                    tool_call_id: msg.tool_call_id ?? '',
+                };
+            }
+            if (msg.tool_calls && msg.tool_calls.length > 0) {
+                return {
+                    role: 'assistant',
+                    content: msg.content,
+                    tool_calls: msg.tool_calls.map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.function.name,
+                            arguments: tc.function.arguments,
+                        },
+                    })),
+                };
+            }
+            // Apply cache control for providers that support it (Anthropic via OpenAI-compatible API).
+            // Converts content to content array format with cache_control block appended.
+            if (msg.cacheControl?.type === 'ephemeral' && msg.content) {
+                return {
+                    role: msg.role,
+                    content: [
+                        { type: 'text', text: msg.content },
+                        { type: 'text', text: '', cache_control: { type: 'ephemeral' } },
+                    ],
+                };
+            }
+            return {
+                role: msg.role,
+                content: msg.content,
+            };
+        });
+    }
+}
+exports.LLMService = LLMService;
+//# sourceMappingURL=llm.js.map