@bytetrue/pi-vendor 0.1.0

package/src/official-catalog.ts

@@ -0,0 +1,194 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import type { ProviderModelConfig } from "./models-json.js";
+
+export type OfficialModelConfig = Record<string, unknown> & {
+	id: string;
+	name?: string;
+	api?: string;
+	provider?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	apiKey?: string;
+	authHeader?: boolean;
+	contextWindow?: number;
+	maxTokens?: number;
+};
+
+export type OfficialModelsCatalog = Record<string, Record<string, OfficialModelConfig>>;
+
+export type OfficialModelCandidate = {
+	provider: string;
+	model: OfficialModelConfig;
+};
+
+const STRIPPED_FIELDS = ["provider", "baseUrl", "headers", "apiKey", "authHeader"] as const;
+
+function cloneJson<T>(value: T): T {
+	return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function resolvePackageRoot(startDir: string): string | null {
+	let current = startDir;
+	for (;;) {
+		try {
+			const pkg = JSON.parse(readFileSync(join(current, "package.json"), "utf8")) as { name?: string };
+			if (pkg.name === "@earendil-works/pi-coding-agent") {
+				return current;
+			}
+		} catch {
+			// keep walking
+		}
+
+		const parent = dirname(current);
+		if (parent === current) {
+			return null;
+		}
+		current = parent;
+	}
+}
+
+function resolveCandidateRoots(): string[] {
+	const roots = new Set<string>();
+
+	try {
+		const resolvedUrl = import.meta.resolve("@earendil-works/pi-coding-agent");
+		if (resolvedUrl.startsWith("file://")) {
+			const root = resolvePackageRoot(dirname(fileURLToPath(resolvedUrl)));
+			if (root) roots.add(root);
+		}
+	} catch {
+		// ignore
+	}
+
+	const localRoot = resolvePackageRoot(dirname(fileURLToPath(import.meta.url)));
+	if (localRoot) roots.add(localRoot);
+
+	return [...roots];
+}
+
+function candidateCatalogPaths(): string[] {
+	const paths = new Set<string>();
+	for (const root of resolveCandidateRoots()) {
+		paths.add(join(root, "node_modules", "@earendil-works", "pi-ai", "dist", "models.generated.js"));
+
+		let current = root;
+		for (;;) {
+			paths.add(
+				join(current, "node_modules", "@earendil-works", "pi-coding-agent", "node_modules", "@earendil-works", "pi-ai", "dist", "models.generated.js"),
+			);
+			const parent = dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+	return [...paths];
+}
+
+let cachedCatalogPath: string | null = null;
+let cachedCatalog: OfficialModelsCatalog | null = null;
+
+export function findOfficialCatalogPath(): string | null {
+	for (const candidate of candidateCatalogPaths()) {
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+
+export async function loadOfficialCatalog(): Promise<OfficialModelsCatalog | null> {
+	const path = findOfficialCatalogPath();
+	if (!path) {
+		cachedCatalogPath = null;
+		cachedCatalog = null;
+		return null;
+	}
+	if (cachedCatalogPath === path) return cachedCatalog;
+
+	try {
+		const mod = await import(pathToFileURL(path).href);
+		const catalog = mod.MODELS as OfficialModelsCatalog | undefined;
+		if (!catalog || typeof catalog !== "object") {
+			return null;
+		}
+		cachedCatalogPath = path;
+		cachedCatalog = catalog;
+		return cachedCatalog;
+	} catch {
+		return null;
+	}
+}
+
+export function collectOfficialCandidates(catalog: OfficialModelsCatalog | null | undefined, modelId: string): OfficialModelCandidate[] {
+	if (!catalog) return [];
+
+	const matches: OfficialModelCandidate[] = [];
+	for (const [provider, providerModels] of Object.entries(catalog)) {
+		const model = providerModels?.[modelId];
+		if (model && typeof model === "object" && !Array.isArray(model) && typeof model.id === "string") {
+			matches.push({ provider, model: cloneJson(model) as OfficialModelConfig });
+		}
+	}
+	return matches;
+}
+
+export type OfficialModelEntry = {
+	provider: string;
+	modelId: string;
+	model: OfficialModelConfig;
+};
+
+export type OfficialModelGroup = {
+	modelId: string;
+	entries: OfficialModelEntry[];
+};
+
+export function listAllOfficialModels(catalog: OfficialModelsCatalog | null | undefined): OfficialModelEntry[] {
+	if (!catalog) return [];
+
+	const entries: OfficialModelEntry[] = [];
+	for (const [provider, providerModels] of Object.entries(catalog)) {
+		for (const [modelId, model] of Object.entries(providerModels)) {
+			if (model && typeof model === "object" && !Array.isArray(model) && typeof model.id === "string") {
+				entries.push({ provider, modelId, model: cloneJson(model) as OfficialModelConfig });
+			}
+		}
+	}
+	return entries;
+}
+
+export function groupOfficialModelsById(entries: OfficialModelEntry[]): OfficialModelGroup[] {
+	const groups: OfficialModelGroup[] = [];
+	const byId = new Map<string, OfficialModelGroup>();
+
+	for (const entry of entries) {
+		let group = byId.get(entry.modelId);
+		if (!group) {
+			group = { modelId: entry.modelId, entries: [] };
+			byId.set(entry.modelId, group);
+			groups.push(group);
+		}
+		group.entries.push(entry);
+	}
+
+	return groups;
+}
+
+export function stripOfficialRoutingFields(model: OfficialModelConfig): ProviderModelConfig {
+	const next = cloneJson(model) as ProviderModelConfig;
+	for (const field of STRIPPED_FIELDS) {
+		delete next[field];
+	}
+	return next;
+}
+
+export function formatOfficialCandidate(candidate: OfficialModelCandidate): string {
+	const name = typeof candidate.model.name === "string" && candidate.model.name.trim() && candidate.model.name !== candidate.model.id ? candidate.model.name.trim() : undefined;
+	const api = typeof candidate.model.api === "string" && candidate.model.api.trim() ? candidate.model.api.trim() : undefined;
+	const contextWindow = typeof candidate.model.contextWindow === "number" ? `ctx ${candidate.model.contextWindow}` : undefined;
+	const maxTokens = typeof candidate.model.maxTokens === "number" ? `max ${candidate.model.maxTokens}` : undefined;
+	const meta = [api, contextWindow, maxTokens].filter(Boolean).join(", ");
+	const head = name ? `${candidate.provider}/${candidate.model.id} - ${name}` : `${candidate.provider}/${candidate.model.id}`;
+	return meta ? `${head} (${meta})` : head;
+}

package/src/openai-models.ts

@@ -0,0 +1,91 @@
+export type OpenAIModelsProviderDraft = {
+	baseUrl?: string;
+	apiKey?: string;
+};
+
+export type FetchLike = (input: string, init?: { method?: string; headers?: Record<string, string> }) => Promise<{
+	ok: boolean;
+	status: number;
+	statusText: string;
+	json(): Promise<unknown>;
+}>;
+
+export function buildOpenAIModelsUrl(baseUrl: string): string {
+	const url = new URL(baseUrl);
+	if (!url.pathname.endsWith("/")) {
+		url.pathname += "/";
+	}
+	return new URL("models", url).toString();
+}
+
+export function resolveApiKeyValue(apiKey: string, env: NodeJS.ProcessEnv = process.env): { value: string; source: "literal" | "env" } {
+	const trimmed = apiKey.trim();
+	if (!trimmed) {
+		throw new Error("Missing API key");
+	}
+
+	const match = trimmed.match(/^\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))$/);
+	if (!match) {
+		return { value: trimmed, source: "literal" };
+	}
+
+	const name = match[1] ?? match[2];
+	if (!name) {
+		throw new Error("Missing API key");
+	}
+	const value = env[name];
+	if (typeof value !== "string" || !value.trim()) {
+		throw new Error(`Environment variable ${name} is not set`);
+	}
+	return { value: value.trim(), source: "env" };
+}
+export function parseOpenAIModelsResponse(payload: unknown): string[] {
+	if (!payload || typeof payload !== "object") return [];
+	const data = (payload as { data?: unknown }).data;
+	if (!Array.isArray(data)) return [];
+
+	const ids = new Set<string>();
+	for (const entry of data) {
+		if (!entry || typeof entry !== "object") continue;
+		const id = (entry as { id?: unknown }).id;
+		if (typeof id === "string" && id.trim()) {
+			ids.add(id.trim());
+		}
+	}
+	return [...ids].sort((a, b) => a.localeCompare(b));
+}
+
+export async function fetchOpenAIModelIds(
+	provider: OpenAIModelsProviderDraft,
+	fetchImpl: FetchLike = globalThis.fetch as unknown as FetchLike,
+): Promise<string[]> {
+	if (!provider.baseUrl?.trim()) {
+		throw new Error("Missing provider base URL");
+	}
+	if (!provider.apiKey?.trim()) {
+		throw new Error("Missing provider API key");
+	}
+
+	const { value: apiKey } = resolveApiKeyValue(provider.apiKey);
+	const endpoint = buildOpenAIModelsUrl(provider.baseUrl.trim());
+	const response = await fetchImpl(endpoint, {
+		method: "GET",
+		headers: {
+			Authorization: `Bearer ${apiKey}`,
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to fetch ${endpoint}: ${response.status} ${response.statusText}`.trim());
+	}
+
+	let payload: unknown;
+	try {
+		payload = await response.json();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to parse ${endpoint} response: ${message}`);
+	}
+
+	return parseOpenAIModelsResponse(payload);
+}

package/src/templates.ts

@@ -0,0 +1,120 @@
+import type { ProviderModelConfig } from "./models-json.js";
+
+export type ModelTemplate = {
+	id?: string;
+	prefix?: string;
+	name?: string;
+	reasoning?: boolean;
+	input?: Array<"text" | "image">;
+	contextWindow?: number;
+	maxTokens?: number;
+	cost?: Record<string, number>;
+	compat?: Record<string, unknown>;
+	thinkingLevelMap?: Record<string, string | null>;
+};
+
+export const MODEL_TEMPLATES: readonly ModelTemplate[] = [
+	{
+		id: "gpt-4o",
+		name: "GPT-4o",
+		reasoning: true,
+		input: ["text", "image"],
+		contextWindow: 128000,
+		maxTokens: 16384,
+		compat: {
+			supportsReasoningEffort: true,
+		},
+	},
+	{
+		prefix: "gpt-4",
+		name: "GPT-4 family",
+		reasoning: true,
+		input: ["text", "image"],
+		contextWindow: 128000,
+		maxTokens: 16384,
+	},
+	{
+		prefix: "claude-3.7",
+		name: "Claude 3.7 family",
+		reasoning: true,
+		input: ["text", "image"],
+		contextWindow: 200000,
+		maxTokens: 8192,
+	},
+	{
+		prefix: "gemini-2.5",
+		name: "Gemini 2.5 family",
+		reasoning: true,
+		input: ["text", "image"],
+		contextWindow: 1000000,
+		maxTokens: 8192,
+	},
+	{
+		prefix: "deepseek-v3",
+		name: "DeepSeek V3 family",
+		reasoning: true,
+		input: ["text"],
+		contextWindow: 128000,
+		maxTokens: 16384,
+	},
+] as const;
+
+function cloneJson<T>(value: T): T {
+	return JSON.parse(JSON.stringify(value)) as T;
+}
+
+export function listModelTemplates(): ModelTemplate[] {
+	return MODEL_TEMPLATES.map((template) => cloneJson(template));
+}
+
+export function templateLabel(template: ModelTemplate): string {
+	if (template.id) {
+		return template.name && template.name !== template.id ? `${template.id} - ${template.name}` : template.id;
+	}
+	if (template.prefix) {
+		return template.name ? `${template.prefix}* - ${template.name}` : `${template.prefix}*`;
+	}
+	return template.name ?? "template";
+}
+
+export function matchTemplate(modelId: string, templates: readonly ModelTemplate[] = MODEL_TEMPLATES): ModelTemplate | undefined {
+	const exact = templates.find((template) => template.id === modelId);
+	if (exact) return exact;
+
+	let best: ModelTemplate | undefined;
+	let bestLength = -1;
+	for (const template of templates) {
+		if (!template.prefix) continue;
+		if (!modelId.startsWith(template.prefix)) continue;
+		if (template.prefix.length > bestLength) {
+			best = template;
+			bestLength = template.prefix.length;
+		}
+	}
+	return best;
+}
+
+export function createTemplateModelConfig(modelId: string, template: ModelTemplate): ProviderModelConfig {
+	return {
+		id: modelId,
+		name: template.name?.trim() || modelId,
+		reasoning: template.reasoning ?? false,
+		input: template.input ? [...template.input] : ["text"],
+		contextWindow: template.contextWindow ?? 128000,
+		maxTokens: template.maxTokens ?? 16384,
+		...(template.cost ? { cost: cloneJson(template.cost) } : {}),
+		...(template.compat ? { compat: cloneJson(template.compat) } : {}),
+		...(template.thinkingLevelMap ? { thinkingLevelMap: cloneJson(template.thinkingLevelMap) } : {}),
+	};
+}
+
+export function createDefaultModelConfig(modelId: string): ProviderModelConfig {
+	return {
+		id: modelId,
+		name: modelId,
+		reasoning: false,
+		input: ["text"],
+		contextWindow: 128000,
+		maxTokens: 16384,
+	};
+}