@gitkraken/core-gitlens 0.1.0

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

@@ -0,0 +1,92 @@
+import { githubProviderDescriptor as provider } from '../constants.js';
+import { AIError, AIErrorReason } from '../errors.js';
+import type { AIActionType, AIModel } from '../models/model.js';
+import { getReducedMaxInputTokens } from '../utils/ai.utils.js';
+import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js';
+
+type GitHubModelsModel = AIModel<typeof provider.id>;
+
+export class GitHubModelsProvider extends OpenAICompatibleProviderBase<typeof provider.id> {
+	readonly id = provider.id;
+	readonly name = provider.name;
+	protected readonly descriptor = provider;
+	protected readonly config = {
+		keyUrl: 'https://github.com/settings/tokens',
+		keyValidator: /(?:ghp-)?[a-zA-Z0-9]{32,}/,
+	};
+
+	async getModels(): Promise<readonly AIModel<typeof provider.id>[]> {
+		const rsp = await this.context.fetch(
+			'https://github.com/marketplace?category=All&task=chat-completion&type=models',
+			{
+				headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+			},
+		);
+
+		interface ModelsResponse {
+			results: {
+				type: 'model';
+				task: 'chat-completion';
+
+				id: string;
+				name: string;
+				friendly_name: string;
+				publisher: string;
+				model_family: string;
+				max_input_tokens: number;
+				max_output_tokens: number;
+			}[];
+		}
+
+		const result = (await rsp.json()) as ModelsResponse;
+		const models = result.results.map<GitHubModelsModel>(
+			m =>
+				({
+					id: m.name,
+					name: m.friendly_name,
+					maxTokens: { input: m.max_input_tokens, output: m.max_output_tokens },
+					provider: provider,
+					temperature: null,
+				}) satisfies GitHubModelsModel,
+		);
+
+		return models;
+	}
+
+	protected getUrl(_model: AIModel<typeof provider.id>): string {
+		return 'https://models.inference.ai.azure.com/chat/completions';
+	}
+
+	override async handleFetchFailure(
+		rsp: Response,
+		action: AIActionType,
+		model: AIModel<typeof provider.id>,
+		retries: number,
+		maxInputTokens: number,
+	): Promise<{ retry: true; maxInputTokens: number }> {
+		if (rsp.status !== 404 && rsp.status !== 429) {
+			let json;
+			try {
+				json = (await rsp.json()) as { error?: { code: string; message: string } } | undefined;
+			} catch {}
+
+			if (json?.error?.code === 'tokens_limit_reached') {
+				if (retries < 3) {
+					const match = /Max size: (\d+) tokens/.exec(json?.error?.message);
+					if (match?.[1] != null) {
+						return { retry: true, maxInputTokens: parseInt(match[1], 10) };
+					}
+
+					return { retry: true, maxInputTokens: getReducedMaxInputTokens(maxInputTokens, retries + 1) };
+				}
+
+				throw new AIError(
+					AIErrorReason.RequestTooLarge,
+					new Error(`(${this.name}) ${rsp.status}: ${json?.error?.message || rsp.statusText}`),
+				);
+			}
+		}
+
+		return super.handleFetchFailure(rsp, action, model, retries, maxInputTokens);
+	}
+}

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

