@phuetz/code-buddy 1.6.0 → 2.0.0

package/dist/codebuddy/providers/provider-gemini-native.js

@@ -20,6 +20,58 @@ import { logger } from '../../utils/logger.js';
 import { retry, RetryStrategies, RetryPredicates } from '../../utils/retry.js';
 import { getCircuitBreaker } from '../../providers/circuit-breaker.js';
 import { parseRateLimitHeaders, storeRateLimitInfo } from '../../utils/rate-limit-display.js';
+/**
+ * Link a caller cancellation to one Gemini fetch while retaining the provider's
+ * existing per-request timeout. The parent listener deliberately remains live
+ * until the response body is consumed; `fetch()` resolving only means headers
+ * arrived, not that `response.json()` or an SSE stream has finished.
+ */
+function createLinkedRequestAbortControl(parent, timeoutMs) {
+    const controller = new AbortController();
+    let timeout;
+    let disposed = false;
+    const onParentAbort = () => {
+        if (!controller.signal.aborted)
+            controller.abort(parent?.reason);
+    };
+    if (parent?.aborted)
+        onParentAbort();
+    else
+        parent?.addEventListener('abort', onParentAbort, { once: true });
+    if (!controller.signal.aborted) {
+        timeout = setTimeout(() => {
+            if (!controller.signal.aborted) {
+                controller.abort(new DOMException('Gemini request timed out', 'TimeoutError'));
+            }
+        }, timeoutMs);
+        timeout.unref?.();
+    }
+    const clearRequestTimeout = () => {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = undefined;
+    };
+    return {
+        signal: controller.signal,
+        clearTimeout: clearRequestTimeout,
+        dispose: (abortActive = false) => {
+            if (disposed)
+                return;
+            disposed = true;
+            clearRequestTimeout();
+            parent?.removeEventListener('abort', onParentAbort);
+            if (abortActive && !controller.signal.aborted)
+                controller.abort();
+        },
+    };
+}
+function abortErrorForSignal(signal) {
+    if (signal.reason instanceof Error)
+        return signal.reason;
+    const error = new Error('Gemini request aborted');
+    error.name = 'AbortError';
+    return error;
+}
 export class GeminiNativeProvider {
     apiKey;
     baseURL;
@@ -64,6 +116,11 @@ export class GeminiNativeProvider {
     /**
      * Gemini type mapping: lowercase OpenAI types to uppercase Gemini types
      */
+    /** JSON-Schema keywords rejected by Gemini's OpenAPI-subset parameter schema. */
+    static GEMINI_UNSUPPORTED_SCHEMA_KEYS = [
+        'additionalProperties', 'patternProperties', 'unevaluatedProperties', '$schema', '$id', '$ref',
+        'definitions', '$defs', 'default', 'examples', 'title', 'const', 'contentMediaType',
+    ];
     static GEMINI_TYPE_MAP = {
         'string': 'STRING',
         'number': 'NUMBER',
@@ -98,7 +155,8 @@ export class GeminiNativeProvider {
         for (const msg of messages) {
             if (msg.role === 'system') {
                 // Gemini uses systemInstruction instead of system message
-                systemInstruction = { parts: [{ text: String(msg.content) }] };
+                systemInstruction ??= { parts: [] };
+                systemInstruction.parts.push({ text: String(msg.content) });
             }
             else if (msg.role === 'user') {
                 const parts = this.convertContentToGeminiParts(msg.content);
@@ -125,6 +183,10 @@ export class GeminiNativeProvider {
                                 name: tc.function.name,
                                 args,
                             },
+                            // Gemini 3.x validates a thoughtSignature on every echoed functionCall; when the
+                            // call was not produced by Gemini (other provider, injected, compacted away) the
+                            // documented escape hatch skips the validator instead of failing the whole turn.
+                            thoughtSignature: tc.thoughtSignature ?? 'skip_thought_signature_validator',
                         });
                     }
                     contents.push({ role: 'model', parts: parts });
@@ -214,6 +276,13 @@ export class GeminiNativeProvider {
         if (merged.length > 0 && merged[0]?.role !== 'user') {
             merged.unshift({ role: 'user', parts: [{ text: '(continuing previous conversation)' }] });
         }
+        // Pass 4: the current Gemini API rejects role 'function' (« Role 'function' is not supported »,
+        // 2026-09-06). Function responses travel as `functionResponse` parts inside a 'user' turn; the
+        // internal 'function' role above only served the ordering checks.
+        for (const entry of merged) {
+            if (entry.role === 'function')
+                entry.role = 'user';
+        }
         // Build request body
         // Build generationConfig with optional thinkingConfig for Gemini 3.x
         const generationConfig = {
@@ -326,41 +395,51 @@ export class GeminiNativeProvider {
                 toolCount: tools?.length || 0,
             });
             let response;
+            let responseAbortControl;
             try {
                 // Make request with retry, optionally guarded by the circuit breaker.
                 response = await this.withCircuitBreaker(opts?.circuitBreaker, () => retry(async () => {
-                    const controller = new AbortController();
-                    const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
-                    let res;
+                    const control = createLinkedRequestAbortControl(opts?.signal, requestTimeoutMs);
                     try {
-                        res = await fetch(url, {
+                        if (opts?.signal?.aborted)
+                            throw abortErrorForSignal(opts.signal);
+                        const res = await fetch(url, {
                             method: 'POST',
                             headers: {
                                 'Content-Type': 'application/json',
                                 'x-goog-api-key': this.apiKey,
                             },
                             body: JSON.stringify(body),
-                            signal: controller.signal,
+                            signal: control.signal,
                         });
+                        // Preserve the previous timeout semantics (headers/connect), but
+                        // keep caller cancellation linked through body consumption.
+                        control.clearTimeout();
+                        if (!res.ok) {
+                            const errorText = await res.text();
+                            logger.error('Gemini API error', {
+                                source: 'GeminiNativeProvider',
+                                status: res.status,
+                                statusText: res.statusText,
+                                errorBody: errorText?.substring(0, 500),
+                            });
+                            // Audit 2026-09-02 (D8) : sans `.status`, RetryPredicates.llmApiError
+                            // ne reconnaît jamais un 429/5xx Gemini — aucun retry/backoff.
+                            const httpError = new Error(`${res.status} ${errorText || res.statusText}`);
+                            httpError.status = res.status;
+                            throw httpError;
+                        }
+                        responseAbortControl = control;
+                        return res;
                     }
-                    finally {
-                        clearTimeout(timeoutId);
-                    }
-                    if (!res.ok) {
-                        const errorText = await res.text();
-                        logger.error('Gemini API error', {
-                            source: 'GeminiNativeProvider',
-                            status: res.status,
-                            statusText: res.statusText,
-                            errorBody: errorText?.substring(0, 500),
-                        });
-                        throw new Error(`${res.status} ${errorText || res.statusText}`);
+                    catch (error) {
+                        control.dispose(true);
+                        throw error;
                     }
-                    return res;
                 }, {
                     ...RetryStrategies.llmApi,
                     timeout: requestTimeoutMs * 2,
-                    isRetryable: RetryPredicates.llmApiError,
+                    isRetryable: error => !opts?.signal?.aborted && RetryPredicates.llmApiError(error),
                     onRetry: (error, attempt, delay) => {
                         logger.warn(`Gemini API call failed, retrying (attempt ${attempt}) in ${delay}ms...`, {
                             source: 'GeminiNativeProvider',
@@ -371,6 +450,9 @@ export class GeminiNativeProvider {
                 }));
             }
             catch (error) {
+                responseAbortControl?.dispose(true);
+                if (opts?.signal?.aborted)
+                    throw abortErrorForSignal(opts.signal);
                 const message = error instanceof Error ? error.message : String(error);
                 const looksLikeModel404 = message.includes('404') &&
                     message.includes('models/') &&
@@ -405,7 +487,14 @@ export class GeminiNativeProvider {
             catch {
                 /* rate-limit telemetry is best-effort */
             }
-            const data = await response.json();
+            const data = await (async () => {
+                try {
+                    return await response.json();
+                }
+                finally {
+                    responseAbortControl?.dispose();
+                }
+            })();
             // Convert response to CodeBuddy format
             const candidate = data.candidates?.[0];
             // Handle MALFORMED_FUNCTION_CALL: Gemini sometimes generates Python-style
@@ -424,21 +513,7 @@ export class GeminiNativeProvider {
                     };
                     return await this.chat([...messagesPayload, recoverySystemMessage], tools, { ...opts, geminiMalformedRetryCount: malformedRetryCount + 1 });
                 }
-                return {
-                    choices: [{
-                            message: {
-                                role: 'assistant',
-                                content: 'I generated a malformed function call. Let me retry with the correct tool format. I need to use proper JSON arguments, not Python syntax.',
-                                tool_calls: undefined,
-                            },
-                            finish_reason: 'stop',
-                        }],
-                    usage: {
-                        prompt_tokens: data.usageMetadata?.promptTokenCount ?? 0,
-                        completion_tokens: 0,
-                        total_tokens: data.usageMetadata?.totalTokenCount ?? 0,
-                    },
-                };
+                throw new Error('Gemini malformed function call retries exhausted');
             }
             if (!candidate || !candidate.content) {
                 logger.error('Gemini response missing candidate or content', {
@@ -451,26 +526,11 @@ export class GeminiNativeProvider {
             }
             // Handle empty content (Gemini may return content without parts for certain queries)
             if (!candidate.content.parts || candidate.content.parts.length === 0) {
-                logger.warn('Gemini returned empty content parts', {
+                logger.error('Gemini returned empty content parts', {
                     source: 'GeminiNativeProvider',
                     finishReason: candidate.finishReason,
                 });
-                // Return a graceful response instead of throwing
-                return {
-                    choices: [{
-                            message: {
-                                role: 'assistant',
-                                content: "Je ne peux pas répondre à cette question. Il s'agit peut-être d'une requête nécessitant des données en temps réel (météo, actualités) auxquelles je n'ai pas accès, ou d'une question que le modèle ne peut pas traiter.",
-                                tool_calls: undefined,
-                            },
-                            finish_reason: candidate.finishReason || 'stop',
-                        }],
-                    usage: {
-                        prompt_tokens: data.usageMetadata?.promptTokenCount ?? 0,
-                        completion_tokens: 0,
-                        total_tokens: data.usageMetadata?.totalTokenCount ?? 0,
-                    },
-                };
+                throw new Error('Gemini returned empty content parts');
             }
             const toolCalls = [];
             let content = '';
@@ -487,6 +547,9 @@ export class GeminiNativeProvider {
                             arguments: JSON.stringify(part.functionCall.args),
                         },
                     };
+                    const sig = part.thoughtSignature;
+                    if (typeof sig === 'string' && sig)
+                        toolCall.thoughtSignature = sig;
                     toolCalls.push(toolCall);
                     logger.debug('Gemini tool call extracted', {
                         source: 'GeminiNativeProvider',
@@ -587,6 +650,13 @@ export class GeminiNativeProvider {
             return schema;
         }
         const result = { ...schema };
+        // Gemini's function_declarations accept an OpenAPI subset: JSON-Schema-only keywords make the
+        // whole request fail with 400 « Unknown name "additionalProperties" » (seen 2026-09-06 on the
+        // Telegram companion). Drop them here so every tool definition stays usable on this provider.
+        for (const key of GeminiNativeProvider.GEMINI_UNSUPPORTED_SCHEMA_KEYS) {
+            if (key in result)
+                delete result[key];
+        }
         // Convert lowercase type to uppercase for Gemini
         if (typeof result.type === 'string') {
             const upperType = GeminiNativeProvider.GEMINI_TYPE_MAP[result.type.toLowerCase()];
@@ -652,7 +722,12 @@ export class GeminiNativeProvider {
                         yield JSON.parse(jsonStr);
                     }
                     catch {
-                        // Skip malformed JSON lines
+                        // Audit 2026-09-02 (D2) : ne plus jeter une ligne en silence — le
+                        // trou dans la réponse était invisible, même en debug.
+                        logger.warn('Gemini SSE: malformed data line dropped (possible content gap)', {
+                            source: 'GeminiNativeProvider',
+                            linePreview: jsonStr.slice(0, 120),
+                        });
                     }
                 }
             }
@@ -665,7 +740,10 @@ export class GeminiNativeProvider {
                     yield JSON.parse(jsonStr);
                 }
                 catch {
-                    // Skip malformed JSON
+                    logger.warn('Gemini SSE: malformed trailing data dropped (possible content gap)', {
+                        source: 'GeminiNativeProvider',
+                        linePreview: jsonStr.slice(0, 120),
+                    });
                 }
             }
         }
@@ -677,11 +755,18 @@ export class GeminiNativeProvider {
         const model = opts?.model || this.currentModel;
         const streamUrl = `${this.baseURL}/models/${model}:streamGenerateContent?alt=sse`;
         const requestTimeoutMs = opts?.timeoutMs && opts.timeoutMs >= 1000 ? opts.timeoutMs : this.geminiRequestTimeoutMs;
+        const requestControl = createLinkedRequestAbortControl(opts?.signal, requestTimeoutMs);
+        // Audit 2026-09-02 (D3/D1) : suivre ce qui a déjà été émis pour ne jamais
+        // rejouer la requête après émission (duplication silencieuse), et signaler
+        // une fin de stream sans finishReason (troncature possible).
+        let emittedChunks = 0;
+        let sawFinishReason = false;
+        let terminalFinishReason;
         try {
+            if (opts?.signal?.aborted)
+                throw abortErrorForSignal(opts.signal);
             // Build the same request body as chat
             const body = this.buildGeminiBody(messages, tools, opts);
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
             let res;
             try {
                 res = await this.withCircuitBreaker(opts?.circuitBreaker, () => fetch(streamUrl, {
@@ -691,11 +776,13 @@ export class GeminiNativeProvider {
                         'x-goog-api-key': this.apiKey,
                     },
                     body: JSON.stringify(body),
-                    signal: controller.signal,
+                    signal: requestControl.signal,
                 }));
             }
             finally {
-                clearTimeout(timeoutId);
+                // The provider timeout guards connection/headers as before. The parent
+                // signal remains linked until the SSE reader is fully consumed.
+                requestControl.clearTimeout();
             }
             if (!res.ok) {
                 // Fallback to non-streaming on error
@@ -703,10 +790,12 @@ export class GeminiNativeProvider {
                     source: 'GeminiNativeProvider',
                     status: res.status,
                 });
+                requestControl.dispose(true);
                 yield* this.geminiChatStreamFallback(messages, tools, opts);
                 return;
             }
             if (!res.body) {
+                requestControl.dispose(true);
                 yield* this.geminiChatStreamFallback(messages, tools, opts);
                 return;
             }
@@ -722,16 +811,32 @@ export class GeminiNativeProvider {
                     continue;
                 // Grounding metadata typically arrives in the final chunk of the
                 // stream — keep the latest non-empty payload around so we can
-                // emit the "Sources:" footer right before the stop chunk.
+                // emit the "Sources:" footer right before the terminal chunk.
                 if (candidate.groundingMetadata) {
                     lastGroundingMetadata = candidate.groundingMetadata;
                 }
                 const content = candidate.content;
+                const finishReason = candidate.finishReason;
+                if (finishReason) {
+                    sawFinishReason = true;
+                    // Keep one terminal reason for the final chunk. In particular, do
+                    // not emit length/content_filter and then overwrite it with stop.
+                    if (terminalFinishReason === undefined) {
+                        const finishMap = {
+                            'STOP': 'stop',
+                            'MAX_TOKENS': 'length',
+                            'SAFETY': 'content_filter',
+                            'RECITATION': 'content_filter',
+                        };
+                        terminalFinishReason = finishMap[finishReason] || 'stop';
+                    }
+                }
                 const parts = content?.parts;
                 if (!parts)
                     continue;
                 for (const part of parts) {
                     if (part.text) {
+                        emittedChunks++;
                         yield {
                             id: `chatcmpl-gemini-${Date.now()}-${chunkIndex++}`,
                             object: 'chat.completion.chunk',
@@ -749,6 +854,8 @@ export class GeminiNativeProvider {
                     }
                     if (part.functionCall) {
                         const fc = part.functionCall;
+                        const streamSig = part.thoughtSignature;
+                        emittedChunks++;
                         yield {
                             id: `chatcmpl-gemini-${Date.now()}-${chunkIndex++}`,
                             object: 'chat.completion.chunk',
@@ -765,6 +872,7 @@ export class GeminiNativeProvider {
                                                     name: fc.name,
                                                     arguments: JSON.stringify(fc.args || {}),
                                                 },
+                                                ...(typeof streamSig === 'string' && streamSig ? { thoughtSignature: streamSig } : {}),
                                             }],
                                     },
                                     finish_reason: null,
@@ -772,31 +880,8 @@ export class GeminiNativeProvider {
                         };
                     }
                 }
-                // Check for finish reason
-                const finishReason = candidate.finishReason;
-                if (finishReason && finishReason !== 'STOP') {
-                    // Map Gemini finish reasons to OpenAI format
-                    const finishMap = {
-                        'STOP': 'stop',
-                        'MAX_TOKENS': 'length',
-                        'SAFETY': 'content_filter',
-                        'RECITATION': 'content_filter',
-                    };
-                    const mappedReason = finishMap[finishReason] || 'stop';
-                    yield {
-                        id: `chatcmpl-gemini-${Date.now()}-${chunkIndex++}`,
-                        object: 'chat.completion.chunk',
-                        created: Math.floor(Date.now() / 1000),
-                        model,
-                        choices: [{
-                                index: 0,
-                                delta: {},
-                                finish_reason: mappedReason,
-                            }],
-                    };
-                }
             }
-            // Emit the Sources footer (if any) BEFORE the final stop chunk so
+            // Emit the Sources footer (if any) BEFORE the final terminal chunk so
             // it lands in the assistant content rather than after finish_reason.
             const groundingFooter = GeminiNativeProvider.formatGroundingFooter(lastGroundingMetadata);
             if (groundingFooter) {
@@ -815,7 +900,16 @@ export class GeminiNativeProvider {
                         }],
                 };
             }
-            // Final stop chunk
+            // Audit 2026-09-02 (D1) : un stream fermé par le serveur sans aucun
+            // finishReason est très probablement tronqué — on termine quand même en
+            // 'stop' (compat consommateurs) mais on le dit au lieu de se taire.
+            if (!sawFinishReason) {
+                logger.warn('Gemini stream ended without a finishReason — response may be truncated', {
+                    source: 'GeminiNativeProvider',
+                    emittedChunks,
+                });
+            }
+            // Final terminal chunk
             yield {
                 id: `chatcmpl-gemini-${Date.now()}-${chunkIndex}`,
                 object: 'chat.completion.chunk',
@@ -824,17 +918,36 @@ export class GeminiNativeProvider {
                 choices: [{
                         index: 0,
                         delta: {},
-                        finish_reason: 'stop',
+                        finish_reason: terminalFinishReason ?? 'stop',
                     }],
             };
         }
         catch (error) {
+            requestControl.dispose(true);
+            if (opts?.signal?.aborted)
+                throw abortErrorForSignal(opts.signal);
+            // Audit 2026-09-02 (D3) : après émission, le repli non-stream rejouerait
+            // TOUTE la réponse à la suite du préfixe déjà livré — contenu dupliqué
+            // présenté comme une seule réponse, et requête facturée deux fois. On ne
+            // replie que si rien n'a été émis ; sinon l'erreur remonte au client.
+            if (emittedChunks > 0) {
+                logger.warn('Gemini stream failed after chunks were emitted — propagating (no non-stream fallback, it would duplicate content)', {
+                    source: 'GeminiNativeProvider',
+                    emittedChunks,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
             logger.warn('Gemini streaming error, falling back to non-streaming', {
                 source: 'GeminiNativeProvider',
                 error: error instanceof Error ? error.message : String(error),
             });
             yield* this.geminiChatStreamFallback(messages, tools, opts);
         }
+        finally {
+            // Also cancels an unread body when a consumer stops iterating early.
+            requestControl.dispose(true);
+        }
     }
     /**
      * Fallback: non-streaming Gemini call emitted as synthetic chunks

package/dist/codebuddy/providers/provider-openai-compat.d.ts

@@ -35,6 +35,38 @@ export interface OpenAICompatProviderOptions {
      */
     getCircuitBreakerConfig: () => Partial<CircuitBreakerConfig> | undefined;
 }
+/**
+ * Extra HTTP headers applied to every OpenAI-compat LLM API call, for
+ * API gateways and observability proxies (Helicone, Portkey, LiteLLM, corp
+ * proxies with header-based auth).
+ *
+ * Source: `CODEBUDDY_LLM_EXTRA_HEADERS` — a JSON object of string values,
+ * e.g. `{"Helicone-Auth": "Bearer sk-...", "X-Proxy-Tag": "codebuddy"}`.
+ * Transport-managed headers are dropped (warned once); invalid JSON or a
+ * non-object disables the feature with a warning rather than failing chat.
+ */
+export declare function resolveLlmExtraHeaders(raw?: string | undefined): Record<string, string> | undefined;
+/**
+ * Normalize a message list so it carries **exactly one `system` message, in
+ * position 0** — required by strict chat templates (e.g. Qwen3's Jinja template
+ * raises `System message must be at the beginning` on any later/second system
+ * message; Ollama then returns HTTP 400 "Unable to generate parser").
+ *
+ * Code Buddy legitimately emits several `system` messages per turn: the base
+ * system prompt (front) plus per-turn context injections appended AFTER the
+ * conversation (`<lessons_context>`, `<todo_context>`, mention/middleware/
+ * companion context blocks — see agent-executor). Public cloud providers accept
+ * that ordering; strict local templates do not.
+ *
+ * The transform merges every `system` content, in original order, into a single
+ * leading system message and keeps all non-system messages in their original
+ * relative order. It is a no-op (returns the same array reference) when the list
+ * already has at most one system message and it is already at index 0, so
+ * runtimes that tolerate the current ordering are byte-identical.
+ *
+ * Exported for unit testing.
+ */
+export declare function mergeSystemMessagesToFront(messages: CodeBuddyMessage[]): CodeBuddyMessage[];
 export declare class OpenAICompatProvider implements Provider {
     private client;
     private apiKey;
@@ -45,6 +77,7 @@ export declare class OpenAICompatProvider implements Provider {
     private toolSupportProbed;
     private toolSupportDetected;
     private probePromise;
+    private probeGeneration;
     private _promptCacheHits;
     private _promptCacheMisses;
     /**
@@ -61,6 +94,14 @@ export declare class OpenAICompatProvider implements Provider {
     private setListProviderOption;
     private readBooleanEnv;
     private readEnv;
+    /**
+     * Qwen reasoning models served by Lemonade enable hidden thinking by
+     * default. That is useful for deep work but disastrous for a conversational
+     * fast path: a short answer can spend tens of seconds in reasoning before
+     * emitting visible text. Disable it by default on Lemonade; an operator can
+     * opt back in for deliberate jobs with CODEBUDDY_LEMONADE_THINKING=1.
+     */
+    private getLemonadeChatTemplateKwargs;
     /**
      * Get prompt cache statistics
      */
@@ -76,6 +117,7 @@ export declare class OpenAICompatProvider implements Provider {
      * Promise-based locking prevents concurrent probes (single API request).
      */
     probeToolSupport(): Promise<boolean>;
+    private cacheToolSupport;
     private performToolProbe;
     private modelSupportsFunctionCalling;
     /**
@@ -86,11 +128,49 @@ export declare class OpenAICompatProvider implements Provider {
     private isLocalInference;
     /** xAI no longer accepts legacy search_parameters payloads. */
     private isXaiProvider;
+    /**
+     * Whether the target is a **local inference runtime** whose chat template may
+     * be strict about system-message placement (Ollama, LM Studio, vLLM). These
+     * embed the model's own Jinja template, so a second/late `system` message
+     * hard-fails (Qwen3: "System message must be at the beginning" → HTTP 400).
+     *
+     * Detection is by endpoint: loopback / private-LAN hosts and the well-known
+     * local ports, plus the `ollama`/`lmstudio`/`vllm` model providers. Public
+     * cloud hosts (api.x.ai, api.openai.com, api.anthropic.com, openrouter.ai, …)
+     * never match, so Grok/GPT/Claude payloads are left untouched.
+     */
+    private isStrictTemplateLocalRuntime;
+    /**
+     * Apply `mergeSystemMessagesToFront` when talking to a strict-template local
+     * runtime. No-op for cloud providers (preserves the exact current ordering,
+     * so Grok/GPT/Claude are byte-identical).
+     */
+    private normalizeMessagesForRuntime;
     /** Gate legacy search_parameters by provider compatibility. */
     private shouldIncludeSearchParameters;
+    private isSearchOmittedForXai;
+    /**
+     * Whether this provider talks to Ollama. Sync view: provider env,
+     * `OLLAMA_HOST`, or a memoized tags probe. `ensureOllamaEndpoint()`
+     * fills the probe cache before the first native call.
+     */
+    private ollamaEndpointResolved;
+    private isOllamaProvider;
+    private ensureOllamaEndpoint;
+    /**
+     * The ONE SDK seam. Ollama drops `options.num_ctx` on `/v1/chat/completions`
+     * and then loads the model at its full declared window (262 144 tokens for
+     * qwen3), so `CODEBUDDY_MAX_CONTEXT` never reached the server. For Ollama the
+     * already-built payload is sent to the native `/api/chat` instead, carrying
+     * the resolved context window; every other provider keeps the SDK call, byte
+     * for byte. The caller sees the same OpenAI shapes either way.
+     */
+    private createChatCompletion;
+    private createOllamaNativeCompletion;
     private getOllamaReasoningEffort;
     private isAsyncIterableStream;
     private isNonStreamingChatResponse;
+    private isEmptyProviderResponse;
     private nonStreamingResponseToChunks;
     private trackPromptCache;
     /**
@@ -103,6 +183,8 @@ export declare class OpenAICompatProvider implements Provider {
      * E.g. "grok-code-fast-1" → "grok", "claude-sonnet-4-6" → "anthropic".
      */
     private detectProviderLabel;
+    /** Canonical provider id shared with fleet candidate identities. */
+    private getMetricsProviderId;
     chat(messages: CodeBuddyMessage[], tools?: CodeBuddyTool[], opts?: ChatOptions, searchOptions?: SearchOptions): Promise<CodeBuddyResponse>;
     chatStream(messages: CodeBuddyMessage[], tools?: CodeBuddyTool[], opts?: ChatOptions, searchOptions?: SearchOptions): AsyncGenerator<ChatCompletionChunk, void, unknown>;
 }