newmark-agent 0.5.14 → 0.6.0

package/dist/preload.js

@@ -10,7 +10,7 @@ contextBridge.exposeInMainWorld('api', {
     onStartupStatus: (callback) => {
         ipcRenderer.on('startup:status', (_event, payload) => callback(payload));
     },
-    sendMessage: (message, target) => ipcRenderer.invoke('agent:send', message, target),
+    sendMessage: (message, target, options) => ipcRenderer.invoke('agent:send', message, target, options),
     enqueueGuide: (envelope) => ipcRenderer.invoke('agent:enqueueGuide', envelope),
     queueAction: (action, input, target) => ipcRenderer.invoke('agent:queueAction', action, input, target),
     checkpointConversation: (request) => ipcRenderer.invoke('agent:checkpointConversation', request),
@@ -19,7 +19,7 @@ contextBridge.exposeInMainWorld('api', {
     stopConversation: (request) => ipcRenderer.invoke('agent:stopConversation', request),
     setWorkRunExpanded: (request) => ipcRenderer.invoke('agent:setWorkRunExpanded', request),
     sendPrompt: (message, _model) => ipcRenderer.invoke('agent:sendPrompt', message),
-    setMode: (mode) => ipcRenderer.invoke('agent:setMode', mode),
+    setMode: (mode, target) => ipcRenderer.invoke('agent:setMode', mode, target),
     setModel: (model) => ipcRenderer.invoke('agent:setModel', model),
     setIntelligence: (tier) => ipcRenderer.invoke('agent:setIntelligence', tier),
     setInputMode: (mode, target) => ipcRenderer.invoke('agent:setInputMode', mode, target),
@@ -48,7 +48,7 @@ contextBridge.exposeInMainWorld('api', {
     browserControl: (request) => ipcRenderer.invoke('browser:control', request),
     computerUseState: (target) => ipcRenderer.invoke('agent:computerUseState', target),
     setComputerUseEnabled: (target, enabled) => ipcRenderer.invoke('agent:setComputerUseEnabled', target, enabled),
-    runFlow: (name, input, start) => ipcRenderer.invoke('flow:run', name, input, start),
+    runFlow: (name, input, start, target) => ipcRenderer.invoke('flow:run', name, input, start, target),
     resumeFlow: (response, target) => ipcRenderer.invoke('flow:resume', response, target),
     guideFlow: (message, target) => ipcRenderer.invoke('flow:guide', message, target),
     stopFlow: (target) => ipcRenderer.invoke('flow:stop', target),

package/dist/providers/chat-completions.adapter.d.ts

@@ -16,6 +16,8 @@ export declare class ChatCompletionsAdapter implements ModelProviderAdapter {
     execute(request: SerializedProviderRequest, signal: AbortSignal, transport?: typeof defaultProviderTransport): AsyncIterable<NormalizedProviderEvent>;
     private emitNonStreaming;
     normalizeUsage(value: unknown): ActualApiUsage | null;
+    private validToolArguments;
+    private responseError;
     normalizeHeaders(headers: Headers | Record<string, string>): ProviderResponseMetadata;
     private extractText;
 }

package/dist/providers/chat-completions.adapter.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatCompletionsAdapter = void 0;
 const provider_events_1 = require("./provider-events");
 const provider_headers_1 = require("./provider-headers");
+const provider_request_compat_1 = require("./provider-request-compat");
 const chat_messages_1 = require("./chat-messages");
 const CHAT_SYSTEM_ROLE = 'system';
 /**
@@ -56,13 +57,9 @@ class ChatCompletionsAdapter {
         // body，否则省略，避免严格 API 拒绝未知字段。
         if (request.sessionId)
             body.session_id = request.sessionId;
-        const base = request.baseUrl.replace(/\/+$/, '');
         return {
-            url: `${base}/chat/completions`,
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${request.apiKey}`,
-            },
+            url: (0, provider_request_compat_1.providerEndpoint)(request.baseUrl, '/chat/completions'),
+            headers: (0, provider_request_compat_1.providerRequestHeaders)('openai', request.apiKey),
             body,
         };
     }
@@ -88,7 +85,7 @@ class ChatCompletionsAdapter {
         const contentType = response.headers.get('content-type') || '';
         if (!/text\/event-stream/i.test(contentType)) {
             const json = await response.json();
-            yield* this.emitNonStreaming(json);
+            yield* this.emitNonStreaming(json, response.headers);
             return;
         }
         const reader = response.body?.getReader();
@@ -97,9 +94,10 @@ class ChatCompletionsAdapter {
             return;
         }
         const decoder = new TextDecoder();
-        let buffer = '';
+        const sse = new provider_events_1.ProviderSseDecoder();
         const toolCalls = new Map();
         const toolCallOrder = [];
+        const toolIndexById = new Map();
         let syntheticToolIndex = 0;
         let lastToolIndex = 0;
         let contentPolicyBlocked = false;
@@ -107,22 +105,17 @@ class ChatCompletionsAdapter {
         let emittedTool = false;
         let emittedReasoning = false;
         let explicitCompletion = false;
+        let finishReason = '';
+        let streamError = '';
         try {
-            while (true) {
+            stream: while (true) {
                 const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
                 if (done)
                     break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    const trimmed = line.trim();
-                    if (!trimmed.startsWith('data: '))
-                        continue;
-                    const data = trimmed.slice(6);
+                for (const { data } of sse.push(decoder.decode(value, { stream: true }))) {
                     if (data === '[DONE]') {
                         explicitCompletion = true;
-                        continue;
+                        break stream;
                     }
                     let json;
                     try {
@@ -136,12 +129,18 @@ class ChatCompletionsAdapter {
                         if (usage)
                             yield { type: 'usage.updated', usage };
                     }
+                    if (json.error) {
+                        streamError = this.responseError(json, response.headers);
+                        break stream;
+                    }
                     if ((0, provider_events_1.isContentPolicyBlocked)(json))
                         contentPolicyBlocked = true;
                     const choices = Array.isArray(json.choices) ? json.choices : [];
                     const choice = choices[0];
-                    if (choice?.finish_reason !== undefined && choice.finish_reason !== null)
+                    if (typeof choice?.finish_reason === 'string' && choice.finish_reason.trim()) {
                         explicitCompletion = true;
+                        finishReason = choice.finish_reason.trim();
+                    }
                     const delta = choice?.delta;
                     if (!delta)
                         continue;
@@ -162,14 +161,16 @@ class ChatCompletionsAdapter {
                         const tc = raw;
                         const fn = tc.function && typeof tc.function === 'object' ? tc.function : {};
                         const rawIndex = Number(tc.index);
-                        const index = Number.isInteger(rawIndex) && rawIndex >= 0
-                            ? rawIndex
-                            : (tc.id ? syntheticToolIndex++ : lastToolIndex);
+                        const id = String(tc.id || '');
+                        while (toolCalls.has(syntheticToolIndex))
+                            syntheticToolIndex++;
+                        const index = toolIndexById.get(id) ?? (tc.index !== undefined && tc.index !== null && Number.isInteger(rawIndex) && rawIndex >= 0
+                            ? rawIndex : (id ? syntheticToolIndex++ : lastToolIndex));
                         lastToolIndex = index;
                         let currentToolCall = toolCalls.get(index);
-                        if (!currentToolCall && tc.id) {
+                        if (!currentToolCall) {
                             currentToolCall = {
-                                id: String(tc.id || ''),
+                                id,
                                 name: (0, chat_messages_1.openAIToolName)(String(fn.name || '')),
                                 argumentParts: [],
                             };
@@ -177,6 +178,14 @@ class ChatCompletionsAdapter {
                             toolCallOrder.push(index);
                             yield { type: 'tool_call.started', id: currentToolCall.id, name: currentToolCall.name };
                         }
+                        if (id) {
+                            if (currentToolCall.id && currentToolCall.id !== id) {
+                                streamError = '[LLM Error] Provider changed a streamed tool call identity.';
+                                break stream;
+                            }
+                            currentToolCall.id = id;
+                            toolIndexById.set(id, index);
+                        }
                         if (currentToolCall && fn.name && !currentToolCall.name)
                             currentToolCall.name = (0, chat_messages_1.openAIToolName)(String(fn.name));
                         if (currentToolCall && fn.arguments !== undefined && fn.arguments !== null) {
@@ -189,17 +198,26 @@ class ChatCompletionsAdapter {
                     }
                 }
             }
+            if (streamError || !explicitCompletion || finishReason === 'length' || finishReason === 'content_filter') {
+                yield { type: 'response.failed', error: streamError || (finishReason === 'length'
+                        ? '[LLM Error] Chat response was truncated by the output token limit.'
+                        : finishReason === 'content_filter' ? '[Error] Content policy refusal (content_filter).'
+                            : '[LLM Error] Chat stream ended before an explicit completion.') };
+                return;
+            }
             if (toolCallOrder.length) {
-                for (const index of toolCallOrder) {
-                    const currentToolCall = toolCalls.get(index);
-                    if (!currentToolCall)
-                        continue;
+                const completeCalls = toolCallOrder.map(index => toolCalls.get(index)).map(call => ({ ...call, arguments: (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts, true) }));
+                if (completeCalls.some(call => !call.id || !call.name || !this.validToolArguments(call.arguments))) {
+                    yield { type: 'response.failed', error: '[LLM Error] Provider returned incomplete or invalid tool-call arguments.' };
+                    return;
+                }
+                for (const currentToolCall of completeCalls) {
                     emittedTool = true;
                     yield {
                         type: 'tool_call.completed',
                         id: currentToolCall.id,
                         name: currentToolCall.name,
-                        arguments: (0, provider_events_1.assembleCompatibleToolArguments)(currentToolCall.argumentParts),
+                        arguments: currentToolCall.arguments,
                     };
                 }
             }
@@ -207,20 +225,24 @@ class ChatCompletionsAdapter {
                 yield { type: 'response.failed', error: '[Error] Content policy refusal (content_filter).' };
                 return;
             }
-            if (!explicitCompletion && !emittedContent && !emittedTool && !emittedReasoning) {
-                yield { type: 'response.failed', error: '[LLM Error] Chat stream ended before an explicit completion.' };
-                return;
-            }
             yield { type: 'response.completed' };
         }
         finally {
+            try {
+                await reader.cancel();
+            }
+            catch { }
             reader.releaseLock();
         }
     }
-    async *emitNonStreaming(json) {
+    async *emitNonStreaming(json, headers) {
         const usage = this.normalizeUsage(json.usage);
         if (usage)
             yield { type: 'usage.updated', usage };
+        if (json.error) {
+            yield { type: 'response.failed', error: this.responseError(json, headers) };
+            return;
+        }
         const choices = Array.isArray(json.choices) ? json.choices : [];
         const choice = choices[0];
         const message = choice?.message && typeof choice.message === 'object' ? choice.message : {};
@@ -230,14 +252,27 @@ class ChatCompletionsAdapter {
         const text = this.extractText(message.content) || this.extractText(choice?.text);
         if (text)
             yield { type: 'text.delta', delta: text };
+        if (choice?.finish_reason === 'length' || choice?.finish_reason === 'content_filter') {
+            yield { type: 'response.failed', error: choice.finish_reason === 'length'
+                    ? '[LLM Error] Chat response was truncated by the output token limit.'
+                    : '[Error] Content policy refusal (content_filter).' };
+            return;
+        }
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-        for (const raw of toolCalls) {
+        const completeCalls = toolCalls.map(raw => {
             const tc = raw;
             const fn = tc.function && typeof tc.function === 'object' ? tc.function : {};
             const id = String(tc.id || '');
             const name = (0, chat_messages_1.openAIToolName)(String(fn.name || ''));
+            const args = fn.arguments === undefined || fn.arguments === null ? '' : String(fn.arguments);
+            return { id, name, args };
+        });
+        if (completeCalls.some(call => !call.id || !call.name || !this.validToolArguments(call.args))) {
+            yield { type: 'response.failed', error: '[LLM Error] Provider returned incomplete or invalid tool-call arguments.' };
+            return;
+        }
+        for (const { id, name, args } of completeCalls) {
             yield { type: 'tool_call.started', id, name };
-            const args = String(fn.arguments || '{}');
             if (args && args !== '{}')
                 yield { type: 'tool_call.arguments.delta', id, delta: args };
             yield { type: 'tool_call.completed', id, name, arguments: args };
@@ -254,6 +289,19 @@ class ChatCompletionsAdapter {
             return null;
         return normalized;
     }
+    validToolArguments(value) {
+        try {
+            const parsed = JSON.parse(value);
+            return !!parsed && typeof parsed === 'object' && !Array.isArray(parsed);
+        }
+        catch {
+            return false;
+        }
+    }
+    responseError(json, headers) {
+        const error = json.error && typeof json.error === 'object' ? json.error : {};
+        return (0, provider_events_1.providerSemanticErrorText)(error, this.extractText(error.message || error.type || json.error) || 'Provider returned an error response.', headers);
+    }
     normalizeHeaders(headers) {
         return (0, provider_headers_1.normalizeProviderHeaders)(headers);
     }

package/dist/providers/provider-adapter.d.ts

@@ -133,6 +133,8 @@ export interface ActualApiUsage {
     cacheReadTokens: number;
     cacheWriteTokens: number;
     totalTokens: number;
+    /** Legacy injected providers may omit this; normal protocol parsing fills it. */
+    reported?: import('../core/types').ProviderUsageReported;
 }
 export interface ProviderResponseMetadata {
     requestId?: string;

package/dist/providers/provider-events.d.ts

@@ -1,4 +1,6 @@
-import { NormalizedAgentRequest, SerializedProviderRequest, TransportResponse } from './provider-adapter';
+import { ActualApiUsage, NormalizedAgentRequest, SerializedProviderRequest, TransportResponse } from './provider-adapter';
+import { Dispatcher } from 'undici';
+export declare function providerStreamingDispatcher(dispatcher?: unknown): Dispatcher;
 /** dev-0.5.14: let non-LLMProvider adapter fallbacks also honor the configured proxy. */
 export declare function setDefaultProviderDispatcher(dispatcher: unknown): void;
 /**
@@ -28,13 +30,24 @@ export declare function parseProviderSse(raw: string): Array<{
     event?: string;
     data: string;
 }>;
+/** Incremental SSE framing: CRLF can straddle any transport chunk boundary. */
+export declare class ProviderSseDecoder {
+    private line;
+    private skipLf;
+    private event;
+    private data;
+    push(text: string): Array<{
+        event?: string;
+        data: string;
+    }>;
+}
 /**
  * Compatible gateways may stream function arguments as JSON deltas or repeat
  * a cumulative snapshot on every SSE frame. Keep the normal incremental form
  * when it parses, then fall back to snapshot folding. Returning malformed
  * concatenated snapshots would erase the model's correction at tool parsing.
  */
-export declare function assembleCompatibleToolArguments(parts: string[]): string;
+export declare function assembleCompatibleToolArguments(parts: string[], strictFinal?: boolean): string;
 /**
  * Detect content-policy refusals across the provider failure shapes.
  * Mirrors `LLMProvider.contentPolicyBlocked` semantics exactly so the
@@ -46,18 +59,16 @@ export declare function assembleCompatibleToolArguments(parts: string[]): string
  * - `content_filter_results` / `prompt_filter_results` with `"filtered": true`
  */
 export declare function isContentPolicyBlocked(json: Record<string, unknown>): boolean;
+export interface UsageNormalizationOptions {
+    /** Only the actual native protocol can change the meaning of input_tokens. */
+    protocol?: 'openai' | 'anthropic' | 'github_models';
+}
 /**
  * Normalize the many provider usage shapes into ActualApiUsage.
  * Handles Chat Completions `usage`, Responses `response.usage`, and
  * Anthropic-style `usage` objects.
  */
-export declare function normalizeProviderUsage(value: unknown): {
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-    totalTokens: number;
-} | null;
+export declare function normalizeProviderUsage(value: unknown, options?: UsageNormalizationOptions): ActualApiUsage | null;
 export declare function estimateRequestTokens(request: NormalizedAgentRequest): {
     inputTokens: number;
     outputReservedTokens: number;
@@ -65,11 +76,9 @@ export declare function estimateRequestTokens(request: NormalizedAgentRequest):
     totalTokens: number;
     tokenizerSource: 'estimated' | 'compatible' | 'provider_tokenizer';
 };
-/**
- * Format a non-OK provider response into the exact error string the LLM
- * provider produces (`[LLM Error: <status>][ Retry-After: <n>s] <body>`).
- * Mirrors `LLMProvider.llmErrorText`.
- */
+/** Keep semantic provider errors classifiable even when the HTTP status is 200. */
+export declare function providerSemanticErrorText(value: unknown, fallback: string, headers?: Pick<Headers, 'get'>): string;
+/** Format a non-OK response, retaining the server's retry delay. */
 export declare function providerErrorText(response: {
     status: number;
     headers?: {

package/dist/providers/provider-events.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderSseDecoder = void 0;
+exports.providerStreamingDispatcher = providerStreamingDispatcher;
 exports.setDefaultProviderDispatcher = setDefaultProviderDispatcher;
 exports.defaultProviderTransport = defaultProviderTransport;
 exports.providerAbortError = providerAbortError;
@@ -10,12 +12,40 @@ exports.assembleCompatibleToolArguments = assembleCompatibleToolArguments;
 exports.isContentPolicyBlocked = isContentPolicyBlocked;
 exports.normalizeProviderUsage = normalizeProviderUsage;
 exports.estimateRequestTokens = estimateRequestTokens;
+exports.providerSemanticErrorText = providerSemanticErrorText;
 exports.providerErrorText = providerErrorText;
 exports.normalizeResponsesPayload = normalizeResponsesPayload;
+const undici_1 = require("undici");
+const provider_headers_1 = require("./provider-headers");
 /**
  * Shared SSE parsing and usage normalization used by both adapters.
  */
 let defaultProviderDispatcher = null;
+const directProviderStreamDispatcher = new undici_1.Agent();
+const providerStreamDispatchers = new WeakMap();
+class StreamingProviderDispatcher extends undici_1.Dispatcher {
+    delegate;
+    constructor(delegate) {
+        super();
+        this.delegate = delegate;
+    }
+    dispatch(options, handler) {
+        // The application already owns cancellation. Undici otherwise adds its
+        // own 300s headers/body deadline, including during valid long reasoning
+        // and non-streaming JSON model responses (for example generated titles).
+        // Keep connection establishment and all non-LLM requests unchanged.
+        return this.delegate.dispatch({ ...options, headersTimeout: 0, bodyTimeout: 0 }, handler);
+    }
+}
+function providerStreamingDispatcher(dispatcher) {
+    const delegate = (dispatcher || directProviderStreamDispatcher);
+    let streaming = providerStreamDispatchers.get(delegate);
+    if (!streaming) {
+        streaming = new StreamingProviderDispatcher(delegate);
+        providerStreamDispatchers.set(delegate, streaming);
+    }
+    return streaming;
+}
 /** dev-0.5.14: let non-LLMProvider adapter fallbacks also honor the configured proxy. */
 function setDefaultProviderDispatcher(dispatcher) {
     defaultProviderDispatcher = dispatcher || null;
@@ -31,8 +61,11 @@ function defaultProviderTransport(request, signal) {
         body: JSON.stringify(request.body),
         signal,
     };
-    if (defaultProviderDispatcher) {
-        init.dispatcher = defaultProviderDispatcher;
+    // This transport is exclusively for model POSTs, regardless of whether the
+    // provider returns SSE or a complete JSON body. It never serves model GETs.
+    const dispatcher = providerStreamingDispatcher(defaultProviderDispatcher);
+    if (dispatcher) {
+        init.dispatcher = dispatcher;
     }
     return fetch(request.url, init);
 }
@@ -116,16 +149,64 @@ function parseProviderSse(raw) {
     }
     return events;
 }
+/** Incremental SSE framing: CRLF can straddle any transport chunk boundary. */
+class ProviderSseDecoder {
+    line = '';
+    skipLf = false;
+    event;
+    data = [];
+    push(text) {
+        const events = [];
+        let start = 0;
+        for (let i = 0; i < text.length; i += 1) {
+            const char = text[i];
+            if (this.skipLf) {
+                this.skipLf = false;
+                if (char === '\n') {
+                    start = i + 1;
+                    continue;
+                }
+            }
+            if (char !== '\r' && char !== '\n')
+                continue;
+            const line = this.line + text.slice(start, i);
+            this.line = '';
+            start = i + 1;
+            this.skipLf = char === '\r';
+            if (!line) {
+                if (this.data.length)
+                    events.push({ event: this.event, data: this.data.join('\n') });
+                this.event = undefined;
+                this.data = [];
+            }
+            else if (!line.startsWith(':')) {
+                const colon = line.indexOf(':');
+                const field = colon < 0 ? line : line.slice(0, colon);
+                let value = colon < 0 ? '' : line.slice(colon + 1);
+                // SSE removes only the optional single ASCII space after the colon.
+                if (value.startsWith(' '))
+                    value = value.slice(1);
+                if (field === 'event')
+                    this.event = value;
+                else if (field === 'data')
+                    this.data.push(value);
+            }
+        }
+        this.line += text.slice(start);
+        return events;
+    }
+}
+exports.ProviderSseDecoder = ProviderSseDecoder;
 /**
  * Compatible gateways may stream function arguments as JSON deltas or repeat
  * a cumulative snapshot on every SSE frame. Keep the normal incremental form
  * when it parses, then fall back to snapshot folding. Returning malformed
  * concatenated snapshots would erase the model's correction at tool parsing.
  */
-function assembleCompatibleToolArguments(parts) {
-    const nonEmpty = (parts || []).map(String).filter(part => part && part !== 'null');
+function assembleCompatibleToolArguments(parts, strictFinal = false) {
+    const nonEmpty = (parts || []).map(String).filter(part => part && (strictFinal || part !== 'null'));
     if (!nonEmpty.length)
-        return '{}';
+        return strictFinal ? '' : '{}';
     const isJsonObject = (value) => {
         try {
             const parsed = JSON.parse(value);
@@ -146,13 +227,21 @@ function assembleCompatibleToolArguments(parts) {
             continue;
         else if (incoming.startsWith(compatible))
             compatible = incoming;
-        else if (compatible.startsWith(incoming))
-            continue;
+        else if (compatible.startsWith(incoming)) {
+            if (strictFinal && isJsonObject(compatible) && !isJsonObject(incoming))
+                compatible = incoming;
+            else
+                continue;
+        }
         else
             compatible += incoming;
     }
     if (isJsonObject(compatible))
         return compatible;
+    // At execution time an earlier valid snapshot cannot repair a newer,
+    // truncated correction. Only the final snapshot may replace bad assembly.
+    if (strictFinal)
+        return isJsonObject(nonEmpty[nonEmpty.length - 1]) ? nonEmpty[nonEmpty.length - 1] : compatible;
     return [...nonEmpty].reverse().find(isJsonObject) || compatible;
 }
 /**
@@ -181,49 +270,62 @@ function isContentPolicyBlocked(json) {
     const filterEvidence = JSON.stringify(choice.content_filter_results || json.prompt_filter_results || {});
     return /"filtered"\s*:\s*true/i.test(filterEvidence);
 }
-function extractUsageValue(value) {
-    return Math.max(0, Number(value) || 0);
+function reportedUsageValue(...values) {
+    for (const value of values) {
+        if (typeof value !== 'number' && (typeof value !== 'string' || !value.trim()))
+            continue;
+        const number = Number(value);
+        if (Number.isFinite(number) && number >= 0)
+            return { value: Math.floor(number), reported: true };
+    }
+    return { value: 0, reported: false };
 }
 /**
  * Normalize the many provider usage shapes into ActualApiUsage.
  * Handles Chat Completions `usage`, Responses `response.usage`, and
  * Anthropic-style `usage` objects.
  */
-function normalizeProviderUsage(value) {
+function normalizeProviderUsage(value, options = {}) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return null;
     const raw = value;
     // Nested response usage (Responses API: usage inside response).
     if (raw.response && typeof raw.response === 'object' && !Array.isArray(raw.response)) {
-        return normalizeProviderUsage(raw.response);
+        return normalizeProviderUsage(raw.response, options);
     }
     // Top-level `usage` wrapper (Responses `response.completed` items carry
     // `{ response: { usage } }`, which strips down to `{ usage }`).
     if (raw.usage && typeof raw.usage === 'object' && !Array.isArray(raw.usage)) {
-        return normalizeProviderUsage(raw.usage);
+        return normalizeProviderUsage(raw.usage, options);
     }
-    const inputTokens = extractUsageValue(raw.input_tokens) ||
-        extractUsageValue(raw.prompt_tokens) ||
-        extractUsageValue(raw.input) ||
-        0;
-    const outputTokens = extractUsageValue(raw.output_tokens) ||
-        extractUsageValue(raw.completion_tokens) ||
-        extractUsageValue(raw.output) ||
-        0;
-    // token_details (Responses) / prompt_tokens_details (Chat).
-    const details = raw.token_details ?? raw.prompt_tokens_details ?? {};
-    const detailsObj = details && typeof details === 'object' && !Array.isArray(details) ? details : {};
-    const cachedTokens = raw.cached_tokens ?? detailsObj.cached_tokens ?? 0;
-    const cacheReadTokens = extractUsageValue(cachedTokens);
-    const cacheCreationTokens = raw.cache_creation_tokens ?? raw.cache_read_input_tokens ?? detailsObj.cache_creation ?? 0;
-    const cacheWriteTokens = extractUsageValue(cacheCreationTokens);
-    const totalTokens = extractUsageValue(raw.total_tokens) || inputTokens + outputTokens;
+    const input = reportedUsageValue(raw.input_tokens, raw.prompt_tokens, raw.input);
+    const output = reportedUsageValue(raw.output_tokens, raw.completion_tokens, raw.output);
+    // Responses uses input_tokens_details; Chat uses prompt_tokens_details.
+    // Keep compatible top-level and legacy aliases without confusing reads
+    // with writes. An explicit zero is authoritative, not a missing value.
+    const details = [raw.input_tokens_details, raw.prompt_tokens_details, raw.token_details]
+        .filter((value) => !!value && typeof value === 'object' && !Array.isArray(value));
+    const detailValues = (...keys) => details.flatMap(value => keys.map(key => value[key]));
+    const cacheRead = reportedUsageValue(raw.cached_tokens, raw.cache_read_input_tokens, raw.cached_input_tokens, ...detailValues('cached_tokens', 'cache_read_tokens'), raw.prompt_cache_hit_tokens);
+    const cacheWrite = reportedUsageValue(raw.cache_creation_input_tokens, raw.cache_write_input_tokens, raw.cache_creation_tokens, ...detailValues('cache_write_tokens', 'cache_creation'));
+    const total = reportedUsageValue(raw.total_tokens);
+    const reported = { input: input.reported, output: output.reported, cacheRead: cacheRead.reported, cacheWrite: cacheWrite.reported };
+    if (!Object.values(reported).some(Boolean) && !total.reported)
+        return null;
+    // Native Anthropic input_tokens excludes both cache reads and writes. OpenAI
+    // compatible aliases alone never select this protocol-specific convention.
+    const inputTokens = input.value + (options.protocol === 'anthropic' ? cacheRead.value + cacheWrite.value : 0);
+    const outputTokens = output.value;
+    const cacheReadTokens = cacheRead.value;
+    const cacheWriteTokens = cacheWrite.value;
+    const totalTokens = total.reported ? total.value : inputTokens + outputTokens;
     return {
         inputTokens,
         outputTokens,
         cacheReadTokens,
         cacheWriteTokens,
         totalTokens,
+        reported,
     };
 }
 const CHARACTERS_PER_TOKEN = 4;
@@ -257,22 +359,25 @@ function estimateRequestTokens(request) {
         tokenizerSource: 'estimated',
     };
 }
-/**
- * Format a non-OK provider response into the exact error string the LLM
- * provider produces (`[LLM Error: <status>][ Retry-After: <n>s] <body>`).
- * Mirrors `LLMProvider.llmErrorText`.
- */
-function providerErrorText(response, body) {
-    const rawRetryAfter = response.headers?.get('retry-after')?.trim() || '';
-    let retryAfter = '';
-    if (/^\d+(?:\.\d+)?$/.test(rawRetryAfter)) {
-        retryAfter = ` Retry-After: ${rawRetryAfter}s`;
-    }
-    else if (rawRetryAfter) {
-        const retryAt = Date.parse(rawRetryAfter);
-        if (Number.isFinite(retryAt))
-            retryAfter = ` Retry-After: ${Math.max(0, Math.ceil((retryAt - Date.now()) / 1000))}s`;
+/** Keep semantic provider errors classifiable even when the HTTP status is 200. */
+function providerSemanticErrorText(value, fallback, headers) {
+    const seconds = headers ? (0, provider_headers_1.normalizeProviderHeaders)(headers).retryAfterSeconds : undefined;
+    const prefix = `[LLM Error]${seconds === undefined ? '' : ` Retry-After: ${seconds}s`} `;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return prefix + fallback;
+    const error = value;
+    const detail = { message: typeof error.message === 'string' ? error.message : fallback };
+    for (const key of ['code', 'type']) {
+        const entry = error[key];
+        if (typeof entry === 'string' && /^[a-z0-9_.-]{1,80}$/i.test(entry))
+            detail[key] = entry;
     }
+    return prefix + (detail.code || detail.type ? JSON.stringify({ error: detail }) : detail.message);
+}
+/** Format a non-OK response, retaining the server's retry delay. */
+function providerErrorText(response, body) {
+    const seconds = response.headers ? (0, provider_headers_1.normalizeProviderHeaders)(response.headers).retryAfterSeconds : undefined;
+    const retryAfter = seconds === undefined ? '' : ` Retry-After: ${seconds}s`;
     return `[LLM Error: ${response.status}]${retryAfter} ${body}`;
 }
 /**