@@ -0,0 +1,218 @@
+import { trace } from '../../../utils/decorators/log.js';
+import { getScopedLogger } from '../../../utils/logger.scoped.js';
+import { gitKrakenProviderDescriptor as provider } from '../constants.js';
+import { AIError, AIErrorReason, AuthenticationRequiredError } from '../errors.js';
+import type { AIActionType, AIModel } from '../models/model.js';
+import { getReducedMaxInputTokens } from '../utils/ai.utils.js';
+import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js';
+
+type GitKrakenModel = AIModel<typeof provider.id>;
+
+export class GitKrakenProvider extends OpenAICompatibleProviderBase<typeof provider.id> {
+	readonly id = provider.id;
+	readonly name = provider.name;
+	protected readonly descriptor = provider;
+	protected readonly config = {};
+
+	override async getApiKey(silent: boolean): Promise<string | undefined> {
+		return this.context.getApiKey(
+			{
+				id: this.id,
+				name: this.name,
+				requiresAccount: this.descriptor.requiresAccount,
+				validator: () => true,
+			},
+			silent,
+		);
+	}
+
+	@trace()
+	async getModels(): Promise<readonly AIModel<typeof provider.id>[]> {
+		const scope = getScopedLogger();
+
+		try {
+			const rsp = await this.context.fetch('providers/message-prompt', {
+				headers: { Accept: 'application/json' },
+			});
+			if (!rsp.ok) {
+				throw new Error(`Getting models failed: ${rsp.status} (${rsp.statusText})`);
+			}
+
+			interface ModelsResponse {
+				data: {
+					providerId: string;
+					providerName: string;
+					modelId: string;
+					modelName: string;
+					preferred: boolean;
+					maxInputTokens: number;
+					maxOutputTokens: number;
+				}[];
+				error?: null;
+			}
+
+			const result = (await rsp.json()) as ModelsResponse;
+			if (result.error != null) {
+				throw new Error(`Getting models failed: ${String(result.error)}`);
+			}
+
+			const models = result.data.map<GitKrakenModel>(
+				m =>
+					({
+						id: m.modelId,
+						name: m.modelName,
+						maxTokens: { input: m.maxInputTokens, output: m.maxOutputTokens },
+						provider: provider,
+						default: m.preferred,
+						temperature: null,
+					}) satisfies GitKrakenModel,
+			);
+			return models;
+		} catch (ex) {
+			if (!(ex instanceof AuthenticationRequiredError)) {
+				debugger;
+				scope?.error(ex, `Unable to get models`);
+			}
+		}
+
+		return [];
+	}
+
+	protected getUrl(_model: AIModel<typeof provider.id>): string {
+		return 'chat/completions';
+	}
+
+	protected override getHeaders<TAction extends AIActionType>(
+		action: TAction,
+		apiKey: string,
+		_model: AIModel<typeof provider.id>,
+		_url: string,
+	): Record<string, string> {
+		return {
+			Accept: 'application/json',
+			Authorization: `Bearer ${apiKey}`,
+			'GK-Action': action,
+		};
+	}
+
+	protected override async handleFetchFailure<TAction extends AIActionType>(
+		rsp: Response,
+		_action: TAction,
+		_model: AIModel<typeof provider.id>,
+		retries: number,
+		maxInputTokens: number,
+	): Promise<{ retry: true; maxInputTokens: number }> {
+		type ErrorResponse = {
+			error?: { code: string; message: string; data?: any };
+		};
+
+		let json;
+		try {
+			json = (await rsp.json()) as ErrorResponse | undefined;
+		} catch {}
+
+		let message = json?.error?.message || rsp.statusText;
+
+		let status: string | number;
+		let code: string | number;
+		[status, code] = json?.error?.code?.split('.') ?? [];
+
+		status = status ? parseInt(status, 10) : rsp.status;
+		code = code ? parseInt(code, 10) : 0;
+
+		switch (status) {
+			case 400: // Bad Request
+				// CodeValidation         = "400.1"
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			case 401:
+				// CodeAuthentication     = "401.1"
+				throw new AuthenticationRequiredError();
+			case 403:
+				// CodeAuthorization      = "403.1"
+				// CodeEntitlement        = "403.2"
+				// CodeFeatureDisabled    = "403.3"
+
+				// Entitlement Error
+				if (code === 2) {
+					type EntitlementErrorData = {
+						entitlementId?: string;
+						entitlementValue?: string | number;
+						currentValue?: string | number;
+					};
+
+					const data = json?.error?.data as EntitlementErrorData;
+					const entitlementId = data?.entitlementId;
+					if (entitlementId != null) {
+						message += `; entitlement=${data.entitlementId} ${JSON.stringify(data)}`;
+					}
+
+					throw new AIError(
+						// If there is an `entitlementValue` then we are over the limit, otherwise it is an entitlement error
+						data?.entitlementValue ? AIErrorReason.UserQuotaExceeded : AIErrorReason.NoEntitlement,
+						new Error(`(${this.name}) ${status}.${code}: ${message}`),
+					);
+				} else if (code === 3) {
+					throw new AIError(
+						AIErrorReason.DeniedByOrganization,
+						new Error(`(${this.name}) ${status}.${code}: ${message}`),
+					);
+				}
+				throw new AIError(
+					AIErrorReason.Unauthorized,
+					new Error(`(${this.name}) ${status}.${code}: ${message}`),
+				);
+			case 404:
+				// CodeNotFound           = "404.1"
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			case 408:
+				// CodeTimeout            = "408.1"
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			case 413:
+				// CodeRequestTooLarge    = "413.1"
+
+				// Request too large
+				if (code === 1) {
+					if (retries < 3) {
+						return { retry: true, maxInputTokens: getReducedMaxInputTokens(maxInputTokens, retries + 1) };
+					}
+					throw new AIError(
+						AIErrorReason.RequestTooLarge,
+						new Error(`(${this.name}) ${status}.${code}: ${message}`),
+					);
+				}
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			case 429:
+				// CodeTooManyRequests    = "429.1"
+
+				// Too many requests
+				if (code === 1) {
+					throw new AIError(
+						AIErrorReason.RateLimitExceeded,
+						new Error(`(${this.name}) ${status}.${code}: ${message}`),
+					);
+				}
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			case 499:
+				// CodeRequestCanceled    = "499.1"
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			case 500:
+				// CodeServerError        = "500.1"
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			case 503:
+				// CodeServiceUnavailable = "503.1"
+
+				// Service unavailable
+				if (code === 1) {
+					if (message === 'Agent Error: too many requests') {
+						throw new AIError(
+							AIErrorReason.ServiceCapacityExceeded,
+							new Error(`(${this.name}) ${status}.${code}: ${message}`),
+						);
+					}
+				}
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+			default:
+				throw new Error(`(${this.name}) ${status}.${code}: ${message}`);
+		}
+	}
+}

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

