@gitkraken/core-gitlens 0.5.109 → 0.5.111

package/src/plus/ai/providers/gitkrakenProvider.ts

@@ -8,9 +8,14 @@ import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js'
 
 type GitKrakenModel = AIModel<typeof provider.id>;
 
+/** Opt-out flag the models endpoint reports in `disabledAttributes` for models whose upstream
+ *  translation doesn't cover native structured outputs */
+const structuredOutputAttribute = 'structured_output';
+
 export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provider.id> {
 	readonly id = provider.id;
 	readonly name = provider.name;
+	readonly supportsTools = true;
 	protected readonly descriptor = provider;
 	protected readonly config = {};
 
@@ -47,6 +52,7 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 					preferred: boolean;
 					maxInputTokens: number;
 					maxOutputTokens: number;
+					disabledAttributes?: string[];
 					consumptionRateLabel?: string;
 				}[];
 				error?: null;
@@ -67,6 +73,10 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 						default: m.preferred,
 						temperature: null,
 						consumptionRateLabel: m.consumptionRateLabel,
+						// The backend owns the per-upstream `response_format` translation, so it's the
+						// authority on which models it covers. A schema an upstream's converter still
+						// rejects is recovered per-request via isResponseFormatRejection below
+						supportsStructuredOutputs: !m.disabledAttributes?.includes(structuredOutputAttribute),
 					}) satisfies GitKrakenModel,
 			);
 			return models;
@@ -84,6 +94,31 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 		return 'chat/completions';
 	}
 
+	protected override isToolsRejection(status: number, message: string | undefined): boolean {
+		if (super.isToolsRejection(status, message)) return true;
+		if (message == null) return false;
+
+		// The backend forwards an upstream refusal as its own envelope carrying only "upstream AI provider
+		// error (<provider> HTTP 400)", naming neither "tool" nor "function" — so the base's text match can
+		// never fire here. Treat any wrapped upstream 400 as a candidate and let the retry decide: `tools`
+		// is the only field a tool-using request sends that a plain completion doesn't, the probe costs one
+		// request, and the caller latches the rejection only when dropping tools actually fixes it. A
+		// misread therefore self-corrects — the same bargain `isResponseFormatRejection` below makes.
+		return getWrappedUpstreamStatus(message) === 400;
+	}
+
+	protected override isResponseFormatRejection(status: number, body: string): boolean {
+		if (super.isResponseFormatRejection(status, body)) return true;
+
+		// The backend wraps upstream schema rejections in its own envelope, carrying only the upstream
+		// status (e.g. its Gemini schema converter mangles null-union types → Gemini 400s). Match on the
+		// wrapper, NOT the envelope code — that varies by backend (500.1 on prod, 400.1 seen on staging),
+		// and keying off it means the probe silently stops firing. A non-schema upstream 400 also matches,
+		// which is fine: the strip-and-resend probe is cheap and rejection is only memoized when the
+		// resend succeeds, so misclassification self-corrects.
+		return getWrappedUpstreamStatus(body) === 400;
+	}
+
 	protected override getHeaders<TAction extends AIActionType>(
 		action: TAction,
 		apiKey: string,
@@ -107,17 +142,27 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 		_model: AIModel<typeof provider.id>,
 		retries: number,
 		maxInputTokens: number,
-	): Promise<{ retry: true; maxInputTokens: number }> {
+		body?: string,
+		sentTools?: boolean,
+	): Promise<{ retry: true; maxInputTokens: number; withoutTools?: boolean }> {
 		type ErrorResponse = {
 			error?: { code: string; message: string; data?: any };
 		};
 
 		let json;
 		try {
-			json = (await rsp.json()) as ErrorResponse | undefined;
+			json = (body != null ? JSON.parse(body) : await rsp.json()) as ErrorResponse | undefined;
 		} catch {}
 
+		// The backend's own prose says only "upstream AI provider error (<provider> HTTP <status>)" and
+		// puts the provider's actual complaint in `data`. Dropping it (as every branch but the
+		// entitlement one did) leaves nothing naming a cause, so a request the upstream rejected is
+		// indistinguishable from any other 400 — and the only way to find out is to guess.
 		let message = json?.error?.message || rsp.statusText;
+		const detail = formatErrorData(json?.error?.data);
+		if (detail != null) {
+			message += `; ${detail}`;
+		}
 
 		let status: string | number;
 		let code: string | number;
@@ -126,6 +171,33 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 		status = status ? parseInt(status, 10) : rsp.status;
 		code = code ? parseInt(code, 10) : 0;
 
+		// Classify a wrapped upstream failure by the status it carries, not by the envelope's own code:
+		// prod reports these as 500.1, but staging has been seen using 400.1, and keying off the outer
+		// code means an upstream rate limit arrives as a bare Error with no reason — so no "Switch
+		// Model" action and no retry, just an opaque message.
+		const upstreamStatus = getWrappedUpstreamStatus(message);
+		if (upstreamStatus != null) {
+			const wrapped = new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			switch (upstreamStatus) {
+				case 429:
+					throw new AIError(AIErrorReason.RateLimitExceeded, wrapped);
+				case 413:
+					throw new AIError(AIErrorReason.RequestTooLarge, wrapped);
+				case 401:
+				case 403:
+					throw new AIError(AIErrorReason.Unauthorized, wrapped);
+				// Anything else is the upstream refusing the request itself. There's nothing to recover
+				// automatically, so fall through and surface it with the detail folded in above.
+			}
+		}
+
+		// Recover a tools rejection BEFORE the switch below. This override owns the 400 case and throws,
+		// so it never reaches `super.handleFetchFailure` — which is the only place the base's
+		// retry-without-tools fallback lives, leaving it unreachable for this provider.
+		if (sentTools && this.isToolsRejection(status, message)) {
+			return { retry: true, maxInputTokens: maxInputTokens, withoutTools: true };
+		}
+
 		switch (status) {
 			case 400: // Bad Request
 				// CodeValidation         = "400.1"
@@ -201,9 +273,12 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 			case 499:
 				// CodeRequestCanceled    = "499.1"
 				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
-			case 500:
+			case 500: {
 				// CodeServerError        = "500.1"
+				// Wrapped upstream failures are classified above, before this switch — the backend has
+				// used more than one envelope code for them, so that can't key off `status`.
 				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			}
 			case 503:
 				// CodeServiceUnavailable = "503.1"
 
@@ -222,3 +297,51 @@ export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provi
 		}
 	}
 }
