newmark-agent 0.5.14 → 0.6.0

package/dist/llm/provider.js

@@ -41,6 +41,8 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const agentKernelDiagnostics_1 = require("../core/agentKernelDiagnostics");
+const provider_request_compat_1 = require("../providers/provider-request-compat");
+const provider_headers_1 = require("../providers/provider-headers");
 const chat_messages_1 = require("../providers/chat-messages");
 const providers_1 = require("../providers");
 const undici_1 = require("undici");
@@ -188,14 +190,16 @@ class LLMProvider {
         }
         return this.nodeProxyAgent;
     }
-    async providerFetch(input, init = {}) {
-        const dispatcher = this.resolveProxyDispatcher();
+    async providerFetch(input, init = {}, streaming = false) {
+        const proxyDispatcher = this.resolveProxyDispatcher();
         const url = typeof input === 'string'
             ? input
             : input instanceof URL
                 ? input.toString()
                 : String(input.url || '');
-        if (!dispatcher || this.isPlainHttpLoopback(url))
+        const selectedDispatcher = this.isPlainHttpLoopback(url) ? null : proxyDispatcher;
+        const dispatcher = streaming ? (0, providers_1.providerStreamingDispatcher)(selectedDispatcher) : selectedDispatcher;
+        if (!dispatcher)
             return fetch(input, init);
         return fetch(input, { ...init, dispatcher });
     }
@@ -305,40 +309,23 @@ class LLMProvider {
         return 'chat_stream';
     }
     cleanBaseUrl() {
-        return this.baseUrl.replace(/\/+$/, '');
+        return this.baseUrl.trim();
     }
     githubModelsBaseUrl() {
         const base = this.cleanBaseUrl();
         if (!base)
             return 'https://models.github.ai';
-        if (/\/inference$/i.test(base))
-            return base.replace(/\/inference$/i, '');
         return base;
     }
     githubModelsUrl(pathname) {
-        const base = this.githubModelsBaseUrl();
-        const path = pathname.startsWith('/') ? pathname : `/${pathname}`;
-        return `${base}${path}`;
+        return (0, provider_request_compat_1.providerEndpoint)(this.githubModelsBaseUrl(), pathname);
     }
-    openAIHeaders() {
-        if (this.protocol() === 'github_models')
-            return this.githubModelsHeaders();
-        return {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${this.apiKey}`,
-        };
+    openAIHeaders(stream = false) {
+        return (0, provider_request_compat_1.providerRequestHeaders)(this.protocol() === 'github_models' ? 'github_models' : 'openai', this.apiKey, stream);
     }
     llmErrorText(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()) / 1_000))}s`;
-        }
+        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}`;
     }
     headerReader(headers) {
@@ -369,12 +356,8 @@ class LLMProvider {
             return;
         console.error(`[NewmarkProvider] ${stage}${detail ? ` ${detail}` : ''}`);
     }
-    githubModelsHeaders() {
-        return {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${this.apiKey}`,
-            'X-GitHub-Api-Version': '2022-11-28',
-        };
+    githubModelsHeaders(stream = false) {
+        return (0, provider_request_compat_1.providerRequestHeaders)('github_models', this.apiKey, stream);
     }
     temperatureCapabilityKey(url, body) {
         return `${url}|${String(body.model || '')}`;
@@ -460,8 +443,17 @@ class LLMProvider {
                 headers,
                 body: JSON.stringify(body),
                 signal: abort.signal,
-            });
-            return response;
+            }, true);
+            // Keep the caller's cancellation and explicit deadline attached through
+            // the JSON body, not just until response headers arrive.
+            const responseText = await response.text();
+            return {
+                ok: response.ok,
+                status: response.status,
+                headers: response.headers,
+                text: async () => responseText,
+                json: async () => JSON.parse(responseText || '{}'),
+            };
         }
         catch (e) {
             if (signal?.aborted)
@@ -713,12 +705,8 @@ class LLMProvider {
             out = out.split(this.apiKey).join('sk-***REDACTED***');
         return out.replace(/sk-[A-Za-z0-9_\-.]{8,}/g, 'sk-***REDACTED***');
     }
-    anthropicHeaders() {
-        return {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-            'anthropic-version': '2023-06-01',
-        };
+    anthropicHeaders(stream = false) {
+        return (0, provider_request_compat_1.providerRequestHeaders)('anthropic', this.apiKey, stream);
     }
     stringifyContent(value) {
         return (0, chat_messages_1.stringifyContent)(value);
@@ -944,12 +932,17 @@ class LLMProvider {
             ? current
             : {};
     }
-    async openAIResponsesChat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier) {
-        const response = await this.postJsonWithFetchFallback(`${this.cleanBaseUrl()}/responses`, this.openAIHeaders(), this.responsesBody(model, messages, systemPrompt, temperature, maxTokens, [], reasoningTier), 120000, signal);
+    async openAIResponsesChat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier, onUsage) {
+        const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/responses'), this.openAIHeaders(), this.responsesBody(model, messages, systemPrompt, temperature, maxTokens, [], reasoningTier), 120000, signal);
         if (!response.ok) {
             return this.llmErrorText(response, await response.text());
         }
-        return this.extractResponsesText(this.normalizeResponsesPayload(await response.json()));
+        const json = this.normalizeResponsesPayload(await response.json());
+        onUsage?.((0, agentKernelDiagnostics_1.extractProviderUsage)(json));
+        const failure = this.nativeJsonCompletionError(json, 'responses');
+        if (failure)
+            return failure;
+        return this.extractResponsesText(json);
     }
     anthropicTools(tools) {
         const converted = [];
@@ -1052,6 +1045,7 @@ class LLMProvider {
         };
         const serialized = await adapter.serializeRequest(request);
         serialized.body.stream = mode === 'chat' ? false : true;
+        serialized.headers = this.openAIHeaders(serialized.body.stream === true);
         const execSignal = signal ?? new AbortController().signal;
         const transport = this.buildProviderAdapterTransport();
         const streaming = mode === 'chat_stream';
@@ -1091,7 +1085,7 @@ class LLMProvider {
                     yield* this.adapterResponsesBridge(model, messages, systemPrompt, temperature, maxTokens, tools, signal, downgradeTier);
                     return;
                 }
-                yield { type: 'text', text: event.error };
+                yield { type: 'text', text: event.error, providerError: true };
                 return;
             }
         }
@@ -1113,7 +1107,7 @@ class LLMProvider {
         };
         const serialized = await adapter.serializeRequest(request);
         serialized.body.stream = true;
-        serialized.headers['Accept'] = 'text/event-stream';
+        serialized.headers = this.openAIHeaders(true);
         const execSignal = signal ?? new AbortController().signal;
         const transport = this.buildProviderAdapterTransport();
         let reasoningSummary = '';
@@ -1147,7 +1141,7 @@ class LLMProvider {
                 continue;
             }
             if (event.type === 'response.failed') {
-                yield { type: 'text', text: event.error };
+                yield { type: 'text', text: event.error, providerError: true };
                 return;
             }
         }