@@ -0,0 +1,51 @@
+import { huggingFaceProviderDescriptor as provider } from '../constants.js';
+import type { AIModel } from '../models/model.js';
+import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js';
+
+type HuggingFaceModel = AIModel<typeof provider.id>;
+
+export class HuggingFaceProvider extends OpenAICompatibleProviderBase<typeof provider.id> {
+	readonly id = provider.id;
+	readonly name = provider.name;
+	protected readonly descriptor = provider;
+	protected readonly config = {
+		keyUrl: 'https://huggingface.co/settings/tokens',
+		keyValidator: /(?:hf_)?[a-zA-Z0-9]{32,}/,
+	};
+
+	async getModels(): Promise<readonly AIModel<typeof provider.id>[]> {
+		const query = new URLSearchParams({
+			filter: 'text-generation,conversational',
+			inference: 'warm',
+			sort: 'trendingScore',
+			limit: '30',
+		});
+		const rsp = await this.context.fetch(`https://huggingface.co/api/models?${query.toString()}`, {
+			headers: {
+				Accept: 'application/json',
+				'Content-Type': 'application/json',
+			},
+			method: 'GET',
+		});
+
+		type ModelsResponse = { id: string }[];
+
+		const results = (await rsp.json()) as ModelsResponse;
+		const models = results.map<HuggingFaceModel>(
+			r =>
+				({
+					id: r.id,
+					name: r.id.split('/').pop()!,
+					maxTokens: { input: 4096, output: 4096 },
+					provider: provider,
+					temperature: null,
+				}) satisfies HuggingFaceModel,
+		);
+
+		return models;
+	}
+
+	protected getUrl(model: AIModel<typeof provider.id>): string {
+		return `https://api-inference.huggingface.co/models/${model.id}/v1/chat/completions`;
+	}
+}

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