+
+/** Max characters of `error.data` folded into a message — enough to name a cause, bounded so a large
+ *  payload can't dominate a notification or a log line. */
+const maxErrorDetailLength = 500;
+
+/**
+ * Renders the backend's `error.data` as a short detail string. This is where the upstream provider's
+ * own complaint arrives, so it's the difference between "upstream AI provider error (OpenAI HTTP 400)"
+ * and knowing which field it rejected.
+ *
+ * Strings pass through; objects are JSON-encoded. A common shape is the upstream's own error envelope,
+ * so a nested `message` is preferred when present rather than dumping the whole object.
+ */
+function formatErrorData(data: unknown): string | undefined {
+	if (data == null) return undefined;
+
+	let text: string | undefined;
+	if (typeof data === 'string') {
+		text = data;
+	} else if (typeof data === 'object') {
+		const nested =
+			(data as { error?: { message?: unknown }; message?: unknown }).error?.message ??
+			(data as { message?: unknown }).message;
+		if (typeof nested === 'string' && nested) {
+			text = nested;
+		} else {
+			try {
+				text = JSON.stringify(data);
+			} catch {
+				return undefined;
+			}
+		}
+	} else if (typeof data === 'number' || typeof data === 'boolean') {
+		text = String(data);
+	}
+
+	text = text?.trim();
+	if (!text || text === '{}' || text === 'null') return undefined;
+
+	return text.length > maxErrorDetailLength ? `${text.slice(0, maxErrorDetailLength)}…` : text;
+}
+
+/** Extracts the upstream HTTP status from the backend's upstream-error prose wrapper. The envelope code
+ *  varies (500.1 on prod, 400.1 seen on staging), so callers must key off this, not the outer code. */
+function getWrappedUpstreamStatus(text: string): number | undefined {
+	const status = /upstream ai provider error[\s\S]*?http (\d{3})/i.exec(text)?.[1];
+	return status != null ? parseInt(status, 10) : undefined;
+}

