@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/plus/ai/providers/openAICompatibleProviderBase.js

@@ -1,478 +1,359 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { CancellationError, isCancellationError } from '../../../utils/cancellation.js';
-import { uuid } from '../../../utils/crypto.js';
-import { getLoggableName, Logger } from '../../../utils/logger.js';
-import { maybeStartScopedLogger } from '../../../utils/logger.scoped.js';
-import { AIError, AIErrorReason } from '../errors.js';
-import { getActionName, getReducedMaxInputTokens, getValidatedTemperature } from '../utils/ai.utils.js';
-import { isResponseFormatRejected, rememberResponseFormatRejection } from './responseFormatCache.js';
-// Native-format rejection wording varies by provider ("response_format", "structured outputs",
-// Gemini's "Json mode is not enabled", and its OpenAI-compat layer's `generation_config.response_schema`
-// path in INVALID_ARGUMENT bodies, ...)
+import { CancellationError, isCancellationError } from "../../../utils/cancellation.js";
+import { Logger as _logger, getLoggableName } from "../../../utils/logger.js";
+import { maybeStartScopedLogger } from "../../../utils/logger.scoped.js";
+import _usingCtx from "../../../_virtual/@oxc-project+runtime/helpers/esm/usingCtx.js";
+import { uuid } from "../../../utils/crypto.js";
+import { AIError } from "../errors.js";
+import { getActionName, getReducedMaxInputTokens, getValidatedTemperature } from "../utils/ai.utils.js";
+import { isResponseFormatRejected, rememberResponseFormatRejection } from "./responseFormatCache.js";
+import * as l10n from "@vscode/l10n";
+//#region ../plus/ai/src/providers/openAICompatibleProviderBase.ts
 const formatRejectionRegex = /response[_ ]?(?:format|schema)|structured[_ ]?output|output_config|json_schema|json[_ ]?mode/i;