@@ -1158,6 +1152,7 @@ class LLMProvider {
             output: usage.outputTokens,
             cacheRead: usage.cacheReadTokens,
             cacheWrite: usage.cacheWriteTokens,
+            reported: usage.reported,
         };
     }
     shouldDowngradeToResponses(errorText) {
@@ -1195,9 +1190,10 @@ class LLMProvider {
                             headers: request.headers,
                             body: JSON.stringify(request.body),
                             signal: abort.signal,
-                        });
+                        }, true);
                         if (request.body.temperature !== undefined && response.status === 400) {
-                            const errorText = await response.clone().text();
+                            const buffered = await this.bufferTransportResponse(response);
+                            const errorText = await buffered.text();
                             if (this.unsupportedTemperatureError(response.status, errorText)) {
                                 this.temperatureUnsupported.add(this.temperatureCapabilityKey(request.url, request.body));
                                 const retryBody = { ...request.body };
@@ -1207,8 +1203,17 @@ class LLMProvider {
                                     headers: request.headers,
                                     body: JSON.stringify(retryBody),
                                     signal: abort.signal,
-                                });
+                                }, true);
                             }
+                            else {
+                                return buffered;
+                            }
+                        }
+                        // Compatible providers can answer a stream request with JSON or
+                        // an error body. Read those once while cancellation still owns
+                        // the socket; only SSE readers take ownership after this returns.
+                        if (!response.ok || !/text\/event-stream/i.test(response.headers.get('content-type') || '')) {
+                            return await this.bufferTransportResponse(response);
                         }
                         return response;
                     }