package/src/plus/ai/providers/huggingFaceProvider.ts

@@ -55,4 +55,10 @@ export class HuggingFaceProvider extends OpenAICompatibleProviderBase<typeof pro
 	protected getUrl(_model: AIModel<typeof provider.id>): string {
 		return 'https://router.huggingface.co/v1/chat/completions';
 	}
+
+	// Router support varies by partner provider with no capability metadata and auto-routing —
+	// the prompt-described JSON fallback is the only reliable path
+	protected override supportsResponseFormat(_model: AIModel<typeof provider.id>): boolean {
+		return false;
+	}
 }

package/src/plus/ai/providers/mistralProvider.ts

@@ -8,10 +8,17 @@ type MistralModel = AIModel<typeof provider.id>;
 const models: MistralModel[] = [
 	{
 		id: 'mistral-medium-latest',
-		name: 'Mistral Medium',
-		maxTokens: { input: 131072, output: 4096 },
+		name: 'Mistral Medium 3.5',
+		maxTokens: { input: 262144, output: 4096 },
 		provider: provider,
 	},
+	{
+		id: 'mistral-medium-3-5',
+		name: 'Mistral Medium 3.5',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
 	{
 		id: 'mistral-medium-2505',
 		name: 'Mistral Medium',
@@ -20,24 +27,44 @@ const models: MistralModel[] = [
 		hidden: true,
 	},
 	{
-		id: 'codestral-latest',
-		name: 'Codestral',
+		id: 'zai-glm-5-2',
+		name: 'GLM 5.2',
+		maxTokens: { input: 1000000, output: 128000 },
+		provider: provider,
+	},
+	{
+		id: 'mistral-small-latest',
+		name: 'Mistral Small 4',
 		maxTokens: { input: 262144, output: 4096 },
 		provider: provider,
 		default: true,
 	},
 	{
-		id: 'codestral-2501',
-		name: 'Codestral',
+		id: 'mistral-small-2603',
+		name: 'Mistral Small 4',
 		maxTokens: { input: 262144, output: 4096 },
 		provider: provider,
 		hidden: true,
 	},
 	{
-		id: 'mistral-large-latest',
-		name: 'Mistral Large',
+		id: 'mistral-small-2503',
+		name: 'Mistral Small',
 		maxTokens: { input: 131072, output: 4096 },
 		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'mistral-large-latest',
+		name: 'Mistral Large 3',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'mistral-large-2512',
+		name: 'Mistral Large 3',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		hidden: true,
 	},
 	{
 		id: 'mistral-large-2411',
@@ -47,27 +74,74 @@ const models: MistralModel[] = [
 		hidden: true,
 	},
 	{
-		id: 'devstral-small-latest',
-		name: 'Devstral Small',
+		id: 'ministral-14b-latest',
+		name: 'Ministral 3 14B',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'ministral-14b-2512',
+		name: 'Ministral 3 14B',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'ministral-8b-latest',
+		name: 'Ministral 3 8B',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'ministral-8b-2512',
+		name: 'Ministral 3 8B',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'ministral-3b-latest',
+		name: 'Ministral 3 3B',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'ministral-3b-2512',
+		name: 'Ministral 3 3B',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'codestral-latest',
+		name: 'Codestral',
 		maxTokens: { input: 131072, output: 4096 },
 		provider: provider,
 	},
 	{
-		id: 'devstral-small-2505',
-		name: 'Devstral Small',
+		id: 'codestral-2508',
+		name: 'Codestral',
 		maxTokens: { input: 131072, output: 4096 },
 		provider: provider,
 		hidden: true,
 	},
 	{
-		id: 'mistral-small-latest',
-		name: 'Mistral Small',
+		id: 'codestral-2501',
+		name: 'Codestral',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'devstral-small-latest',
+		name: 'Devstral Small',
 		maxTokens: { input: 131072, output: 4096 },
 		provider: provider,
+		hidden: true,
 	},
 	{
-		id: 'mistral-small-2503',
-		name: 'Mistral Small',
+		id: 'devstral-small-2505',
+		name: 'Devstral Small',
 		maxTokens: { input: 131072, output: 4096 },
 		provider: provider,
 		hidden: true,
@@ -77,6 +151,7 @@ const models: MistralModel[] = [
 export class MistralProvider extends OpenAICompatibleProviderBase<typeof provider.id> {
 	readonly id = provider.id;
 	readonly name = provider.name;
+	readonly supportsTools = true;
 	protected readonly descriptor = provider;
 	protected readonly config = {
 		keyUrl: 'https://console.mistral.ai/api-keys',
@@ -111,11 +186,13 @@ export class MistralProvider extends OpenAICompatibleProviderBase<typeof provide
 		model: AIModel<typeof provider.id>,
 		retries: number,
 		maxInputTokens: number,
-	): Promise<{ retry: true; maxInputTokens: number }> {
+		body?: string,
+		sentTools?: boolean,
+	): Promise<{ retry: true; maxInputTokens: number; withoutTools?: boolean }> {
 		if (rsp.status !== 404 && rsp.status !== 429) {
 			let json;
 			try {
-				json = (await rsp.json()) as MistralError | undefined;
+				json = (body != null ? JSON.parse(body) : await rsp.json()) as MistralError | undefined;
 			} catch {}
 
 			debugger;
@@ -137,10 +214,16 @@ export class MistralProvider extends OpenAICompatibleProviderBase<typeof provide
 				}
 			}
 
+			// This override throws for every non-404/429 status, so the base class's tools-rejection
+			// recovery would never run for Mistral — check it here to keep the text-only fallback
+			if (sentTools && this.isToolsRejection(rsp.status, message)) {
+				return { retry: true, maxInputTokens: maxInputTokens, withoutTools: true };
+			}
+
 			throw new Error(`(${this.name}) ${rsp.status}: ${message || rsp.statusText}`);
 		}
 
-		return super.handleFetchFailure(rsp, action, model, retries, maxInputTokens);
+		return super.handleFetchFailure(rsp, action, model, retries, maxInputTokens, body, sentTools);
 	}
 }
 

package/src/plus/ai/providers/ollamaProvider.ts

@@ -1,7 +1,14 @@
 import { uuid } from '../../../utils/crypto.js';
+import { Logger } from '../../../utils/logger.js';
 import { ollamaProviderDescriptor as provider } from '../constants.js';
 import type { AIActionType, AIModel } from '../models/model.js';
-import type { AIChatMessage, AIProviderResponse } from '../models/provider.js';
+import type {
+	AIChatMessage,
+	AIChatMessageRole,
+	AIProviderResponse,
+	AIResponseFormat,
+	JSONSchema,
+} from '../models/provider.js';
 import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js';
 
 type OllamaModel = AIModel<typeof provider.id>;
@@ -122,6 +129,11 @@ export class OllamaProvider extends OpenAICompatibleProviderBase<typeof provider
 		return url ? `${url}/api/chat` : undefined;
 	}
 
+	// Ollama < 0.5.0 rejects a schema-valued `format` (accepts only 'json')
+	protected override isResponseFormatRejection(status: number, body: string): boolean {
+		return status === 400 && /format/i.test(body);
+	}
+
 	protected override getHeaders<TAction extends AIActionType>(
 		_action: TAction,
 		_apiKey: string,
@@ -138,8 +150,9 @@ export class OllamaProvider extends OpenAICompatibleProviderBase<typeof provider
 		action: TAction,
 		model: AIModel<typeof provider.id>,
 		apiKey: string,
-		messages: (maxInputTokens: number, retries: number) => Promise<AIChatMessage[]>,
+		messages: (maxInputTokens: number, retries: number) => Promise<AIChatMessage<AIChatMessageRole>[]>,
 		modelOptions?: { outputTokens?: number; temperature?: number },
+		responseFormat?: AIResponseFormat,
 		signal?: AbortSignal,
 	): Promise<AIProviderResponse<void>> {
 		let retries = 0;
@@ -158,10 +171,19 @@ export class OllamaProvider extends OpenAICompatibleProviderBase<typeof provider
 			// Ensure temperature is within valid range for Ollama (0.0-1.0)
 			const temperature = Math.min(Math.max(modelOptions?.temperature ?? 0.7, 0), 1);
 
+			const format =
+				responseFormat != null &&
+				!this.isResponseFormatSessionRejected(model, responseFormat) &&
+				this.supportsResponseFormat(model)
+					? responseFormat.schema
+					: undefined;
+
 			const request: OllamaChatRequest = {
 				model: model.id,
 				messages: ollamaMessages,
 				stream: false,
+				// Ollama takes the bare JSON schema (grammar-constrained sampling, any model)
+				format: format,
 				options: {
 					temperature: temperature,
 					// Add num_predict if outputTokens is specified
@@ -169,9 +191,34 @@ export class OllamaProvider extends OpenAICompatibleProviderBase<typeof provider
 				},
 			};
 
-			const rsp = await this.fetchCore(action, model, apiKey, request, signal);
+			let rsp = await this.fetchCore(action, model, apiKey, request, signal);
+			let errorBody: string | undefined;
+			if (!rsp.ok && rsp.status === 400 && request.format != null) {
+				// If the schema-valued format was rejected (Ollama < 0.5.0 accepts only 'json'),
+				// resend the same request without it — the prompt still describes the JSON
+				// 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.format;
+					rsp = await this.fetchCore(action, model, apiKey, request, signal);
+					errorBody = undefined;
+					if (rsp.ok && rejected != null) {
+						this.rememberResponseFormatRejection(model, rejected);
+					}
+				}
+			}
+
 			if (!rsp.ok) {
-				const result = await this.handleFetchFailure(rsp, action, model, retries, maxInputTokens);
+				const result = await this.handleFetchFailure(rsp, action, model, retries, maxInputTokens, errorBody);
 				if (result.retry) {
 					maxInputTokens = result.maxInputTokens;
 					retries++;
@@ -190,6 +237,7 @@ export class OllamaProvider extends OpenAICompatibleProviderBase<typeof provider
 				return {
 					id: uuid(),
 					content: data.message.content,
+					finishReason: data.done_reason === 'length' ? 'length' : undefined,
 					model: model,
 					usage: {
 						promptTokens: data.prompt_eval_count ?? 0,
@@ -216,6 +264,8 @@ interface OllamaChatRequest {
 		content: string;
 	}>;
 	stream: boolean;
+	/** 'json' for JSON mode, or a JSON schema object for structured output (Ollama ≥0.5.0) */
+	format?: 'json' | JSONSchema;
 	options?: {
 		temperature?: number;
 		top_p?: number;
@@ -232,6 +282,7 @@ interface OllamaChatResponse {
 		content: string;
 	};
 	done: boolean;
+	done_reason?: string;
 	total_duration?: number;
 	load_duration?: number;
 	prompt_eval_count?: number;

package/src/plus/ai/providers/openAICompatibleProvider.ts

@@ -27,6 +27,11 @@ export class OpenAICompatibleProvider extends OpenAICompatibleProviderBase<typeo
 		return cfg.url || undefined;
 	}
 
+	// Unknown user-configured backend — fall back to prompt-described JSON
+	protected override supportsResponseFormat(_model: AIModel<typeof provider.id>): boolean {
+		return false;
+	}
+
 	private async getOrPromptBaseUrl(silent: boolean, hasApiKey: boolean): Promise<string | undefined> {
 		const orgConf = this.context.getProviderConfig(this.id);
 		if (!orgConf.enabled) return undefined;