-export class OpenAICompatibleProviderBase {
-    context;
-    constructor(context) {
-        this.context = context;
-    }
-    dispose() { }
-    [Symbol.dispose]() {
-        this.dispose();
-    }
-    async configured(silent) {
-        try {
-            const apiKey = await this.getApiKey(silent);
-            return apiKey != null;
-        }
-        catch (ex) {
-            if (isCancellationError(ex))
-                return false;
-            throw ex;
-        }
-    }
-    async getApiKey(silent) {
-        const orgConf = this.context.getProviderConfig(this.id);
-        if (!orgConf.enabled)
-            return undefined;
-        if (orgConf.key)
-            return orgConf.key;
-        const { keyUrl, keyValidator } = this.config;
-        return this.context.getApiKey({
-            id: this.id,
-            name: this.name,
-            requiresAccount: this.descriptor.requiresAccount,
-            validator: keyValidator != null ? v => keyValidator.test(v) : () => true,
-            url: keyUrl,
-        }, silent);
-    }
-    isResponseFormatSessionRejected(model, responseFormat) {
-        return isResponseFormatRejected(this.id, model, responseFormat);
-    }
-    rememberResponseFormatRejection(model, responseFormat) {
-        rememberResponseFormatRejection(this.id, model, responseFormat);
-    }
-    getHeaders(_action, apiKey, _model, _url, 
-    // Deliberately unused here: only the GitKraken provider forwards the conversation ID (as
-    // `GK-Conversation-ID`); it must never reach third-party APIs.
-    _conversationId) {
-        return {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${apiKey}`,
-        };
-    }
-    async sendRequest(action, model, apiKey, getMessages, options) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const scope = __addDisposableResource(env_1, maybeStartScopedLogger(`${getLoggableName(this)}.sendRequest`), false);
-            try {
-                const result = await this.fetch(action, model, apiKey, getMessages, options.modelOptions, options.responseFormat, options.signal, options.conversationId, options.tools);
-                return result;
-            }
-            catch (ex) {
-                if (isCancellationError(ex)) {
-                    scope?.error(ex, `Cancelled request to ${getActionName(action)}: (${model.provider.name})`);
-                    throw ex;
-                }
-                scope?.error(ex, `Unable to ${getActionName(action)}: (${model.provider.name})`);
-                if (ex instanceof AIError)
-                    throw ex;
-                debugger;
-                throw new Error(`Unable to ${getActionName(action)}: (${model.provider.name}) ${ex.message}`, {
-                    cause: ex,
-                });
-            }
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    }
-    async fetch(action, model, apiKey, messages, modelOptions, responseFormat, signal, conversationId, tools) {
-        let retries = 0;
-        let maxInputTokens = model.maxTokens.input;
-        // Latched when the provider rejects the `tools` field, so the retry drops tools entirely and
-        // the caller can stop offering them for the rest of the session.
-        let toolsRejected = false;
-        while (true) {
-            const useTools = tools?.length && !toolsRejected ? tools : undefined;
-            const { messages: msgs, system } = this.extractSystemPrompt(await messages(maxInputTokens, retries));
-            const request = {
-                model: model.id,
-                messages: this.serializeMessages(msgs),
-                ...(system != null ? { system: system } : undefined),
-                ...(useTools != null ? this.serializeTools(useTools) : undefined),
-                stream: false,
-                max_completion_tokens: model.maxTokens.output
-                    ? Math.min(modelOptions?.outputTokens ?? Infinity, model.maxTokens.output)
-                    : modelOptions?.outputTokens,
-                temperature: getValidatedTemperature(model, modelOptions?.temperature ?? model.temperature, this.context.defaultTemperature),
-            };
-            if (responseFormat != null &&
-                !this.isResponseFormatSessionRejected(model, responseFormat) &&
-                this.supportsResponseFormat(model)) {
-                this.applyResponseFormat(request, model, responseFormat);
-            }
-            let rsp = await this.fetchCore(action, model, apiKey, request, signal, conversationId);
-            // Read once and forward to `handleFetchFailure` so the error body isn't decoded twice
-            let errorBody;
-            if (!rsp.ok && (request.response_format != null || request.output_config != null)) {
-                // If the native format was rejected (stale model snapshot, older Azure api-version,
-                // proxy converter gaps, OpenRouter's require_parameters matching no endpoint), strip
-                // it and resend the same request — the prompt still describes the JSON. Resending
-                // directly avoids re-running the (non-idempotent) prompt build and its side effects
-                // Leave it `undefined` (not '') when the read fails, so `handleFetchFailure` falls
-                // back to reading the still-unconsumed response instead of parsing an empty string
-                errorBody = await rsp
-                    .clone()
-                    .text()
-                    .catch(() => undefined);
-                if (this.isResponseFormatRejection(rsp.status, errorBody ?? '')) {
-                    Logger.warn(`(${this.name}) ${model.id}: native response format was rejected (${rsp.status}); retrying without it`);
-                    const rejected = responseFormat;
-                    responseFormat = undefined;
-                    delete request.response_format;
-                    delete request.output_config;
-                    delete request.provider;
-                    rsp = await this.fetchCore(action, model, apiKey, request, signal, conversationId);
-                    errorBody = undefined;
-                    // Memoize only when stripping fixed it — proof the format (not e.g. an oversized
-                    // prompt behind the same wrapped status) caused the failure
-                    if (rsp.ok && rejected != null) {
-                        this.rememberResponseFormatRejection(model, rejected);
-                    }
-                }
-            }
-            if (!rsp.ok) {
-                const result = await this.handleFetchFailure(rsp, action, model, retries, maxInputTokens, errorBody, useTools != null);
-                if (result.retry) {
-                    maxInputTokens = result.maxInputTokens;
-                    if (result.withoutTools) {
-                        // Say so explicitly: the caller degrades silently by design, so the only remaining
-                        // evidence would be `toolCalls=0` — indistinguishable from a model that simply chose
-                        // not to consult the repository. That ambiguity is the whole reason to log it.
-                        Logger.warn(`(${this.name}) ${model.id}: tools were rejected (${rsp.status}); retrying without them — repository consultation is unavailable for the rest of this session`);
-                        toolsRejected = true;
-                    }
-                    retries++;
-                    continue;
-                }
-            }
-            const data = (await rsp.json());
-            const toolCalls = this.parseToolCalls(data);
-            // A tool-call-only turn carries no text, which `extractContent` correctly reports as '' — it
-            // selects the text block by type, so a `tool_use` (or thinking) block is never mistaken for one.
-            // The calls ride alongside on `toolCalls` below.
-            const content = this.extractContent(data);
-            // Some providers/proxies (e.g. OpenRouter) report upstream failures as an OK response
-            // carrying an error envelope and no choices — surface that instead of empty content
-            if (!content && toolCalls == null && data.error != null) {
-                if (data.error.code === 429 || data.error.code === '429') {
-                    throw new AIError(AIErrorReason.RateLimitOrFundsExceeded, new Error(`(${this.name}) ${data.error.message || 'Rate limit exceeded'}`));
-                }
-                throw new Error(`(${this.name}) ${data.error.message || 'Unknown error'}`);
-            }
-            const result = {
-                id: data.id ?? uuid(),
-                content: content,
-                finishReason: this.extractFinishReason(data),
-                model: model,
-                ...(toolCalls?.length ? { toolCalls: toolCalls } : undefined),
-                ...(toolsRejected ? { toolsRejected: true } : undefined),
-                usage: {
-                    promptTokens: data.usage?.prompt_tokens ?? data.usage?.input_tokens,
-                    completionTokens: data.usage?.completion_tokens ?? data.usage?.output_tokens,
-                    totalTokens: data.usage?.total_tokens,
-                    limits: data?.usage?.gk != null
-                        ? {
-                            used: data.usage.gk.used,
-                            limit: data.usage.gk.limit,
-                            resetsOn: new Date(data.usage.gk.resets_on),
-                        }
-                        : undefined,
-                },
-                result: undefined,
-            };
-            return result;
-        }
-    }
-    /**
-     * Returns the message-related request fields. The default sends every message inline (OpenAI
-     * Chat Completions semantics); providers whose API carries the initial system prompt separately
-     * (e.g. Anthropic's top-level `system`) override this to extract it from the messages.
-     */
-    extractSystemPrompt(messages) {
-        return { messages: messages };
-    }
-    /** Whether the given model accepts a native response-format/schema field; when false the
-     *  prompt's JSON description is the only format control (the request is unchanged).
-     *  Dynamic-catalog providers (GitKraken, OpenRouter) populate
-     *  {@link AIModel.supportsStructuredOutputs}; static providers override with id-based gates */
-    supportsResponseFormat(model) {
-        return model.supportsStructuredOutputs ?? true;
-    }
-    /**
-     * Whether a failed response reads as a rejection of the `tools` field rather than a problem with the
-     * prompt — the trigger for one retry without tools, so a tool-using feature degrades to single-shot
-     * instead of failing outright.
-     *
-     * Providers that wrap upstream rejections in their own envelope (e.g. GitKraken) must override this:
-     * the wrapper's prose names neither "tool" nor "function", so the text match here cannot see through
-     * it and the fallback would never fire.
-     */
-    isToolsRejection(status, message) {
-        if (status !== 400 || !message)
-            return false;
-        const m = message.toLowerCase();
-        return ((m.includes('tool') || m.includes('function')) &&
-            (m.includes('unsupported') ||
-                m.includes('not supported') ||
-                m.includes('unknown') ||
-                m.includes('unrecognized') ||
-                m.includes('invalid') ||
-                m.includes('unexpected')));
-    }
-    /** Whether a failed response means the native response format itself was rejected — the
-     *  trigger for stripping it and retrying via the prompt-described JSON. Providers that wrap
-     *  upstream rejections in their own envelope (e.g. GitKraken) extend this */
-    isResponseFormatRejection(status, body) {
-        return ((status === 400 && formatRejectionRegex.test(body)) ||
-            // OpenRouter answers 404 when `require_parameters` matches no serving endpoint
-            (status === 404 && /no endpoints found/i.test(body)));
-    }
-    /** Translates the canonical response format onto the request; called only when
-     *  {@link supportsResponseFormat} allows it. Base emits the OpenAI `response_format.json_schema`
-     *  envelope. Overrides must REPLACE this for providers with a different native field
-     *  (e.g. Anthropic `output_config`) — never leave both on the request. */
-    applyResponseFormat(request, _model, responseFormat) {
-        request.response_format = {
-            type: 'json_schema',
-            json_schema: {
-                name: responseFormat.name,
-                strict: true,
-                schema: responseFormat.schema,
-            },
-        };
-    }
-    // Finds the text block by type rather than position — with some Anthropic models (e.g. Sonnet 5,
-    // where thinking runs by default) a thinking block can precede the text block
-    extractContent(data) {
-        return (data.choices?.[0]?.message?.content?.trim() ??
-            data.content?.find(b => b.type === 'text')?.text?.trim() ??
-            '');
-    }
-    /** Normalizes abnormal completion signals (all arrive as HTTP 200) so consumers can
-     *  distinguish truncated/filtered/refused output from a malformed-but-complete reply */
-    extractFinishReason(data) {
-        const choice = data.choices?.[0];
-        if (choice != null) {
-            // Truthy check — some OpenAI-compatible servers serialize `"refusal": ""` on normal replies
-            if (choice.message?.refusal)
-                return 'refusal';
-            if (choice.finish_reason === 'length')
-                return 'length';
-            if (choice.finish_reason === 'content_filter')
-                return 'content_filter';
-            return undefined;
-        }
-        switch (data.stop_reason) {
-            // `model_context_window_exceeded` means the context filled before the output limit — the
-            // reply is truncated all the same
-            case 'max_tokens':
-            case 'model_context_window_exceeded':
-                return 'length';
-            case 'refusal':
-                return 'refusal';
-            default:
-                return undefined;
-        }
-    }
-    /**
-     * Maps messages onto the provider's wire shape. The default is OpenAI Chat Completions: assistant
-     * tool calls go in `tool_calls` with `arguments` JSON-stringified, and tool results are `tool`-role
-     * entries keyed by `tool_call_id`. Providers with a different tool encoding (e.g. Anthropic's
-     * content blocks) override this.
-     */
-    serializeMessages(messages) {
-        return messages.map(m => {
-            if (m.role === 'tool') {
-                // A tool result is only addressable by the id of the call it answers. Without one, send it
-                // as plain text — the same shape used for providers that can't carry tool calls at all —
-                // rather than a `tool_call_id: undefined` the provider rejects with nothing to trace it to.
-                if (m.toolCallId == null)
-                    return { role: 'user', content: m.content };
-                return { role: 'tool', tool_call_id: m.toolCallId, content: m.content };
-            }
-            if (m.role === 'assistant' && m.toolCalls?.length) {
-                return {
-                    role: 'assistant',
-                    // OpenAI requires `content` to be present, but allows null on a tool-call-only turn
-                    content: m.content || null,
-                    tool_calls: m.toolCalls.map(c => ({
-                        id: c.id,
-                        type: 'function',
-                        function: { name: c.name, arguments: JSON.stringify(c.args) },
-                        // Only the GitKraken proxy mints these, so the field can only ever be present on a
-                        // conversation with that proxy — no other provider sees it.
-                        ...(c.providerSignature != null ? { thought_signature: c.providerSignature } : undefined),
-                    })),
-                };
-            }
-            return { role: m.role, content: m.content };
-        });
-    }
-    /** Returns the tool-related request fields. The default is the OpenAI `function` envelope. */
-    serializeTools(tools) {
-        return {
-            tools: tools.map(t => ({
-                type: 'function',
-                function: { name: t.name, description: t.description, parameters: t.parameters },
-            })),
-        };
-    }
-    /**
-     * Extracts tool calls from a response, handling both the OpenAI shape
-     * (`choices[].message.tool_calls`, whose `arguments` is a JSON string) and the Anthropic shape
-     * (`content[]` blocks of type `tool_use`) — mirroring how {@link fetch} already reads content
-     * from both.
-     */
-    parseToolCalls(data) {
-        const calls = [];
-        for (const call of data.choices?.[0]?.message?.tool_calls ?? []) {
-            let args = {};
-            try {
-                // Providers can emit '' for a no-argument call
-                args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
-            }
-            catch {
-                // Leave args empty — the tool dispatcher reports the resulting validation error back to
-                // the model, which is more recoverable than failing the whole request here.
-            }
-            calls.push({
-                id: call.id,
-                name: call.function.name,
-                args: args,
-                ...(call.thought_signature != null ? { providerSignature: call.thought_signature } : undefined),
-            });
-        }
-        for (const block of data.content ?? []) {
-            if (block.type !== 'tool_use' || block.id == null || block.name == null)
-                continue;
-            calls.push({ id: block.id, name: block.name, args: block.input ?? {} });
-        }
-        return calls.length ? calls : undefined;
-    }
-    async handleFetchFailure(rsp, _action, model, retries, maxInputTokens, 
-    /** The already-read error body, when the caller had to read it (avoids a second decode) */
-    body, sentTools) {
-        if (rsp.status === 404) {
-            throw new AIError(AIErrorReason.Unauthorized, new Error(`Your API key doesn't seem to have access to the selected '${model.id}' model`));
-        }
-        if (rsp.status === 429) {
-            throw new AIError(AIErrorReason.RateLimitOrFundsExceeded, new Error(`(${this.name}) ${rsp.status}: Too many requests (rate limit exceeded) or your account is out of funds`));
-        }
-        let json;
-        try {
-            json = (body != null ? JSON.parse(body) : await rsp.json());
-        }
-        catch { }
-        if (Array.isArray(json)) {
-            json = json[0];
-        }
-        if (json?.error?.code === 'context_length_exceeded') {
-            if (retries < 3) {
-                return { retry: true, maxInputTokens: getReducedMaxInputTokens(maxInputTokens, retries + 1) };
-            }
-            throw new AIError(AIErrorReason.RequestTooLarge, new Error(`(${this.name}) ${rsp.status}: ${json?.error?.message || rsp.statusText}`));
-        }
-        // A provider that advertises the OpenAI shape but rejects `tools` (an older or partial
-        // implementation) gets one retry without them, so the caller degrades to text-only instead of
-        // failing outright.
-        if (sentTools && this.isToolsRejection(rsp.status, json?.error?.message)) {
-            return { retry: true, maxInputTokens: maxInputTokens, withoutTools: true };
-        }
-        throw new Error(`(${this.name}) ${rsp.status}: ${json?.error?.message || rsp.statusText}`);
-    }
-    async fetchCore(action, model, apiKey, request, signal, conversationId) {
-        const url = this.getUrl(model);
-        if (!url) {
-            throw new Error(`(${this.name}) ${getActionName(action)}: No URL configured`);
-        }
-        const body = JSON.stringify(request);
-        // A rejected request is otherwise undiagnosable: a proxying backend reports only its own
-        // "upstream AI provider error (<provider> HTTP <status>)", so which field the upstream objected to
-        // can only be inferred. Log the request's shape — which fields were sent, and how much — but not
-        // the messages, which carry the user's source code.
-        Logger.trace(`(${this.name}) ${getActionName(action)} → ${model.id}: fields=[${Object.keys(request)
-            .sort()
-            .join(',')}] bytes=${body.length}`);
-        try {
-            return await this.context.fetch(url, {
-                headers: await this.getHeaders(action, apiKey, model, url, conversationId),
-                method: 'POST',
-                body: body,
-                signal: signal,
-            });
-        }
-        catch (ex) {
-            if (ex.name === 'AbortError')
-                throw new CancellationError(ex);
-            throw ex;
-        }
-    }
+function getRequestErrorMessage(action, providerName, message) {
+	const args = {
+		provider: providerName,
+		message
+	};
+	switch (action) {
+		case "explain-changes": return l10n.t("Unable to Explain Changes: ({provider}) {message}", args);
+		case "review-changes": return l10n.t("Unable to Review Changes: ({provider}) {message}", args);
+		case "generate-commitMessage": return l10n.t("Unable to Generate Commit Message: ({provider}) {message}", args);
+		case "generate-stashMessage": return l10n.t("Unable to Generate Stash Message: ({provider}) {message}", args);
+		case "generate-changelog": return l10n.t("Unable to Generate Changelog: ({provider}) {message}", args);
+		case "generate-create-cloudPatch": return l10n.t("Unable to Create Cloud Patch Details: ({provider}) {message}", args);
+		case "generate-create-pullRequest": return l10n.t("Unable to Create Pull Request Details: ({provider}) {message}", args);
+		case "generate-commits": return l10n.t("Unable to Generate Commits: ({provider}) {message}", args);
+		case "conflict-resolution": return l10n.t("Unable to Resolve Conflicts (Preview): ({provider}) {message}", args);
+		case "generate-searchQuery": return l10n.t("Unable to Generate Search Query: ({provider}) {message}", args);
+	}
 }
+var OpenAICompatibleProviderBase = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	dispose() {}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	async configured(silent) {
+		try {
+			return await this.getApiKey(silent) != null;
+		} catch (ex) {
+			if (isCancellationError(ex)) return false;
+			throw ex;
+		}
+	}
+	async getApiKey(silent) {
+		const orgConf = this.context.getProviderConfig(this.id);
+		if (!orgConf.enabled) return void 0;
+		if (orgConf.key) return orgConf.key;
+		const { keyUrl, keyValidator } = this.config;
+		return this.context.getApiKey({
+			id: this.id,
+			name: this.name,
+			requiresAccount: this.descriptor.requiresAccount,
+			validator: keyValidator != null ? (v) => keyValidator.test(v) : () => true,
+			url: keyUrl
+		}, silent);
+	}
+	isResponseFormatSessionRejected(model, responseFormat) {
+		return isResponseFormatRejected(this.id, model, responseFormat);
+	}
+	rememberResponseFormatRejection(model, responseFormat) {
+		rememberResponseFormatRejection(this.id, model, responseFormat);
+	}
+	getHeaders(_action, apiKey, _model, _url, _conversationId) {
+		return {
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`
+		};
+	}
+	async sendRequest(action, model, apiKey, getMessages, options) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			const scope = _usingCtx$1.u(maybeStartScopedLogger(`${getLoggableName(this)}.sendRequest`));
+			try {
+				return await this.fetch(action, model, apiKey, getMessages, options.modelOptions, options.responseFormat, options.signal, options.conversationId, options.tools);
+			} catch (ex) {
+				if (isCancellationError(ex)) {
+					scope?.error(ex, `Cancelled request to ${getActionName(action)}: (${model.provider.name})`);
+					throw ex;
+				}
+				scope?.error(ex, `Unable to ${getActionName(action)}: (${model.provider.name})`);
+				if (ex instanceof AIError) throw ex;
+				debugger;
+				throw new Error(getRequestErrorMessage(action, model.provider.name, ex.message), { cause: ex });
+			}
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	async fetch(action, model, apiKey, messages, modelOptions, responseFormat, signal, conversationId, tools) {
+		let retries = 0;
+		let maxInputTokens = model.maxTokens.input;
+		let toolsRejected = false;
+		while (true) {
+			const useTools = tools?.length && !toolsRejected ? tools : void 0;
+			const { messages: msgs, system } = this.extractSystemPrompt(await messages(maxInputTokens, retries));
+			const request = {
+				model: model.id,
+				messages: this.serializeMessages(msgs),
+				...system != null ? { system } : void 0,
+				...useTools != null ? this.serializeTools(useTools) : void 0,
+				stream: false,
+				max_completion_tokens: model.maxTokens.output ? Math.min(modelOptions?.outputTokens ?? Infinity, model.maxTokens.output) : modelOptions?.outputTokens,
+				temperature: getValidatedTemperature(model, modelOptions?.temperature ?? model.temperature, this.context.defaultTemperature)
+			};
+			if (responseFormat != null && !this.isResponseFormatSessionRejected(model, responseFormat) && this.supportsResponseFormat(model)) this.applyResponseFormat(request, model, responseFormat);
+			let rsp = await this.fetchCore(action, model, apiKey, request, signal, conversationId);
+			let errorBody;
+			if (!rsp.ok && (request.response_format != null || request.output_config != null)) {
+				errorBody = await rsp.clone().text().catch(() => void 0);
+				if (this.isResponseFormatRejection(rsp.status, errorBody ?? "")) {
+					_logger.warn(`(${this.name}) ${model.id}: native response format was rejected (${rsp.status}); retrying without it`);
+					const rejected = responseFormat;
+					responseFormat = void 0;
+					delete request.response_format;
+					delete request.output_config;
+					delete request.provider;
+					rsp = await this.fetchCore(action, model, apiKey, request, signal, conversationId);
+					errorBody = void 0;
+					if (rsp.ok && rejected != null) this.rememberResponseFormatRejection(model, rejected);
+				}
+			}
+			if (!rsp.ok) {
+				const result = await this.handleFetchFailure(rsp, action, model, retries, maxInputTokens, errorBody, useTools != null);
+				if (result.retry) {
+					maxInputTokens = result.maxInputTokens;
+					if (result.withoutTools) {
+						_logger.warn(`(${this.name}) ${model.id}: tools were rejected (${rsp.status}); retrying without them — repository consultation is unavailable for the rest of this session`);
+						toolsRejected = true;
+					}
+					retries++;
+					continue;
+				}
+			}
+			const data = await rsp.json();
+			const toolCalls = this.parseToolCalls(data);
+			const content = this.extractContent(data);
+			if (!content && toolCalls == null && data.error != null) {
+				if (data.error.code === 429 || data.error.code === "429") throw new AIError(5, /* @__PURE__ */ new Error(`(${this.name}) ${data.error.message || "Rate limit exceeded"}`));
+				throw new Error(`(${this.name}) ${data.error.message || "Unknown error"}`);
+			}
+			return {
+				id: data.id ?? uuid(),
+				content,
+				finishReason: this.extractFinishReason(data),
+				model,
+				...toolCalls?.length ? { toolCalls } : void 0,
+				...toolsRejected ? { toolsRejected: true } : void 0,
+				usage: {
+					promptTokens: data.usage?.prompt_tokens ?? data.usage?.input_tokens,
+					completionTokens: data.usage?.completion_tokens ?? data.usage?.output_tokens,
+					totalTokens: data.usage?.total_tokens,
+					limits: data?.usage?.gk != null ? {
+						used: data.usage.gk.used,
+						limit: data.usage.gk.limit,
+						resetsOn: new Date(data.usage.gk.resets_on)
+					} : void 0
+				},
+				result: void 0
+			};
+		}
+	}
+	/**
+	* Returns the message-related request fields. The default sends every message inline (OpenAI
+	* Chat Completions semantics); providers whose API carries the initial system prompt separately
+	* (e.g. Anthropic's top-level `system`) override this to extract it from the messages.
+	*/
+	extractSystemPrompt(messages) {
+		return { messages };
+	}
+	/** Whether the given model accepts a native response-format/schema field; when false the
+	*  prompt's JSON description is the only format control (the request is unchanged).
+	*  Dynamic-catalog providers (GitKraken, OpenRouter) populate
+	*  {@link AIModel.supportsStructuredOutputs}; static providers override with id-based gates */
+	supportsResponseFormat(model) {
+		return model.supportsStructuredOutputs ?? true;
+	}
+	/**
+	* Whether a failed response reads as a rejection of the `tools` field rather than a problem with the
+	* prompt — the trigger for one retry without tools, so a tool-using feature degrades to single-shot
+	* instead of failing outright.
+	*
+	* Providers that wrap upstream rejections in their own envelope (e.g. GitKraken) must override this:
+	* the wrapper's prose names neither "tool" nor "function", so the text match here cannot see through
+	* it and the fallback would never fire.
+	*/
+	isToolsRejection(status, message) {
+		if (status !== 400 || !message) return false;
+		const m = message.toLowerCase();
+		return (m.includes("tool") || m.includes("function")) && (m.includes("unsupported") || m.includes("not supported") || m.includes("unknown") || m.includes("unrecognized") || m.includes("invalid") || m.includes("unexpected"));
+	}
+	/** Whether a failed response means the native response format itself was rejected — the
+	*  trigger for stripping it and retrying via the prompt-described JSON. Providers that wrap
+	*  upstream rejections in their own envelope (e.g. GitKraken) extend this */
+	isResponseFormatRejection(status, body) {
+		return status === 400 && formatRejectionRegex.test(body) || status === 404 && /no endpoints found/i.test(body);
+	}
+	/** Translates the canonical response format onto the request; called only when
+	*  {@link supportsResponseFormat} allows it. Base emits the OpenAI `response_format.json_schema`
+	*  envelope. Overrides must REPLACE this for providers with a different native field
+	*  (e.g. Anthropic `output_config`) — never leave both on the request. */
+	applyResponseFormat(request, _model, responseFormat) {
+		request.response_format = {
+			type: "json_schema",
+			json_schema: {
+				name: responseFormat.name,
+				strict: true,
+				schema: responseFormat.schema
+			}
+		};
+	}
+	extractContent(data) {
+		return data.choices?.[0]?.message?.content?.trim() ?? data.content?.find((b) => b.type === "text")?.text?.trim() ?? "";
+	}
+	/** Normalizes abnormal completion signals (all arrive as HTTP 200) so consumers can
+	*  distinguish truncated/filtered/refused output from a malformed-but-complete reply */
+	extractFinishReason(data) {
+		const choice = data.choices?.[0];
+		if (choice != null) {
+			if (choice.message?.refusal) return "refusal";
+			if (choice.finish_reason === "length") return "length";
+			if (choice.finish_reason === "content_filter") return "content_filter";
+			return;
+		}
+		switch (data.stop_reason) {
+			case "max_tokens":
+			case "model_context_window_exceeded": return "length";
+			case "refusal": return "refusal";
+			default: return;
+		}
+	}
+	/**
+	* Maps messages onto the provider's wire shape. The default is OpenAI Chat Completions: assistant
+	* tool calls go in `tool_calls` with `arguments` JSON-stringified, and tool results are `tool`-role
+	* entries keyed by `tool_call_id`. Providers with a different tool encoding (e.g. Anthropic's
+	* content blocks) override this.
+	*/
+	serializeMessages(messages) {
+		return messages.map((m) => {
+			if (m.role === "tool") {
+				if (m.toolCallId == null) return {
+					role: "user",
+					content: m.content
+				};
+				return {
+					role: "tool",
+					tool_call_id: m.toolCallId,
+					content: m.content
+				};
+			}
+			if (m.role === "assistant" && m.toolCalls?.length) return {
+				role: "assistant",
+				content: m.content || null,
+				tool_calls: m.toolCalls.map((c) => ({
+					id: c.id,
+					type: "function",
+					function: {
+						name: c.name,
+						arguments: JSON.stringify(c.args)
+					},
+					...c.providerSignature != null ? { thought_signature: c.providerSignature } : void 0
+				}))
+			};
+			return {
+				role: m.role,
+				content: m.content
+			};
+		});
+	}
+	/** Returns the tool-related request fields. The default is the OpenAI `function` envelope. */
+	serializeTools(tools) {
+		return { tools: tools.map((t) => ({
+			type: "function",
+			function: {
+				name: t.name,
+				description: t.description,
+				parameters: t.parameters
+			}
+		})) };
+	}
+	/**
+	* Extracts tool calls from a response, handling both the OpenAI shape
+	* (`choices[].message.tool_calls`, whose `arguments` is a JSON string) and the Anthropic shape
+	* (`content[]` blocks of type `tool_use`) — mirroring how {@link fetch} already reads content
+	* from both.
+	*/
+	parseToolCalls(data) {
+		const calls = [];
+		for (const call of data.choices?.[0]?.message?.tool_calls ?? []) {
+			let args = {};
+			try {
+				args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+			} catch {}
+			calls.push({
+				id: call.id,
+				name: call.function.name,
+				args,
+				...call.thought_signature != null ? { providerSignature: call.thought_signature } : void 0
+			});
+		}
+		for (const block of data.content ?? []) {
+			if (block.type !== "tool_use" || block.id == null || block.name == null) continue;
+			calls.push({
+				id: block.id,
+				name: block.name,
+				args: block.input ?? {}
+			});
+		}
+		return calls.length ? calls : void 0;
+	}
+	async handleFetchFailure(rsp, _action, model, retries, maxInputTokens, body, sentTools) {
+		if (rsp.status === 404) throw new AIError(9, /* @__PURE__ */ new Error(`Your API key doesn't seem to have access to the selected '${model.id}' model`));
+		if (rsp.status === 429) throw new AIError(5, /* @__PURE__ */ new Error(`(${this.name}) ${rsp.status}: Too many requests (rate limit exceeded) or your account is out of funds`));
+		let json;
+		try {
+			json = body != null ? JSON.parse(body) : await rsp.json();
+		} catch {}
+		if (Array.isArray(json)) json = json[0];
+		if (json?.error?.code === "context_length_exceeded") {
+			if (retries < 3) return {
+				retry: true,
+				maxInputTokens: getReducedMaxInputTokens(maxInputTokens, retries + 1)
+			};
+			throw new AIError(6, /* @__PURE__ */ new Error(`(${this.name}) ${rsp.status}: ${json?.error?.message || rsp.statusText}`));
+		}
+		if (sentTools && this.isToolsRejection(rsp.status, json?.error?.message)) return {
+			retry: true,
+			maxInputTokens,
+			withoutTools: true
+		};
+		throw new Error(`(${this.name}) ${rsp.status}: ${json?.error?.message || rsp.statusText}`);
+	}
+	async fetchCore(action, model, apiKey, request, signal, conversationId) {
+		const url = this.getUrl(model);
+		if (!url) throw new Error(`(${this.name}) ${getActionName(action)}: No URL configured`);
+		const body = JSON.stringify(request);
+		_logger.trace(`(${this.name}) ${getActionName(action)} → ${model.id}: fields=[${Object.keys(request).sort().join(",")}] bytes=${body.length}`);
+		try {
+			return await this.context.fetch(url, {
+				headers: await this.getHeaders(action, apiKey, model, url, conversationId),
+				method: "POST",
+				body,
+				signal
+			});
+		} catch (ex) {
+			if (ex.name === "AbortError") throw new CancellationError(ex);
+			throw ex;
+		}
+	}
+};
+//#endregion
+export { OpenAICompatibleProviderBase };
+
 //# sourceMappingURL=openAICompatibleProviderBase.js.map