@@ -0,0 +1,160 @@
+import { mistralProviderDescriptor as provider } from '../constants.js';
+import { AIError, AIErrorReason } from '../errors.js';
+import type { AIActionType, AIModel } from '../models/model.js';
+import { getReducedMaxInputTokens } from '../utils/ai.utils.js';
+import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js';
+
+type MistralModel = AIModel<typeof provider.id>;
+const models: MistralModel[] = [
+	{
+		id: 'mistral-medium-latest',
+		name: 'Mistral Medium',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'mistral-medium-2505',
+		name: 'Mistral Medium',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'codestral-latest',
+		name: 'Codestral',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		default: true,
+	},
+	{
+		id: 'codestral-2501',
+		name: 'Codestral',
+		maxTokens: { input: 262144, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'mistral-large-latest',
+		name: 'Mistral Large',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'mistral-large-2411',
+		name: 'Mistral Large',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'devstral-small-latest',
+		name: 'Devstral Small',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'devstral-small-2505',
+		name: 'Devstral Small',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+	{
+		id: 'mistral-small-latest',
+		name: 'Mistral Small',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+	},
+	{
+		id: 'mistral-small-2503',
+		name: 'Mistral Small',
+		maxTokens: { input: 131072, output: 4096 },
+		provider: provider,
+		hidden: true,
+	},
+];
+
+export class MistralProvider extends OpenAICompatibleProviderBase<typeof provider.id> {
+	readonly id = provider.id;
+	readonly name = provider.name;
+	protected readonly descriptor = provider;
+	protected readonly config = {
+		keyUrl: 'https://console.mistral.ai/api-keys',
+		keyValidator: /^[a-zA-Z0-9]{32}$/,
+	};
+
+	getModels(): Promise<readonly AIModel<typeof provider.id>[]> {
+		return Promise.resolve(models);
+	}
+
+	protected getUrl(_model: AIModel<typeof provider.id>): string {
+		return 'https://api.mistral.ai/v1/chat/completions';
+	}
+
+	protected override fetchCore<TAction extends AIActionType>(
+		action: TAction,
+		model: AIModel<typeof provider.id>,
+		apiKey: string,
+		request: object,
+		signal: AbortSignal | undefined,
+	): Promise<Response> {
+		if ('max_completion_tokens' in request) {
+			const { max_completion_tokens: max, ...rest } = request;
+			request = max ? { max_tokens: max, ...rest } : rest;
+		}
+		return super.fetchCore(action, model, apiKey, request, signal);
+	}
+
+	protected override async handleFetchFailure<TAction extends AIActionType>(
+		rsp: Response,
+		action: TAction,
+		model: AIModel<typeof provider.id>,
+		retries: number,
+		maxInputTokens: number,
+	): Promise<{ retry: true; maxInputTokens: number }> {
+		if (rsp.status !== 404 && rsp.status !== 429) {
+			let json;
+			try {
+				json = (await rsp.json()) as MistralError | undefined;
+			} catch {}
+
+			debugger;
+
+			const message = `${json?.type}: ${json?.message?.detail
+				?.map(d => `${d.msg} (${d.type} @ ${d.loc.join(',')})`)
+				.join(', ')}`;
+
+			if (json?.type === 'invalid_request_error') {
+				if (message?.includes('prompt is too long')) {
+					if (retries < 3) {
+						return { retry: true, maxInputTokens: getReducedMaxInputTokens(maxInputTokens, retries + 1) };
+					}
+
+					throw new AIError(
+						AIErrorReason.RequestTooLarge,
+						new Error(`(${this.name}) ${rsp.status}: ${message || rsp.statusText}`),
+					);
+				}
+			}
+
+			throw new Error(`(${this.name}) ${rsp.status}: ${message || rsp.statusText}`);
+		}
+
+		return super.handleFetchFailure(rsp, action, model, retries, maxInputTokens);
+	}
+}
+
+interface MistralError {
+	object: 'error';
+	type: 'invalid_request_error' | string;
+	message: {
+		detail: {
+			type: string;
+			msg: string;
+			loc: string[];
+			input: number;
+		}[];
+	};
+	code: unknown | null;
+	param: unknown | null;
+}