@gitkraken/core-gitlens 0.4.0 → 0.4.101

package/src/utils/iterable.ts

@@ -113,9 +113,7 @@ class ConcatIterator<T> implements IterableIterator<T> {
 
 		while (this.sourceIndex < this.sources.length) {
 			// Initialize iterator for current source if needed
-			if (this.currentIterator === undefined) {
-				this.currentIterator = this.sources[this.sourceIndex][Symbol.iterator]();
-			}
+			this.currentIterator ??= this.sources[this.sourceIndex][Symbol.iterator]();
 
 			const result = this.currentIterator.next();
 			if (!result.done) {
@@ -708,9 +706,7 @@ class UnionIterator<T> implements IterableIterator<T> {
 			}
 
 			// Initialize iterator for current source if needed
-			if (this.currentIterator === undefined) {
-				this.currentIterator = source[Symbol.iterator]();
-			}
+			this.currentIterator ??= source[Symbol.iterator]();
 
 			const result = this.currentIterator.next();
 			if (!result.done) {

package/src/utils/logger.scoped.ts

@@ -35,7 +35,7 @@ export function createLogScope(scopeId: number, prevScopeId: number | undefined,
 	let exitDetails: string[] | undefined;
 	let exitFailed: string | undefined;
 
-	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+	// oxlint-disable-next-line typescript/consistent-type-assertions
 	const scope: ScopedLogger = {
 		scopeId: scopeId,
 		prevScopeId: prevScopeId,

package/src/utils/logger.ts

@@ -217,7 +217,7 @@ class Logger {
 
 		const errorMessage = `  ${message ?? ''}${this.#toLoggableParams(false, params)}`;
 		if (ex != null) {
-			// eslint-disable-next-line @typescript-eslint/no-base-to-string
+			// oxlint-disable-next-line typescript/no-base-to-string
 			this.#output?.error(String(ex), errorMessage);
 		} else {
 			this.#output?.error(errorMessage);

package/src/utils/paging.ts

@@ -4,6 +4,26 @@ export interface PagedResult<T> {
 	readonly paging?: {
 		readonly cursor: string;
 		readonly more: boolean;
+		/**
+		 * True when the results may be incomplete in a way that following `cursor` won't resolve. Two sources:
+		 * a read that fetched a single default page and can't report `hasNextPage` (no cursor to follow at all),
+		 * or a multi-scope read where a sibling scope failed (`partial`/`unknown` completeness) even though the
+		 * current scope still exposes a real next page. `truncated` is therefore independent of `more`: `more`
+		 * means "there is a next page you can fetch with `cursor`"; `truncated` means "content may be missing
+		 * that paging alone won't recover." Consumers should surface this as a truncation signal rather than
+		 * treating the result as complete, and should not assume `truncated` implies `more` is false.
+		 */
+		readonly truncated?: boolean;
+		/** 1-based page that produced this result. Populated by numbered-page providers only. */
+		readonly page?: number;
+		/** Items requested per page, when known. */
+		readonly pageSize?: number;
+		/** Next page number, when the provider pages by number. */
+		readonly nextPage?: number;
+		/** Total number of pages, when the provider reports totals. */
+		readonly totalPages?: number;
+		/** Total number of items across all pages, when the provider reports totals. */
+		readonly totalCount?: number;
 	};
 	readonly values: NonNullable<T>[];
 }
@@ -13,6 +33,10 @@ export const emptyPagedResult: PagedResult<any> = Object.freeze({ values: [] });
 
 export interface PagingOptions {
 	cursor?: string;
+	/** 1-based page to request from numbered-page providers. */
+	page?: number;
+	/** Items to request per page (numbered-page providers, and GitHub's cursor pages). */
+	pageSize?: number;
 }
 
 export class PageableResult<T> {
@@ -49,3 +73,25 @@ export class PageableResult<T> {
 		}
 	}
 }
+
+/**
+ * Drains a paged fetcher into a single array, following `paging.cursor` until exhausted. Bounded by
+ * `maxPages` (default 20) as a backstop against a provider that never stops paging.
+ */
+export async function collectPagedResults<T>(
+	fetch: (cursor: string | undefined) => Promise<PagedResult<T> | undefined>,
+	maxPages = 20,
+): Promise<NonNullable<T>[]> {
+	const all: NonNullable<T>[] = [];
+	let cursor: string | undefined;
+	for (let page = 0; page < maxPages; page++) {
+		const result = await fetch(cursor);
+		if (result == null) break;
+
+		all.push(...result.values);
+		if (!result.paging?.more || result.paging.cursor === cursor) break;
+
+		cursor = result.paging.cursor;
+	}
+	return all;
+}

package/src/utils/promise.ts

@@ -91,6 +91,36 @@ export async function batchResults<T, R>(
 	return results;
 }
 
+/**
+ * `Promise.all(items.map(task))` with at most `concurrency` tasks in flight. Unlike {@link batchResults} this is
+ * a sliding window rather than a barrier per batch, so a slow item doesn't idle the rest of the window. Results
+ * are returned in input order and the first rejection propagates, matching `Promise.all`.
+ *
+ * Use it for a fan-out whose width is data-driven (one task per org/project/provider): unbounded `Promise.all`
+ * over such a list opens as many concurrent upstream requests as there are items, which invites provider rate
+ * limiting and socket exhaustion.
+ */
+export async function mapBounded<T, R>(
+	items: readonly T[],
+	concurrency: number,
+	task: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+	const limit = Math.max(1, Math.trunc(concurrency));
+	if (items.length <= limit) return Promise.all(items.map((item, index) => task(item, index)));
+
+	const results = new Array<R>(items.length);
+	let next = 0;
+
+	async function worker(): Promise<void> {
+		for (let index = next++; index < items.length; index = next++) {
+			results[index] = await task(items[index], index);
+		}
+	}
+
+	await Promise.all(Array.from({ length: limit }, () => worker()));
+	return results;
+}
+
 export class PromiseCancelledError<T extends Promise<any> = Promise<any>> extends Error {
 	constructor(
 		public readonly promise: T,
@@ -177,7 +207,7 @@ export function cancellable<T>(
 				disposeCancellation?.dispose();
 				disposeTimeout?.dispose();
 
-				// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+				// oxlint-disable-next-line typescript/prefer-promise-reject-errors
 				reject(ex);
 			},
 		);
@@ -222,7 +252,7 @@ export function getDeferredPromiseIfPending<T>(deferred: Deferred<T> | undefined
 export type MaybePromiseArr<T> = (Promise<T | undefined> | T | undefined)[];
 
 export async function nonnullSettled<T>(arr: MaybePromiseArr<T>): Promise<T[]> {
-	// eslint-disable-next-line @typescript-eslint/await-thenable
+	// oxlint-disable-next-line typescript/await-thenable
 	const all = await Promise.allSettled(arr);
 	return all.map(r => getSettledValue(r)).filter(v => v != null);
 }
@@ -485,7 +515,7 @@ export async function pauseOnCancelOrTimeoutMapTuple<Id, T, U extends unknown[]>
 	}
 
 	const results = await Promise.all(
-		// eslint-disable-next-line @typescript-eslint/await-thenable
+		// oxlint-disable-next-line typescript/await-thenable
 		map(source, ([id, [promise, ...rest]]) =>
 			promise == null
 				? ([id, [undefined, ...rest]] as const)

package/src/utils/promiseCache.ts

@@ -1,5 +1,13 @@
 import { AbortAggregate, CancellationError, raceWithSignal } from './cancellation.js';
 
+/** Deletes `key` from `map` only if it still maps to `owner`. A `delete(key)` + fresh `getOrCreate` can install
+ *  a successor under the same key while our factory is in flight; our late settle must not evict the successor. */
+function deleteIfOwned<K, V>(map: Map<K, V>, key: K, owner: V): void {
+	if (map.get(key) === owner) {
+		map.delete(key);
+	}
+}
+
 interface CacheEntry<V> {
 	promise: Promise<V>;
 	accessed: number;
@@ -48,17 +56,20 @@ export class PromiseCache<K, V> {
 		this.options = { expireOnError: true, ...options };
 	}
 
+	/** Clears all entries. Like `delete`, does NOT dispose in-flight abort aggregates — that would detach a running
+	 *  op's cancellation (a later caller-abort couldn't cancel it); each factory's settle handler disposes its own. */
 	clear(): void {
-		for (const a of this.aborts.values()) {
-			a.dispose();
-		}
 		this.aborts.clear();
 		this.controllers.clear();
 		this.cache.clear();
 	}
 
+	/**
+	 * Removes a promise from the cache.
+	 *  Does NOT dispose the abort aggregate: while a factory is in flight, disposing would detach
+	 *  its callers' cancellation and orphan the underlying op (a later caller-abort could no longer cancel the
+	 *  running `git status`). The factory's own settle handler disposes the aggregate (see `getOrCreate`). */
 	delete(key: K): void {
-		this.aborts.get(key)?.dispose();
 		this.aborts.delete(key);
 		this.controllers.delete(key);
 		this.cache.delete(key);
@@ -154,13 +165,15 @@ export class PromiseCache<K, V> {
 
 		let entry = this.cache.get(key);
 		if (entry != null && !this.expired(entry, now)) {
-			// Update accessed time
-			entry.accessed = now;
-
-			// Cache hit — register this caller on the existing aggregate
+			// Cache hit — but don't join an entry whose aggregate has already permanently aborted (all prior
+			// callers cancelled, so the shared run is failing): that would hand this caller a doomed promise.
+			// Fall through to create a fresh entry; the doomed entry's late settle is `deleteIfOwned`-guarded.
 			const existingAborts = this.aborts.get(key);
-			const cleanup = existingAborts != null ? existingAborts.add(cancellation) : undefined;
-			return this.attachCallerLifecycle(entry.promise, cancellation, cleanup);
+			if (existingAborts == null || !existingAborts.signal.aborted) {
+				entry.accessed = now;
+				const cleanup = existingAborts != null ? existingAborts.add(cancellation) : undefined;
+				return this.attachCallerLifecycle(entry.promise, cancellation, cleanup);
+			}
 		}
 
 		const cacheable = new CacheController();
@@ -174,12 +187,14 @@ export class PromiseCache<K, V> {
 		const promise = factory(cacheable, abortAgg.signal);
 		void promise
 			.finally(() => {
+				// All three deletes are ownership-guarded — a hard `delete(key)` + fresh `getOrCreate` while our
+				// factory is in flight installs a successor under `key`; our late settle must not evict it.
 				if (cacheable.invalidated) {
-					this.cache.delete(key);
+					deleteIfOwned(this.cache, key, entry!);
 				}
 				abortAgg.dispose();
-				this.aborts.delete(key);
-				this.controllers.delete(key);
+				deleteIfOwned(this.aborts, key, abortAgg);
+				deleteIfOwned(this.controllers, key, cacheable);
 			})
 			// Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
 			// separate from the caller-facing promise's own handling (e.g. on cancellation).
@@ -189,20 +204,27 @@ export class PromiseCache<K, V> {
 			// Wrap the promise to handle errors with the onError callback
 			const errorHandled = promise.catch((ex: unknown) => {
 				const result = options.onError!(ex);
+				// A hard `delete(key)` + fresh `getOrCreate` while we were in flight installs a successor;
+				// don't clobber it. But an EMPTY key (our entry already evicted, e.g. by the invalidated-finally)
+				// still takes the fallback — preserving base behavior of caching the error fallback.
+				const occupant = this.cache.get(key);
+				const clobbersSuccessor = occupant != null && occupant !== entry;
 				if (result != null) {
 					// Replace the entry with a resolved fallback value for subsequent callers
-					const errorNow = Date.now();
-					this.cache.set(key, {
-						promise: Promise.resolve(result.value),
-						created: errorNow,
-						accessed: errorNow,
-						createTTL: result.createTTL ?? options.createTTL,
-						accessTTL: options.accessTTL,
-					});
+					if (!clobbersSuccessor) {
+						const errorNow = Date.now();
+						this.cache.set(key, {
+							promise: Promise.resolve(result.value),
+							created: errorNow,
+							accessed: errorNow,
+							createTTL: result.createTTL ?? options.createTTL,
+							accessTTL: options.accessTTL,
+						});
+					}
 					// suppress: return fallback to first caller; otherwise re-throw
 					if (result.suppress) return result.value;
 				} else {
-					this.cache.delete(key);
+					deleteIfOwned(this.cache, key, entry!);
 				}
 				throw ex;
 			});
@@ -219,14 +241,18 @@ export class PromiseCache<K, V> {
 			// Cache resolved undefined for subsequent callers, re-throw to first caller
 			const errorTTL = options.errorTTL;
 			const errorHandled = promise.catch((ex: unknown) => {
-				const errorNow = Date.now();
-				this.cache.set(key, {
-					promise: Promise.resolve(undefined as V),
-					created: errorNow,
-					accessed: errorNow,
-					createTTL: errorTTL,
-					accessTTL: options.accessTTL,
-				});
+				// Overwrite unless a successor now owns the key (empty key still takes it — see onError above).
+				const occupant = this.cache.get(key);
+				if (occupant == null || occupant === entry) {
+					const errorNow = Date.now();
+					this.cache.set(key, {
+						promise: Promise.resolve(undefined as V),
+						created: errorNow,
+						accessed: errorNow,
+						createTTL: errorTTL,
+						accessTTL: options.accessTTL,
+					});
+				}
 				throw ex;
 			});
 
@@ -249,7 +275,10 @@ export class PromiseCache<K, V> {
 			this.cache.set(key, entry);
 
 			if (options?.expireOnError ?? true) {
-				promise.catch(() => this.cache.delete(key));
+				// Ownership-guarded: a hard `delete(key)` + fresh `getOrCreate` replacing us while in flight must
+				// not have its entry evicted by our rejection.
+				const ourEntry = entry;
+				promise.catch(() => deleteIfOwned(this.cache, key, ourEntry));
 			}
 		}
 
@@ -339,7 +368,7 @@ export class PromiseCache<K, V> {
 		this.cache.set(key, entry);
 
 		if (this.options.expireOnError ?? true) {
-			promise.catch(() => this.cache.delete(key));
+			promise.catch(() => deleteIfOwned(this.cache, key, entry));
 		}
 	}
 }
@@ -379,10 +408,14 @@ export class PromiseMap<K, V> {
 
 		const cached = this.cache.get(key);
 		if (cached != null) {
-			// Cache hit — register this caller on the existing aggregate
-			const aborts = this.aborts.get(key);
-			const cleanup = aborts != null ? aborts.add(cancellation) : undefined;
-			return this.attachCallerLifecycle(cached, cancellation, cleanup);
+			// Cache hit — but don't join an entry whose aggregate has already permanently aborted (all prior
+			// callers cancelled, so the shared run is failing): joining hands this caller a doomed promise.
+			// Fall through to a fresh entry; the doomed entry's late settle is `deleteIfOwned`-guarded.
+			const existingAborts = this.aborts.get(key);
+			if (existingAborts == null || !existingAborts.signal.aborted) {
+				const cleanup = existingAborts != null ? existingAborts.add(cancellation) : undefined;
+				return this.attachCallerLifecycle(cached, cancellation, cleanup);
+			}
 		}
 
 		// Cache miss — always create the aggregate so subsequent callers (with or without signals)
@@ -395,16 +428,16 @@ export class PromiseMap<K, V> {
 
 		const promise = factory(cacheable, aborts.signal);
 
-		// Automatically remove failed promises from the cache
-		promise.catch(() => this.cache.delete(key));
+		// Automatically remove failed promises from the cache (ownership-guarded — see `deleteIfOwned`).
+		promise.catch(() => deleteIfOwned(this.cache, key, promise));
 		void promise
 			.finally(() => {
 				if (cacheable.invalidated) {
-					this.cache.delete(key);
+					deleteIfOwned(this.cache, key, promise);
 				}
 				aborts.dispose();
-				this.aborts.delete(key);
-				this.controllers.delete(key);
+				deleteIfOwned(this.aborts, key, aborts);
+				deleteIfOwned(this.controllers, key, cacheable);
 			})
 			// Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
 			// separate from the caller-facing promise's own handling (e.g. on cancellation).
@@ -461,10 +494,8 @@ export class PromiseMap<K, V> {
 	set(key: K, promise: Promise<V>): this {
 		this.cache.set(key, promise);
 
-		// Automatically remove failed promises from the cache
-		promise.catch(() => {
-			this.cache.delete(key);
-		});
+		// Automatically remove failed promises from the cache (ownership-guarded — see `deleteIfOwned`).
+		promise.catch(() => deleteIfOwned(this.cache, key, promise));
 
 		return this;
 	}
@@ -478,21 +509,20 @@ export class PromiseMap<K, V> {
 
 	/**
 	 * Removes a key from the cache.
-	 */
+	 *  Does NOT dispose the abort aggregate: while a factory is in flight, disposing would detach
+	 *  its callers' cancellation and orphan the underlying op (a later caller-abort could no longer cancel the
+	 *  running `git status`). The factory's own settle handler disposes the aggregate (see `getOrCreate`). */
 	delete(key: K): boolean {
-		this.aborts.get(key)?.dispose();
 		this.aborts.delete(key);
 		this.controllers.delete(key);
 		return this.cache.delete(key);
 	}
 
 	/**
-	 * Clears all entries from the cache.
+	 * Clears all entries. Like `delete`, does NOT dispose in-flight abort aggregates — that would detach a running
+	 * op's cancellation (a later caller-abort couldn't cancel it); each factory's settle handler disposes its own.
 	 */
 	clear(): void {
-		for (const a of this.aborts.values()) {
-			a.dispose();
-		}
 		this.aborts.clear();
 		this.controllers.clear();
 		this.cache.clear();

package/src/utils/searchTree.ts

@@ -4,7 +4,6 @@ import { compareSubstring, compareSubstringIgnoreCase } from './string.js';
 
 const FIN = { done: true, value: undefined };
 
-// eslint-disable-next-line @typescript-eslint/naming-convention
 export interface IKeyIterator<K> {
 	reset(key: K): this;
 	next(): this;
@@ -279,12 +278,15 @@ export class TernarySearchTree<K, V> {
 			} else if (iter.hasNext()) {
 				// mid
 				iter.next();
+				// Generic value may be falsy — keep truthy-wins semantics; don't narrow to `??`
+				// oxlint-disable-next-line typescript/prefer-nullish-coalescing
 				candidate = node.value || candidate;
 				node = node.mid;
 			} else {
 				break;
 			}
 		}
+		// oxlint-disable-next-line typescript/prefer-nullish-coalescing -- generic value may be falsy; keep `||`
 		return node?.value || candidate;
 	}
 
@@ -311,7 +313,7 @@ export class TernarySearchTree<K, V> {
 
 				node = node.mid;
 				return {
-					// eslint-disable-next-line no-loop-func
+					// oxlint-disable-next-line no-loop-func
 					[Symbol.iterator]: () => this._nodeIterator(node!, limit),
 				};
 			}

package/src/utils/string.ts

@@ -695,7 +695,7 @@ export async function interpolateAsync(template: string, context: object | undef
 			value = await value;
 		}
 
-		// eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+		// oxlint-disable-next-line typescript/restrict-plus-operands
 		result += template.slice(position, token.start) + (value ?? '');
 		position = token.end;
 	}

package/src/utils/trie.ts

@@ -455,6 +455,7 @@ export class PathTrie<T> {
 		}
 
 		if (node?.children == null) return [];
+		// oxlint-disable-next-line typescript/prefer-nullish-coalescing -- generic value may be falsy; `||` drops falsy entries by design
 		return [...filterMap(node.children.values(), n => n.value || undefined)];
 	}
 

package/dist/plus/ai/providers/githubModelsProvider.d.ts

@@ -1,19 +0,0 @@
-import { githubProviderDescriptor as provider } from '../constants.js';
-import type { AIActionType, AIModel } from '../models/model.js';
-import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js';
-export declare class GitHubModelsProvider extends OpenAICompatibleProviderBase<typeof provider.id> {
-    readonly id: "github";
-    readonly name: string;
-    protected readonly descriptor: import("../models/model.js").AIProviderDescriptor<"github">;
-    protected readonly config: {
-        keyUrl: string;
-        keyValidator: RegExp;
-    };
-    getModels(): Promise<readonly AIModel<typeof provider.id>[]>;
-    protected getUrl(_model: AIModel<typeof provider.id>): string;
-    handleFetchFailure(rsp: Response, action: AIActionType, model: AIModel<typeof provider.id>, retries: number, maxInputTokens: number): Promise<{
-        retry: true;
-        maxInputTokens: number;
-    }>;
-}
-//# sourceMappingURL=githubModelsProvider.d.ts.map

package/dist/plus/ai/providers/githubModelsProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"githubModelsProvider.d.ts","sourceRoot":"","sources":["../../src/providers/githubModelsProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,IAAI,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAEhE,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AAIjF,qBAAa,oBAAqB,SAAQ,4BAA4B,CAAC,OAAO,QAAQ,CAAC,EAAE,CAAC;IACzF,QAAQ,CAAC,EAAE,WAAe;IAC1B,QAAQ,CAAC,IAAI,SAAiB;IAC9B,SAAS,CAAC,QAAQ,CAAC,UAAU,8DAAY;IACzC,SAAS,CAAC,QAAQ,CAAC,MAAM;;;MAGvB;IAEI,SAAS,IAAI,OAAO,CAAC,SAAS,OAAO,CAAC,OAAO,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;IAsClE,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,QAAQ,CAAC,EAAE,CAAC,GAAG,MAAM;IAI9C,kBAAkB,CAChC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,OAAO,CAAC,OAAO,QAAQ,CAAC,EAAE,CAAC,EAClC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GACpB,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC;CA0BnD"}

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

@@ -1,51 +0,0 @@
-import { githubProviderDescriptor as provider } from '../constants.js';
-import { AIError, AIErrorReason } from '../errors.js';
-import { getReducedMaxInputTokens } from '../utils/ai.utils.js';
-import { OpenAICompatibleProviderBase } from './openAICompatibleProviderBase.js';
-export class GitHubModelsProvider extends OpenAICompatibleProviderBase {
-    id = provider.id;
-    name = provider.name;
-    descriptor = provider;
-    config = {
-        keyUrl: 'https://github.com/settings/tokens',
-        keyValidator: /(?:ghp-)?[a-zA-Z0-9]{32,}/,
-    };
-    async getModels() {
-        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' },
-        });
-        const result = (await rsp.json());
-        const models = result.results.map(m => ({
-            id: m.name,
-            name: m.friendly_name,
-            maxTokens: { input: m.max_input_tokens, output: m.max_output_tokens },
-            provider: provider,
-            temperature: null,
-        }));
-        return models;
-    }
-    getUrl(_model) {
-        return 'https://models.inference.ai.azure.com/chat/completions';
-    }
-    async handleFetchFailure(rsp, action, model, retries, maxInputTokens) {
-        if (rsp.status !== 404 && rsp.status !== 429) {
-            let json;
-            try {
-                json = (await rsp.json());
-            }
-            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);
-    }
-}
-//# sourceMappingURL=githubModelsProvider.js.map

package/dist/plus/ai/providers/githubModelsProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"githubModelsProvider.js","sourceRoot":"","sources":["../../src/providers/githubModelsProvider.ts"],"names":[],"mappings":"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"}

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

@@ -1,92 +0,0 @@
-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);
-	}
-}