@@ -1220,7 +1225,7 @@ class LLMProvider {
                         if (!this.shouldUseNodeHttpFallback(error))
                             throw error;
                         const fallbackHeaders = { ...request.headers };
-                        delete fallbackHeaders['Accept'];
+                        fallbackHeaders.Accept = (0, provider_request_compat_1.providerRequestHeaders)(this.protocol(), this.apiKey).Accept;
                         const fallback = await this.postJsonWithFetchFallback(request.url, fallbackHeaders, { ...request.body, stream: false }, effectiveTimeout, signal);
                         return this.toTransportResponse(fallback);
                     }
@@ -1234,6 +1239,17 @@ class LLMProvider {
             return this.toTransportResponse(response);
         };
     }
+    async bufferTransportResponse(response) {
+        const body = await response.text();
+        return {
+            ok: response.ok,
+            status: response.status,
+            headers: response.headers,
+            body: null,
+            text: async () => body,
+            json: async () => JSON.parse(body),
+        };
+    }
     toTransportResponse(response) {
         if (response.body !== undefined) {
             return response;
@@ -1310,10 +1326,8 @@ class LLMProvider {
         throw new Error('LLMProvider legacy OpenAI streaming was removed in dev-0.3.0: enable provider_adapters_v2 (useProviderAdaptersV2).');
     }
     /**
-     * GitHub Models streaming path. Preserved as a dedicated implementation
-     * because the provider adapters (V2) do not serialize the GitHub Models
-     * inference URL or its X-GitHub-Api-Version headers. OpenAI protocol
-     * providers route exclusively through chatStreamWithToolsV2.
+     * GitHub Models keeps its dedicated URL, headers and request serialization.
+     * Response parsing shares the Chat adapter's completion validation.
      */
     async *githubModelsChatStreamWithTools(model, messages, systemPrompt, temperature, maxTokens, tools, signal) {
         const url = this.githubModelsUrl('/inference/chat/completions');
@@ -1329,191 +1343,30 @@ class LLMProvider {
             tool_choice: 'auto',
             stream: true,
         };
-        const abort = new AbortController();
-        const forwardAbort = () => abort.abort(signal?.reason);
-        if (signal?.aborted)
-            forwardAbort();
-        else
-            signal?.addEventListener('abort', forwardAbort, { once: true });
-        // Streaming provider responses are intentionally unbounded. Do not turn
-        // silence into an empty-response failure.
-        const effectiveTimeout = 0;
-        const timeout = effectiveTimeout > 0
-            ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout)
-            : undefined;
-        let reader = null;
-        try {
-            let response;
-            try {
-                response = await this.providerFetch(url, {
-                    method: 'POST',
-                    headers: this.openAIHeaders(),
-                    body: JSON.stringify(body),
-                    signal: abort.signal,
-                });
-            }
-            catch (e) {
-                if (signal?.aborted)
-                    throw abortFailure(signal);
-                if (abort.signal.aborted)
-                    throw abortFailure(abort.signal);
-                if (!this.shouldUseNodeHttpFallback(e))
-                    throw e;
-                clearTimeout(timeout);
-                yield* this.githubModelsChatNonStreaming(url, body, signal);
-                return;
+        // Keep GitHub's endpoint, headers and payload, while sharing the validated
+        // Chat Completions parser and fetch-to-node transport fallback.
+        const adapter = (0, providers_1.createProviderAdapter)(this.name, 'chat_completions');
+        const request = { url, headers: this.openAIHeaders(true), body };
+        let currentReasoningContent = '';
+        for await (const event of adapter.execute(request, signal || new AbortController().signal, this.buildProviderAdapterTransport())) {
+            if (event.type === 'reasoning.summary.delta') {
+                currentReasoningContent += event.delta;
+                yield { type: 'status', text: '', reasoningContent: currentReasoningContent };
             }
-            if (!response.ok) {
-                const err = await response.text();
-                yield { type: 'text', text: this.llmErrorText(response, err) };
-                return;
+            else if (event.type === 'text.delta') {
+                yield { type: 'text', text: event.delta, reasoningContent: currentReasoningContent || undefined };
             }
-            reader = response.body?.getReader() ?? null;
-            if (!reader) {
-                yield { type: 'text', text: '[Error] No response body' };
-                return;
+            else if (event.type === 'tool_call.completed') {
+                yield { type: 'tool_call', text: '', toolCall: { id: event.id, name: event.name, arguments: event.arguments }, reasoningContent: currentReasoningContent || undefined };
             }
-            const decoder = new TextDecoder();
-            let buffer = '';
-            const toolCalls = new Map();
-            const toolCallOrder = [];
-            let syntheticToolIndex = 0;
-            let lastToolIndex = 0;
-            let currentReasoningContent = '';
-            let contentPolicyBlocked = false;
-            let emittedContent = false;
-            let explicitCompletion = false;
-            const streamSignal = signal || new AbortController().signal;
-            while (true) {
-                const { done, value } = await (0, providers_1.readProviderStreamChunk)(reader, streamSignal);
-                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);
-                    if (data === '[DONE]') {
-                        explicitCompletion = true;
-                        continue;
-                    }
-                    try {
-                        const json = JSON.parse(data);
-                        if (json.usage)
-                            yield { type: 'usage', text: '', usage: (0, agentKernelDiagnostics_1.extractProviderUsage)(json) };
-                        if (this.contentPolicyBlocked(json))
-                            contentPolicyBlocked = true;
-                        const delta = json.choices?.[0]?.delta;
-                        if (!delta)
-                            continue;
-                        if (delta.reasoning_content) {
-                            currentReasoningContent += delta.reasoning_content;
-                            yield { type: 'status', text: '', reasoningContent: currentReasoningContent };
-                        }
-                        const deltaText = this.extractTextValue(delta.content);
-                        if (deltaText) {
-                            emittedContent = true;
-                            yield { type: 'text', text: deltaText, reasoningContent: currentReasoningContent || undefined };
-                        }
-                        if (delta.tool_calls) {
-                            for (const tc of delta.tool_calls) {
-                                const rawIndex = Number(tc.index);
-                                const index = Number.isInteger(rawIndex) && rawIndex >= 0
-                                    ? rawIndex
-                                    : (tc.id ? syntheticToolIndex++ : lastToolIndex);
-                                lastToolIndex = index;
-                                let call = toolCalls.get(index);
-                                if (!call && (tc.id || tc.function?.name)) {
-                                    call = { id: tc.id || '', name: tc.function?.name || '', argumentParts: [] };
-                                    toolCalls.set(index, call);
-                                    toolCallOrder.push(index);
-                                }
-                                if (!call)
-                                    continue;
-                                if (tc.id && !call.id)
-                                    call.id = tc.id;
-                                if (tc.function?.name && !call.name)
-                                    call.name = tc.function.name;
-                                if (tc.function?.arguments)
-                                    call.argumentParts.push(tc.function.arguments);
-                            }
-                        }
-                    }
-                    catch { /* skip malformed JSON */ }
-                }
-            }
-            if (toolCallOrder.length) {
-                for (const index of toolCallOrder) {
-                    const call = toolCalls.get(index);
-                    if (!call)
-                        continue;
-                    yield {
-                        type: 'tool_call',
-                        text: '',
-                        toolCall: {
-                            id: call.id,
-                            name: call.name,
-                            arguments: (0, providers_1.assembleCompatibleToolArguments)(call.argumentParts),
-                        },
-                        reasoningContent: currentReasoningContent || undefined,
-                    };
-                }
-            }
-            else if (!emittedContent && contentPolicyBlocked) {
-                yield { type: 'text', text: '[Error] Content policy refusal (content_filter).' };
+            else if (event.type === 'usage.updated') {
+                yield { type: 'usage', text: '', usage: this.toStreamUsage(event.usage) };
             }
-            else if (!explicitCompletion && !emittedContent && !currentReasoningContent) {
-                yield { type: 'text', text: '[LLM Error] GitHub Models stream ended before an explicit completion.' };
+            else if (event.type === 'response.failed') {
+                yield { type: 'text', text: event.error, providerError: true };
+                return;
             }
         }
-        finally {
-            reader?.releaseLock();
-            clearTimeout(timeout);
-            signal?.removeEventListener('abort', forwardAbort);
-        }
-    }
-    /**
-     * GitHub Models non-streaming fallback used when the streaming fetch fails
-     * and the node-http transport is available. Mirrors the legacy chat-tools
-     * node fallback; the responses downgrade is intentionally not applied for
-     * GitHub Models (its inference endpoint is chat-completions only).
-     */
-    async *githubModelsChatNonStreaming(url, streamingBody, signal) {
-        const body = { ...streamingBody, stream: false };
-        const response = await this.postJsonWithFetchFallback(url, this.openAIHeaders(), body, 120000, signal);
-        if (!response.ok) {
-            const err = await response.text();
-            yield { type: 'text', text: this.llmErrorText(response, err) };
-            return;
-        }
-        const json = await response.json();
-        yield { type: 'usage', text: '', usage: (0, agentKernelDiagnostics_1.extractProviderUsage)(json) };
-        const choice = json?.choices?.[0];
-        const message = choice?.message || {};
-        if (message.reasoning_content) {
-            yield { type: 'status', text: '', reasoningContent: String(message.reasoning_content) };
-        }
-        const messageText = this.extractTextValue(message.content) || this.extractTextValue(choice?.text);
-        if (messageText) {
-            yield { type: 'text', text: messageText, reasoningContent: message.reasoning_content ? String(message.reasoning_content) : undefined };
-        }
-        for (const tc of message.tool_calls || []) {
-            yield {
-                type: 'tool_call',
-                text: '',
-                toolCall: {
-                    id: String(tc.id || ''),
-                    name: String(tc.function?.name || ''),
-                    arguments: String(tc.function?.arguments || '{}'),
-                },
-            };
-        }
-        if (!messageText && !(message.tool_calls || []).length && this.contentPolicyBlocked(json)) {
-            yield { type: 'text', text: '[Error] Content policy refusal (content_filter).' };
-        }
     }
     async *anthropicChatWithTools(model, messages, systemPrompt, temperature, maxTokens, tools, signal) {
         const { system, messages: anthropicMessages } = this.anthropicMessages(messages, systemPrompt);
@@ -1528,20 +1381,21 @@ class LLMProvider {
         const convertedTools = this.anthropicTools(tools);
         if (convertedTools.length)
             body.tools = convertedTools;
-        const response = await this.providerFetch(`${this.cleanBaseUrl()}/messages`, {
-            method: 'POST',
-            headers: this.anthropicHeaders(),
-            body: JSON.stringify(body),
-            signal,
-        });
+        // A Build reuses its cancellation signal across many tool turns. Keep the
+        // native JSON exchange request-local so completed fetches cannot accumulate
+        // their abort followers on that long-lived signal until a later GC.
+        const response = await this.postJsonOnce((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/messages'), this.anthropicHeaders(), body, 0, signal);
         if (!response.ok) {
             const err = await response.text();
             yield { type: 'text', text: this.llmErrorText(response, err) };
             return;
         }
         const json = await response.json();
-        yield { type: 'usage', text: '', usage: (0, agentKernelDiagnostics_1.extractProviderUsage)(json) };
-        for (const block of json.content || []) {
+        yield { type: 'usage', text: '', usage: (0, agentKernelDiagnostics_1.extractProviderUsage)(json, { protocol: 'anthropic' }) };
+        const blocks = Array.isArray(json.content) ? json.content : [];
+        const completeCalls = blocks.filter(block => block.type === 'tool_use');
+        const failure = this.nativeJsonCompletionError(json, 'anthropic');
+        for (const block of blocks) {
             const type = String(block.type || '');
             if (type === 'text' && block.text) {
                 const text = this.extractTextValue(block.text);
@@ -1551,18 +1405,37 @@ class LLMProvider {
             else if (type === 'thinking' && block.thinking) {
                 yield { type: 'status', text: '', reasoningContent: String(block.thinking) };
             }
-            else if (type === 'tool_use') {
-                yield {
-                    type: 'tool_call',
-                    text: '',
-                    toolCall: {
-                        id: String(block.id || ''),
-                        name: String(block.name || ''),
-                        arguments: JSON.stringify(block.input || {}),
-                    },
-                };
-            }
         }
+        if (failure) {
+            yield { type: 'text', text: failure };
+            return;
+        }
+        if (completeCalls.some(block => !block.id || !block.name || !block.input || typeof block.input !== 'object' || Array.isArray(block.input))) {
+            yield { type: 'text', text: '[LLM Error] Provider returned incomplete or invalid tool-call arguments.', providerError: true };
+            return;
+        }
+        for (const block of completeCalls) {
+            yield { type: 'tool_call', text: '', toolCall: {
+                    id: String(block.id), name: String(block.name), arguments: JSON.stringify(block.input),
+                } };
+        }
+    }
+    nativeJsonCompletionError(json, protocol) {
+        if (json.error || json.type === 'error') {
+            const error = json.error && typeof json.error === 'object' ? json.error : {};
+            return '[LLM Error] ' + (this.extractTextValue(error.message || error.type || json.error) || 'Provider returned an error response.');
+        }
+        const choice = Array.isArray(json.choices) ? json.choices[0] : undefined;
+        const reason = protocol === 'anthropic' ? json.stop_reason : choice?.finish_reason;
+        if (reason === 'max_tokens' || reason === 'length')
+            return '[LLM Error] Provider response was truncated by the output token limit.';
+        if (reason === 'content_filter')
+            return '[Error] Content policy refusal (content_filter).';
+        if (protocol === 'responses' && json.status && json.status !== 'completed') {
+            const details = json.incomplete_details && typeof json.incomplete_details === 'object' ? json.incomplete_details : {};
+            return `[LLM Error] Responses response was ${json.status}${details.reason ? ': ' + details.reason : ''}.`;
+        }
+        return '';
     }
     /**
      * Deterministic capability probe that sends the schema through the native
@@ -1584,7 +1457,7 @@ class LLMProvider {
             };
             if (system)
                 body.system = system;
-            const response = await this.postJsonWithFetchFallback(`${this.cleanBaseUrl()}/messages`, this.anthropicHeaders(), body, 120000, signal);
+            const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/messages'), this.anthropicHeaders(), body, 120000, signal);
             if (!response.ok)
                 throw new Error(this.llmErrorText(response, await response.text()));
             const json = await response.json();
@@ -1598,7 +1471,7 @@ class LLMProvider {
             body.text = {
                 format: { type: 'json_schema', name: schemaName, strict: true, schema },
             };
-            const response = await this.postJsonWithFetchFallback(`${this.cleanBaseUrl()}/responses`, this.openAIHeaders(), body, 120000, signal);
+            const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/responses'), this.openAIHeaders(), body, 120000, signal);
             if (!response.ok)
                 throw new Error(this.llmErrorText(response, await response.text()));
             return this.extractResponsesText(this.normalizeResponsesPayload(await response.json()));
@@ -1606,7 +1479,7 @@ class LLMProvider {
         const isGitHubModels = this.protocol() === 'github_models';
         const url = isGitHubModels
             ? this.githubModelsUrl('/inference/chat/completions')
-            : `${this.cleanBaseUrl()}/chat/completions`;
+            : (0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/chat/completions');
         const body = {
             model,
             messages: [
@@ -1644,8 +1517,8 @@ class LLMProvider {
             let family;
             if (this.protocol() === 'anthropic') {
                 const prepared = this.anthropicMessages(messages, systemPrompt);
-                url = `${this.cleanBaseUrl()}/messages`;
-                headers = this.anthropicHeaders();
+                url = (0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/messages');
+                headers = this.anthropicHeaders(true);
                 body = {
                     model,
                     messages: prepared.messages,
@@ -1658,8 +1531,8 @@ class LLMProvider {
                 family = 'anthropic';
             }
             else if (this.protocol() !== 'github_models' && this.openAITransportMode() === 'responses') {
-                url = `${this.cleanBaseUrl()}/responses`;
-                headers = this.openAIHeaders();
+                url = (0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/responses');
+                headers = this.openAIHeaders(true);
                 body = { ...this.responsesBody(model, messages, systemPrompt, temperature, maxTokens), stream: true };
                 family = 'openai_responses';
             }
@@ -1667,8 +1540,8 @@ class LLMProvider {
                 const isGitHubModels = this.protocol() === 'github_models';
                 url = isGitHubModels
                     ? this.githubModelsUrl('/inference/chat/completions')
-                    : `${this.cleanBaseUrl()}/chat/completions`;
-                headers = isGitHubModels ? this.githubModelsHeaders() : this.openAIHeaders();
+                    : (0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/chat/completions');
+                headers = isGitHubModels ? this.githubModelsHeaders(true) : this.openAIHeaders(true);
                 body = {
                     model,
                     messages: [
@@ -1736,7 +1609,7 @@ class LLMProvider {
             signal?.removeEventListener('abort', forwardAbort);
         }
     }
-    async chat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier) {
+    async chat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier, onUsage) {
         if (this.protocol() === 'anthropic') {
             const { system, messages: anthropicMessages } = this.anthropicMessages(messages, systemPrompt);
             const body = {
@@ -1747,11 +1620,15 @@ class LLMProvider {
             };
             if (system)
                 body.system = system;
-            const response = await this.postJsonWithFetchFallback(`${this.cleanBaseUrl()}/messages`, this.anthropicHeaders(), body, 120000, signal);
+            const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/messages'), this.anthropicHeaders(), body, 120000, signal);
             if (!response.ok) {
                 throw new Error(this.llmErrorText(response, await response.text()));
             }
             const json = await response.json();
+            onUsage?.((0, agentKernelDiagnostics_1.extractProviderUsage)(json, { protocol: 'anthropic' }));
+            const failure = this.nativeJsonCompletionError(json, 'anthropic');
+            if (failure)
+                throw new Error(failure);
             return (json.content || [])
                 .filter(block => block.type === 'text' && block.text)
                 .map(block => this.extractTextValue(block.text))
@@ -1760,7 +1637,7 @@ class LLMProvider {
         const isGitHubModels = this.protocol() === 'github_models';
         const url = isGitHubModels
             ? this.githubModelsUrl('/inference/chat/completions')
-            : `${this.cleanBaseUrl()}/chat/completions`;
+            : (0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/chat/completions');
         const body = {
             model,
             messages: [
@@ -1773,17 +1650,21 @@ class LLMProvider {
         if (!isGitHubModels)
             this.applyChatReasoningEffort(body, model, reasoningTier);
         if (!isGitHubModels && this.openAITransportMode() === 'responses') {
-            return await this.openAIResponsesChat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier);
+            return await this.openAIResponsesChat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier, onUsage);
         }
         const response = await this.postJsonWithFetchFallback(url, this.openAIHeaders(), body, 120000, signal);
         if (!response.ok) {
             const err = await response.text();
             if (!isGitHubModels && this.shouldUseResponsesFallback(response.status, err)) {
-                return await this.openAIResponsesChat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier);
+                return await this.openAIResponsesChat(model, messages, systemPrompt, temperature, maxTokens, signal, reasoningTier, onUsage);
             }
             throw new Error(this.llmErrorText(response, err));
         }
         const json = await response.json();
+        onUsage?.((0, agentKernelDiagnostics_1.extractProviderUsage)(json));
+        const failure = this.nativeJsonCompletionError(json, 'chat');
+        if (failure)
+            throw new Error(failure);
         return this.extractChatCompletionText(json);
     }
     async modelCatalog() {
@@ -1801,7 +1682,7 @@ class LLMProvider {
                 raw: typeof entry === 'string' ? { id: entry } : entry,
             })).filter((entry, index, all) => !!entry.id && all.findIndex(candidate => candidate.id === entry.id) === index);
         }
-        const response = await this.getJsonWithFetchFallback(`${this.cleanBaseUrl()}/models`, this.protocol() === 'anthropic' ? this.anthropicHeaders() : { 'Authorization': `Bearer ${this.apiKey}` });
+        const response = await this.getJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/models'), this.protocol() === 'anthropic' ? this.anthropicHeaders() : this.openAIHeaders());
         if (!response.ok) {
             throw new Error(`Model list error: ${response.status} ${await response.text()}`);
         }
@@ -1849,7 +1730,7 @@ class LLMProvider {
             return { ok: false, latency: 0 };
         const start = Date.now();
         try {
-            const response = await this.postJsonWithFetchFallback(`${this.cleanBaseUrl()}/images/generations`, this.openAIHeaders(), {
+            const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/images/generations'), this.openAIHeaders(), {
                 model,
                 prompt: 'A single solid blue square on a white background.',
                 size: '256x256',
@@ -1870,7 +1751,7 @@ class LLMProvider {
     async generateImage(model, prompt, size = '1024x1024', signal) {
         if (this.protocol() !== 'openai')
             throw new Error('Image generation requires an OpenAI-compatible provider.');
-        const response = await this.postJsonWithFetchFallback(`${this.cleanBaseUrl()}/images/generations`, this.openAIHeaders(), {
+        const response = await this.postJsonWithFetchFallback((0, provider_request_compat_1.providerEndpoint)(this.cleanBaseUrl(), '/images/generations'), this.openAIHeaders(), {
             model,
             prompt,
             size,