@orion-agents/orion-code 0.1.4 → 0.1.5

package/dist/services/llm.js

@@ -12,11 +12,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMService = exports.ProviderRequestPreflightError = exports.FallbackTriggeredError = exports.LLMProviderError = void 0;
+exports.normalizeFinishReason = normalizeFinishReason;
 const openai_1 = __importDefault(require("openai"));
 const crypto_1 = require("crypto");
 const provider_diagnostics_1 = require("./provider-diagnostics");
 const provider_resilience_1 = require("./provider-resilience");
+const tool_call_groups_1 = require("./compact/tool-call-groups");
 const token_estimate_1 = require("../utils/token-estimate");
+const effort_1 = require("./effort");
 var provider_diagnostics_2 = require("./provider-diagnostics");
 Object.defineProperty(exports, "LLMProviderError", { enumerable: true, get: function () { return provider_diagnostics_2.LLMProviderError; } });
 /** Fallback 触发错误 */
@@ -29,6 +32,29 @@ class FallbackTriggeredError extends Error {
     }
 }
 exports.FallbackTriggeredError = FallbackTriggeredError;
+function normalizeFinishReason(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const reason = value.trim().toLowerCase();
+    if (!reason)
+        return undefined;
+    if (['stop', 'end', 'end_turn', 'completed', 'complete', 'success'].includes(reason)) {
+        return 'stop';
+    }
+    if (['length', 'max_tokens', 'max_output_tokens', 'token_limit'].includes(reason)) {
+        return 'length';
+    }
+    if (['tool_calls', 'tool_call', 'tool_use', 'function_call'].includes(reason)) {
+        return 'tool_calls';
+    }
+    if (['content_filter', 'content_filtered', 'safety', 'blocked'].includes(reason)) {
+        return 'content_filter';
+    }
+    return 'unknown';
+}
+function rawFinishReason(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
 class ProviderRequestPreflightError extends Error {
     constructor(message) {
         super(message);
@@ -55,6 +81,8 @@ function providerErrorTypeForFailureKind(kind) {
         case 'provider_overloaded':
         case 'server_error':
             return 'provider_busy';
+        case 'unsupported_effort':
+            return 'unsupported_effort';
         default:
             return 'unknown_provider_error';
     }
@@ -67,6 +95,7 @@ const DEFAULT_RETRY_CONFIG = {
     maxRetries: 3,
     baseDelayMs: 500,
     maxDelayMs: 10000,
+    maxRetryAfterMs: 60000,
 };
 /** 529 错误最大重试次数（触发 fallback） */
 const MAX_529_RETRIES = 3;
@@ -90,28 +119,6 @@ function throwIfAborted(signal) {
 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);
@@ -155,9 +162,9 @@ async function withRetry(operation, config) {
                 throw lastError;
             }
             let delayMs = exponentialBackoff(attempt, config.baseDelayMs, config.maxDelayMs);
-            const retryAfter = getRetryAfterMs(error);
-            if (retryAfter !== null) {
-                delayMs = retryAfter;
+            const retryAfter = (0, provider_resilience_1.extractRetryAfterMs)(error);
+            if (retryAfter !== undefined) {
+                delayMs = Math.min(retryAfter, config.maxRetryAfterMs ?? 60000);
             }
             else if (isRateLimitError(error)) {
                 delayMs = Math.max(delayMs, Math.min(2000, config.baseDelayMs * 4));
@@ -216,10 +223,13 @@ function extractProviderCost(usage, response) {
 function extractLLMUsage(usage, response, requestId) {
     const cachedPromptTokens = toNonNegativeFiniteNumber(readField(readField(usage, 'prompt_tokens_details'), 'cached_tokens') ??
         readField(readField(usage, 'input_tokens_details'), 'cached_tokens'));
+    const reasoningTokens = toNonNegativeFiniteNumber(readField(readField(usage, 'completion_tokens_details'), 'reasoning_tokens') ??
+        readField(readField(usage, 'output_tokens_details'), 'reasoning_tokens'));
     return {
         promptTokens: toNonNegativeFiniteNumber(readField(usage, 'prompt_tokens') ?? readField(usage, 'input_tokens')) ?? 0,
         completionTokens: toNonNegativeFiniteNumber(readField(usage, 'completion_tokens') ?? readField(usage, 'output_tokens')) ?? 0,
         ...(cachedPromptTokens !== undefined ? { cachedPromptTokens } : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
         ...(extractProviderCost(usage, response) !== undefined
             ? { costUsd: extractProviderCost(usage, response) }
             : {}),
@@ -249,6 +259,14 @@ class LLMService {
             maxRetries: DEFAULT_MAX_RETRIES,
             retryBaseDelay: DEFAULT_RETRY_DELAY,
         };
+        this.effortContext = {
+            preference: config.effortPreference ?? 'auto',
+            protocol: config.providerProtocol ?? 'openai-completions',
+            ...(config.reasoningCapability ? { capability: config.reasoningCapability } : {}),
+            ...(config.fallbackReasoningCapability
+                ? { fallbackCapability: config.fallbackReasoningCapability }
+                : {}),
+        };
         this.lastRequestDiagnostics = this.createRequestDiagnostics();
     }
     /** 是否正在使用 fallback model */
@@ -275,13 +293,13 @@ class LLMService {
                 this.providerRequestPreflight = previous;
         };
     }
-    async assertProviderRequestAllowed(operation, attempt, messages) {
+    async assertProviderRequestAllowed(operation, attempt, messages, model = this.config.model) {
         if (!this.providerRequestPreflight)
             return;
         const decision = await this.providerRequestPreflight({
             operation,
             attempt,
-            model: this.config.model,
+            model,
             estimatedPromptTokens: (0, token_estimate_1.estimateMessagesTokens)(messages),
         });
         if (!decision.available) {
@@ -301,59 +319,13 @@ class LLMService {
         this.usingFallback = false;
         this.consecutive529Errors = 0;
     }
-    /**
-     * Switch to the configured fallback model before a retry, and record it.
-     *
-     * The resilience coordinator only retries errors it has already classified as
-     * retryable -- rate limiting, provider overload, transient transport faults --
-     * which is exactly the situation a fallback model exists for. So the first
-     * retry is the right moment to switch.
-     *
-     * The previous gate (`consecutive529Errors >= MAX_529_RETRIES`, i.e. 3) was
-     * unreachable in practice: that threshold is at least the coordinator's whole
-     * attempt budget, so the request was exhausted before the gate could open. It
-     * also only ever ran from the legacy `retryConfig.onRetry` path, which is
-     * skipped entirely whenever the coordinator is active.
-     *
-     * @returns true when the active model changed.
-     */
-    applyFallbackForRetry(diagnostics) {
-        if (!this.config.fallbackModel || this.usingFallback) {
-            return false;
-        }
-        const originalModel = this.config.model;
-        this.triggerFallback();
-        if (this.config.model === originalModel) {
-            return false;
-        }
-        diagnostics.fallbackTriggered = true;
-        diagnostics.fallbackFromModel = originalModel;
-        diagnostics.fallbackToModel = this.config.model;
-        diagnostics.finalModel = this.config.model;
-        diagnostics.usingFallback = this.usingFallback;
-        return true;
-    }
     /**
      * 非流式对话
      */
     async chat(messages, tools) {
         const requestDiagnostics = this.createRequestDiagnostics();
         this.lastRequestDiagnostics = requestDiagnostics;
-        // Build the payload per attempt. Materialising it once would pin `model` to
-        // whatever was configured before the first request, so a fallback switch
-        // (which mutates this.config.model) would never reach the wire.
-        const buildParams = () => {
-            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;
-            }
-            return params;
-        };
+        const effortSnapshot = this.createEffortRequestSnapshot();
         // v0.2.25: Use resilience coordinator when available.
         let response;
         try {
@@ -363,16 +335,20 @@ class LLMService {
                     operation: 'root_chat',
                     providerKey: 'default',
                     requestedModel: this.config.model,
-                }, async (attempt) => {
-                    await this.assertProviderRequestAllowed('chat', attempt, messages);
-                    // Any attempt past the first means the coordinator classified the
-                    // previous failure as retryable, which is when the fallback model
-                    // is supposed to take over.
-                    if (attempt > 1) {
-                        this.applyFallbackForRetry(requestDiagnostics);
-                    }
+                    fallbackModel: this.config.fallbackModel || undefined,
+                }, async (attempt, signal, model = this.config.model) => {
+                    await this.assertProviderRequestAllowed('chat', attempt, messages, model);
+                    const params = {
+                        model,
+                        messages: this.toOpenAIMessages(messages),
+                        max_tokens: this.config.maxTokens,
+                        temperature: this.config.temperature,
+                        ...(0, effort_1.buildProviderEffortParams)(this.effortSnapshotForModel(effortSnapshot, model)),
+                    };
+                    if (tools && tools.length > 0)
+                        params.tools = tools;
                     return {
-                        response: (await this.client.chat.completions.create(buildParams())),
+                        response: await this.client.chat.completions.create(params, signal ? { signal } : undefined),
                     };
                 });
                 response = result.result;
@@ -380,7 +356,16 @@ class LLMService {
             }
             else {
                 await this.assertProviderRequestAllowed('chat', 1, messages);
-                response = (await this.client.chat.completions.create(buildParams()));
+                const params = {
+                    model: this.config.model,
+                    messages: this.toOpenAIMessages(messages),
+                    max_tokens: this.config.maxTokens,
+                    temperature: this.config.temperature,
+                    ...(0, effort_1.buildProviderEffortParams)(this.effortSnapshotForModel(effortSnapshot, this.config.model)),
+                };
+                if (tools && tools.length > 0)
+                    params.tools = tools;
+                response = (await this.client.chat.completions.create(params));
             }
         }
         catch (error) {
@@ -400,7 +385,8 @@ class LLMService {
                 throw error;
             throw (0, provider_diagnostics_1.toLLMProviderError)(error);
         }
-        const message = response.choices?.[0]?.message;
+        const choice = response.choices?.[0];
+        const message = choice?.message;
         const content = message?.content ?? '';
         const toolCalls = message?.tool_calls?.map(tc => ({
             id: tc.id,
@@ -410,8 +396,11 @@ class LLMService {
                 arguments: tc.function.arguments,
             },
         }));
+        const providerFinishReason = rawFinishReason(choice?.finish_reason);
+        const finishReason = normalizeFinishReason(providerFinishReason) ??
+            (toolCalls && toolCalls.length > 0 ? 'tool_calls' : undefined);
         const usage = response.usage
-            ? extractLLMUsage(response.usage, response, response.id)
+            ? this.annotateEffortUsage(extractLLMUsage(response.usage, response, response.id), this.effortSnapshotForModel(effortSnapshot, response.model ?? this.config.model))
             : undefined;
         requestDiagnostics.finalModel = response.model ?? this.config.model;
         requestDiagnostics.usingFallback = this.usingFallback;
@@ -425,6 +414,8 @@ class LLMService {
             content,
             usage,
             model: response.model ?? this.config.model,
+            finishReason,
+            rawFinishReason: providerFinishReason,
             toolCalls,
         };
     }
@@ -436,10 +427,34 @@ class LLMService {
         const onThinking = typeof callbacks === 'object' ? callbacks?.onThinking : undefined;
         const requestDiagnostics = this.createRequestDiagnostics();
         this.lastRequestDiagnostics = requestDiagnostics;
+        const effortSnapshot = this.createEffortRequestSnapshot();
+        let visibleStreamText = '';
+        const emitStreamText = (text, bufferForRecovery, reporter) => {
+            if (!text)
+                return;
+            reporter?.onTextDelta(text);
+            if (bufferForRecovery)
+                return;
+            visibleStreamText += text;
+            onChunk?.(text);
+        };
+        const finalizeStreamText = (attemptText, bufferForRecovery) => {
+            if (!bufferForRecovery)
+                return attemptText;
+            const suffix = attemptText.startsWith(visibleStreamText)
+                ? attemptText.slice(visibleStreamText.length)
+                : (0, provider_resilience_1.reconcileStreamOverlap)(visibleStreamText, attemptText).suffix;
+            if (suffix) {
+                visibleStreamText += suffix;
+                onChunk?.(suffix);
+            }
+            return visibleStreamText;
+        };
         const retryConfig = {
             maxRetries: this.config.maxRetries,
             baseDelayMs: this.config.retryBaseDelay,
             maxDelayMs: 10000,
+            maxRetryAfterMs: 60000,
             abortSignal: options?.abortSignal,
             onRetry: (_attempt, error, delayMs) => {
                 const diagnostic = (0, provider_diagnostics_1.diagnoseProviderError)(error);
@@ -453,8 +468,16 @@ class LLMService {
                     diagnostic.type === 'provider_busy' ||
                     diagnostic.type === 'rate_limit') {
                     this.consecutive529Errors++;
-                    if (this.consecutive529Errors >= MAX_529_RETRIES) {
-                        this.applyFallbackForRetry(requestDiagnostics);
+                    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;
@@ -469,23 +492,19 @@ class LLMService {
                     operation: 'root_chat_stream',
                     providerKey: 'default',
                     requestedModel: this.config.model,
+                    fallbackModel: this.config.fallbackModel || undefined,
                     abortSignal: options?.abortSignal,
-                }, async (attempt, signal) => {
+                }, async (attempt, signal, model = this.config.model, reporter) => {
                     throwIfAborted(signal);
-                    await this.assertProviderRequestAllowed('chat_stream', attempt, messages);
-                    // Same contract as chat(): the coordinator only re-enters this
-                    // callback after a retryable failure, so switch models here rather
-                    // than in retryConfig.onRetry, which the coordinator never calls.
-                    if (attempt > 1) {
-                        this.applyFallbackForRetry(requestDiagnostics);
-                    }
+                    await this.assertProviderRequestAllowed('chat_stream', attempt, messages, model);
                     const params = {
-                        model: this.config.model,
+                        model,
                         messages: this.toOpenAIMessages(messages),
                         max_tokens: this.config.maxTokens,
                         temperature: this.config.temperature,
                         stream: true,
                         stream_options: { include_usage: true },
+                        ...(0, effort_1.buildProviderEffortParams)(this.effortSnapshotForModel(effortSnapshot, model)),
                     };
                     if (tools && tools.length > 0) {
                         params.tools = tools;
@@ -494,9 +513,12 @@ class LLMService {
                     const requestOptions = signal ? { signal } : undefined;
                     const stream = (await this.client.chat.completions.create(params, requestOptions));
                     let content = '';
-                    let usedModel = this.config.model;
+                    let usedModel = model;
                     let usage;
                     let providerRequestId;
+                    let providerFinishReason;
+                    let finishReason;
+                    const bufferForRecovery = visibleStreamText.length > 0;
                     const toolCallsMap = new Map();
                     for await (const chunk of stream) {
                         throwIfAborted(signal);
@@ -507,11 +529,16 @@ class LLMService {
                                 console.log('[DEBUG] Raw chunk:', JSON.stringify(chunk, null, 2));
                             }
                         }
-                        const delta = chunk.choices?.[0]?.delta;
-                        const text = delta?.content ?? '';
+                        const choice = chunk.choices?.[0];
+                        const delta = choice?.delta;
+                        const msg = choice?.message;
+                        const text = delta?.content ?? (content ? '' : (msg?.content ?? ''));
                         if (text) {
                             content += text;
-                            onChunk?.(text);
+                            emitStreamText(text, bufferForRecovery, reporter);
+                        }
+                        if ((delta?.tool_calls?.length ?? 0) > 0 || (msg?.tool_calls?.length ?? 0) > 0) {
+                            reporter?.onToolCallDelta();
                         }
                         for (const tc of delta?.tool_calls ?? []) {
                             const idx = tc.index ?? 0;
@@ -535,7 +562,6 @@ class LLMService {
                                     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);
@@ -555,13 +581,19 @@ class LLMService {
                             }
                         }
                         if (chunk.usage) {
-                            usage = extractLLMUsage(chunk.usage, chunk, chunk.id ?? providerRequestId);
+                            usage = this.annotateEffortUsage(extractLLMUsage(chunk.usage, chunk, chunk.id ?? providerRequestId), this.effortSnapshotForModel(effortSnapshot, usedModel));
                         }
                         if (chunk.id)
                             providerRequestId = chunk.id;
                         if (chunk.model) {
                             usedModel = chunk.model;
                         }
+                        const chunkFinishReason = rawFinishReason(choice?.finish_reason);
+                        if (chunkFinishReason) {
+                            providerFinishReason = chunkFinishReason;
+                            finishReason = normalizeFinishReason(chunkFinishReason);
+                            reporter?.onFinishReason(chunkFinishReason);
+                        }
                     }
                     const toolCalls = Array.from(toolCallsMap.entries())
                         .sort(([a], [b]) => Number(a) - Number(b))
@@ -580,13 +612,17 @@ class LLMService {
                             }
                         }
                     }
+                    finishReason ?? (finishReason = toolCalls.length > 0 ? 'tool_calls' : undefined);
+                    const finalContent = finalizeStreamText(content, bufferForRecovery);
                     if (usage)
                         this.publishUsage(usage, usedModel, 'chat_stream');
                     return {
                         response: {
-                            content,
+                            content: finalContent,
                             model: usedModel,
                             usage,
+                            finishReason,
+                            rawFinishReason: providerFinishReason,
                             toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
                         },
                         usage: usage
@@ -623,6 +659,7 @@ class LLMService {
                         temperature: this.config.temperature,
                         stream: true,
                         stream_options: { include_usage: true },
+                        ...(0, effort_1.buildProviderEffortParams)(this.effortSnapshotForModel(effortSnapshot, this.config.model)),
                     };
                     if (tools && tools.length > 0) {
                         params.tools = tools;
@@ -634,6 +671,9 @@ class LLMService {
                     let usedModel = this.config.model;
                     let usage;
                     let providerRequestId;
+                    let providerFinishReason;
+                    let finishReason;
+                    const bufferForRecovery = visibleStreamText.length > 0;
                     const toolCallsMap = new Map();
                     for await (const chunk of stream) {
                         throwIfAborted(options?.abortSignal);
@@ -644,11 +684,13 @@ class LLMService {
                                 console.log('[DEBUG] Raw chunk:', JSON.stringify(chunk, null, 2));
                             }
                         }
-                        const delta = chunk.choices?.[0]?.delta;
-                        const text = delta?.content ?? '';
+                        const choice = chunk.choices?.[0];
+                        const delta = choice?.delta;
+                        const msg = choice?.message;
+                        const text = delta?.content ?? (content ? '' : (msg?.content ?? ''));
                         if (text) {
                             content += text;
-                            onChunk?.(text);
+                            emitStreamText(text, bufferForRecovery);
                         }
                         // Handle tool_calls from delta (OpenAI standard streaming format).
                         // A single stream chunk may contain multiple tool call deltas.
@@ -675,7 +717,6 @@ class LLMService {
                             }
                         }
                         // 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);
@@ -695,13 +736,18 @@ class LLMService {
                             }
                         }
                         if (chunk.usage) {
-                            usage = extractLLMUsage(chunk.usage, chunk, chunk.id ?? providerRequestId);
+                            usage = this.annotateEffortUsage(extractLLMUsage(chunk.usage, chunk, chunk.id ?? providerRequestId), this.effortSnapshotForModel(effortSnapshot, usedModel));
                         }
                         if (chunk.id)
                             providerRequestId = chunk.id;
                         if (chunk.model) {
                             usedModel = chunk.model;
                         }
+                        const chunkFinishReason = rawFinishReason(choice?.finish_reason);
+                        if (chunkFinishReason) {
+                            providerFinishReason = chunkFinishReason;
+                            finishReason = normalizeFinishReason(chunkFinishReason);
+                        }
                     }
                     const toolCalls = Array.from(toolCallsMap.entries())
                         .sort(([a], [b]) => Number(a) - Number(b))
@@ -720,6 +766,8 @@ class LLMService {
                             }
                         }
                     }
+                    finishReason ?? (finishReason = toolCalls.length > 0 ? 'tool_calls' : undefined);
+                    const finalContent = finalizeStreamText(content, bufferForRecovery);
                     if (usage)
                         this.publishUsage(usage, usedModel, 'chat_stream');
                     this.consecutive529Errors = 0;
@@ -730,9 +778,11 @@ class LLMService {
                         retryErrorTypes: [...requestDiagnostics.retryErrorTypes],
                     };
                     return {
-                        content,
+                        content: finalContent,
                         model: usedModel,
                         usage,
+                        finishReason,
+                        rawFinishReason: providerFinishReason,
                         toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
                     };
                 }, retryConfig);
@@ -827,6 +877,39 @@ class LLMService {
     setModel(model) {
         this.config.model = model;
     }
+    setEffortContext(input) {
+        const resolved = (0, effort_1.resolveEffort)({ session: input.preference, capability: input.capability });
+        if (input.preference !== 'auto' && !resolved.supported) {
+            throw new Error(resolved.warning ?? 'Effort is not supported by the active profile.');
+        }
+        this.effortContext = {
+            preference: input.preference,
+            protocol: input.protocol,
+            ...(input.capability
+                ? {
+                    capability: {
+                        ...input.capability,
+                        supportedLevels: [...input.capability.supportedLevels],
+                    },
+                }
+                : {}),
+            ...(input.fallbackCapability
+                ? {
+                    fallbackCapability: {
+                        ...input.fallbackCapability,
+                        supportedLevels: [...input.fallbackCapability.supportedLevels],
+                    },
+                }
+                : {}),
+        };
+        return resolved;
+    }
+    getResolvedEffort() {
+        return (0, effort_1.resolveEffort)({
+            session: this.effortContext.preference,
+            capability: this.effortContext.capability,
+        });
+    }
     /**
      * 获取当前模型
      */
@@ -851,6 +934,49 @@ class LLMService {
         };
     }
     // ---- Internal ----
+    createEffortRequestSnapshot() {
+        const preference = this.effortContext.preference;
+        const primaryCapability = this.effortContext.capability
+            ? {
+                ...this.effortContext.capability,
+                supportedLevels: [...this.effortContext.capability.supportedLevels],
+            }
+            : undefined;
+        const fallbackCapability = this.effortContext.fallbackCapability
+            ? {
+                ...this.effortContext.fallbackCapability,
+                supportedLevels: [...this.effortContext.fallbackCapability.supportedLevels],
+            }
+            : undefined;
+        return {
+            primaryModel: this.config.model,
+            ...(this.config.fallbackModel ? { fallbackModel: this.config.fallbackModel } : {}),
+            primary: {
+                protocol: this.effortContext.protocol,
+                capability: primaryCapability,
+                resolved: (0, effort_1.resolveEffort)({ session: preference, capability: primaryCapability }),
+            },
+            fallback: {
+                protocol: this.effortContext.protocol,
+                capability: fallbackCapability,
+                resolved: (0, effort_1.resolveEffort)({ session: preference, capability: fallbackCapability }),
+            },
+        };
+    }
+    effortSnapshotForModel(snapshot, model) {
+        return snapshot.fallbackModel && model === snapshot.fallbackModel
+            ? snapshot.fallback
+            : snapshot.primary;
+    }
+    annotateEffortUsage(usage, snapshot) {
+        return {
+            ...usage,
+            effortRequested: snapshot.resolved.requested,
+            ...(snapshot.resolved.effective ? { effortEffective: snapshot.resolved.effective } : {}),
+            effortSource: snapshot.resolved.source,
+            providerProtocol: snapshot.protocol,
+        };
+    }
     createRequestDiagnostics() {
         return {
             retryCount: 0,
@@ -859,12 +985,23 @@ class LLMService {
             fallbackTriggered: false,
             finalModel: this.config.model,
             usingFallback: this.usingFallback,
+            recoveryCount: 0,
+            unknownBilledAttemptCount: 0,
+            usageConfidence: 'unknown',
         };
     }
     applyResilienceDiagnostics(target, diagnostics) {
         const retriedAttempts = diagnostics.attempts.filter(attempt => attempt.backoffMs !== undefined);
         const lastRetriedAttempt = retriedAttempts[retriedAttempts.length - 1];
         target.retryCount += diagnostics.retryCount;
+        target.recoveryCount += diagnostics.recoveryCount;
+        target.unknownBilledAttemptCount += diagnostics.unknownBilledAttemptCount;
+        if (diagnostics.usageConfidence === 'partial' || target.usageConfidence === 'partial') {
+            target.usageConfidence = 'partial';
+        }
+        else if (diagnostics.usageConfidence === 'exact') {
+            target.usageConfidence = 'exact';
+        }
         target.retryDelayMs += diagnostics.totalBackoffMs;
         target.retryErrorTypes.push(...retriedAttempts.map(attempt => providerErrorTypeForFailureKind(attempt.failureKind)));
         if (lastRetriedAttempt) {
@@ -872,13 +1009,11 @@ class LLMService {
             target.lastRetryStatus = lastRetriedAttempt.status;
         }
         if (diagnostics.fallbackCount > 0) {
-            // The current coordinator records fallback dispositions but does not yet
-            // switch models. Surface the count through the legacy diagnostics contract
-            // so Goal accounting fails closed without claiming that a switch occurred.
             target.fallbackTriggered = true;
             target.fallbackFromModel = diagnostics.requestedModel;
             if (diagnostics.finalModel && diagnostics.finalModel !== diagnostics.requestedModel) {
                 target.fallbackToModel = diagnostics.finalModel;
+                this.usingFallback = true;
             }
         }
         target.finalModel = diagnostics.finalModel ?? target.finalModel;
@@ -886,6 +1021,7 @@ class LLMService {
     }
     /** 转换为 OpenAI SDK 消息格式 */
     toOpenAIMessages(messages) {
+        (0, tool_call_groups_1.assertToolCallGroups)(messages);
         return messages.map(msg => {
             if (msg.role === 'tool') {
                 return {