pi-cliproxyapi 0.1.0

package/src/fetch-models.ts

@@ -0,0 +1,335 @@
+// Discovery:
+//   1. GET <host>/.well-known/pi with User-Agent: pi-cliproxyapi/<ver>
+//      → returns the server contract document (see PLAN.md).
+//   2. On 404 / 5xx / non-JSON / network error → fall back to:
+//      GET <endpoint>/v1/models with Authorization: Bearer <apiKey>
+//      → classify locally via compat.ts.
+//
+// fetchDiscovery() returns a normalized in-memory model. Callers shouldn't
+// know which path was used (except for logging).
+
+import type { Api } from "@earendil-works/pi-ai";
+
+import {
+	classifyCustom,
+	isExcluded,
+	modelDefaults,
+	normalizeSuggestedProvider,
+	reasoningFromId,
+} from "./compat.ts";
+import type { ProxyConfig } from "./config.ts";
+import { log } from "./log.ts";
+
+export const PLUGIN_USER_AGENT = "pi-cliproxyapi/0.1.0";
+const REQUEST_TIMEOUT_MS = 5_000;
+
+export interface DiscoveryModelEntry {
+	id: string;
+	name: string;
+	reasoning: boolean;
+	contextWindow: number;
+	maxTokens: number;
+	cost: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+	};
+}
+
+export interface DiscoveryBuiltinProvider {
+	/** "openai" or "anthropic" — name of the Pi built-in provider. */
+	name: string;
+	api: Api;
+	/** Models from upstream that map to this built-in provider. */
+	models: DiscoveryModelEntry[];
+}
+
+export interface DiscoveryCustomEntry extends DiscoveryModelEntry {
+	api: Api;
+	/** Suggested custom provider slug (e.g. "myproxy-glm"). */
+	suggestedProvider: string;
+	/** Raw upstream owned_by, for diagnostics. */
+	ownedBy: string;
+}
+
+export interface Discovery {
+	source: "well-known" | "v1-models";
+	upstreamVersion: string | null;
+	builtinProviders: DiscoveryBuiltinProvider[];
+	customPool: DiscoveryCustomEntry[];
+	serverDiscoveryExcludes: string[];
+	/** Total ids seen before any filtering. */
+	upstreamTotal: number;
+}
+
+interface RawUpstreamModel {
+	id: string;
+	owned_by: string;
+}
+
+// --------------------------------------------------------------------------- HTTP
+
+async function fetchWithTimeout(
+	url: string,
+	init: RequestInit,
+): Promise<Response> {
+	const ctrl = new AbortController();
+	const timer = setTimeout(
+		() => ctrl.abort(new Error("timeout")),
+		REQUEST_TIMEOUT_MS,
+	);
+	try {
+		return await fetch(url, { ...init, signal: ctrl.signal });
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+function discoveryUrl(endpoint: string): string {
+	return new URL("/.well-known/pi", new URL(endpoint).origin).toString();
+}
+
+// --------------------------------------------------------------------------- well-known path
+
+async function tryWellKnown(cfg: ProxyConfig): Promise<Discovery | null> {
+	const url = discoveryUrl(cfg.proxy.endpoint);
+	let resp: Response;
+	try {
+		resp = await fetchWithTimeout(url, {
+			headers: { "User-Agent": PLUGIN_USER_AGENT, Accept: "application/json" },
+		});
+	} catch (err) {
+		log.warn(
+			"well-known fetch failed:",
+			(err as Error).message,
+			"— falling back to /v1/models",
+		);
+		return null;
+	}
+	if (!resp.ok) {
+		log.warn(`well-known returned ${resp.status} — falling back to /v1/models`);
+		return null;
+	}
+	let body: any;
+	try {
+		body = await resp.json();
+	} catch {
+		log.warn("well-known returned non-JSON — falling back to /v1/models");
+		return null;
+	}
+	if (!body || body.schemaVersion !== 1) {
+		log.warn("well-known schemaVersion != 1 — falling back to /v1/models");
+		return null;
+	}
+
+	const builtin: DiscoveryBuiltinProvider[] = [];
+	const builtinProviders = (body.builtinProviders ?? {}) as Record<string, any>;
+	for (const [name, p] of Object.entries(builtinProviders)) {
+		if (!p || !Array.isArray(p.models)) continue;
+		const models: DiscoveryModelEntry[] = p.models.map(
+			(m: any): DiscoveryModelEntry => ({
+				id: String(m.id),
+				name: typeof m.name === "string" ? m.name : String(m.id),
+				reasoning: Boolean(m.reasoning ?? reasoningFromId(String(m.id))),
+				contextWindow:
+					typeof m.contextWindow === "number" ? m.contextWindow : 200_000,
+				maxTokens: typeof m.maxTokens === "number" ? m.maxTokens : 16_000,
+				cost: m.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			}),
+		);
+		builtin.push({ name, api: (p.api as Api) ?? "openai-responses", models });
+	}
+
+	const customPool: DiscoveryCustomEntry[] = (
+		Array.isArray(body.customModelPool) ? body.customModelPool : []
+	).map(
+		(m: any): DiscoveryCustomEntry => ({
+			id: String(m.id),
+			name: typeof m.name === "string" ? m.name : String(m.id),
+			reasoning: Boolean(m.reasoning ?? reasoningFromId(String(m.id))),
+			contextWindow:
+				typeof m.contextWindow === "number" ? m.contextWindow : 128_000,
+			maxTokens: typeof m.maxTokens === "number" ? m.maxTokens : 16_000,
+			cost: m.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			api: (m.api as Api) ?? "openai-completions",
+			suggestedProvider: normalizeSuggestedProvider(
+				typeof m.suggestedProviderName === "string"
+					? m.suggestedProviderName
+					: "misc",
+				cfg.proxy.providerPrefix,
+			),
+			ownedBy: typeof m.owned_by === "string" ? m.owned_by : "",
+		}),
+	);
+
+	return {
+		source: "well-known",
+		upstreamVersion:
+			typeof body?.upstream?.upstreamVersion === "string"
+				? body.upstream.upstreamVersion
+				: null,
+		builtinProviders: builtin,
+		customPool,
+		serverDiscoveryExcludes: Array.isArray(body.discoveryExcludes)
+			? body.discoveryExcludes.filter(
+					(s: unknown): s is string => typeof s === "string",
+				)
+			: [],
+		upstreamTotal:
+			typeof body?.counts?.upstreamTotal === "number"
+				? body.counts.upstreamTotal
+				: 0,
+	};
+}
+
+// --------------------------------------------------------------------------- /v1/models path
+
+async function fetchRawModels(
+	cfg: ProxyConfig,
+	resolvedKey: string,
+): Promise<RawUpstreamModel[]> {
+	const url = new URL(
+		"/v1/models",
+		new URL(cfg.proxy.endpoint).origin,
+	).toString();
+	const resp = await fetchWithTimeout(url, {
+		headers: {
+			Authorization: `Bearer ${resolvedKey}`,
+			Accept: "application/json",
+			"User-Agent": PLUGIN_USER_AGENT,
+		},
+	});
+	if (!resp.ok) {
+		throw new Error(`/v1/models returned ${resp.status}`);
+	}
+	const body = (await resp.json()) as {
+		data?: Array<{ id?: unknown; owned_by?: unknown }>;
+	};
+	if (!body?.data || !Array.isArray(body.data)) return [];
+	return body.data
+		.map((m) => ({
+			id: typeof m.id === "string" ? m.id : "",
+			owned_by: typeof m.owned_by === "string" ? m.owned_by : "",
+		}))
+		.filter((m) => m.id);
+}
+
+function classifyLocally(
+	raw: RawUpstreamModel[],
+	cfg: ProxyConfig,
+): Discovery {
+	const excludes = cfg.discoveryExcludes;
+	const builtinByName = new Map<string, DiscoveryBuiltinProvider>();
+	const customPool: DiscoveryCustomEntry[] = [];
+	let upstreamTotal = 0;
+
+	for (const m of raw) {
+		upstreamTotal++;
+		if (isExcluded(m.id, excludes)) continue;
+
+		if (m.owned_by === "openai") {
+			const entry = modelDefaults(m.id);
+			pushBuiltin(
+				builtinByName,
+				"openai",
+				"openai-responses",
+				entryToDiscovery(entry),
+			);
+			continue;
+		}
+		if (m.owned_by === "anthropic") {
+			const entry = modelDefaults(m.id);
+			pushBuiltin(
+				builtinByName,
+				"anthropic",
+				"anthropic-messages",
+				entryToDiscovery(entry),
+			);
+			continue;
+		}
+		const { slug, api } = classifyCustom(m.owned_by, cfg.proxy.providerPrefix);
+		const base = modelDefaults(m.id);
+		customPool.push({
+			id: m.id,
+			name: base.name ?? m.id,
+			reasoning: base.reasoning ?? false,
+			contextWindow: base.contextWindow ?? 128_000,
+			maxTokens: base.maxTokens ?? 16_000,
+			cost: base.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			api,
+			suggestedProvider: slug,
+			ownedBy: m.owned_by,
+		});
+	}
+
+	return {
+		source: "v1-models",
+		upstreamVersion: null,
+		builtinProviders: Array.from(builtinByName.values()),
+		customPool,
+		serverDiscoveryExcludes: [],
+		upstreamTotal,
+	};
+}
+
+function pushBuiltin(
+	map: Map<string, DiscoveryBuiltinProvider>,
+	name: string,
+	api: Api,
+	entry: DiscoveryModelEntry,
+): void {
+	let p = map.get(name);
+	if (!p) {
+		p = { name, api, models: [] };
+		map.set(name, p);
+	}
+	p.models.push(entry);
+}
+
+function entryToDiscovery(
+	base: ReturnType<typeof modelDefaults>,
+): DiscoveryModelEntry {
+	return {
+		id: base.id,
+		name: base.name ?? base.id,
+		reasoning: base.reasoning ?? false,
+		contextWindow: base.contextWindow ?? 128_000,
+		maxTokens: base.maxTokens ?? 16_000,
+		cost: base.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	};
+}
+
+// --------------------------------------------------------------------------- public
+
+export async function fetchDiscovery(
+	cfg: ProxyConfig,
+	resolvedKey: string,
+): Promise<Discovery> {
+	const wk = await tryWellKnown(cfg);
+	if (wk) {
+		log.info(
+			`discovery via /.well-known/pi: ${wk.builtinProviders.length} builtin, ${wk.customPool.length} custom`,
+		);
+		return wk;
+	}
+	if (!resolvedKey) {
+		throw new Error(
+			"well-known unavailable AND proxy apiKey is empty — cannot fall back to /v1/models. Set proxy.apiKey in config.",
+		);
+	}
+	const raw = await fetchRawModels(cfg, resolvedKey);
+	const d = classifyLocally(raw, cfg);
+	log.info(
+		`discovery via /v1/models: ${d.builtinProviders.length} builtin, ${d.customPool.length} custom`,
+	);
+	return d;
+}
+
+/** Convenience: flat set of all upstream ids (after server-applied excludes). */
+export function discoveryToIdSet(d: Discovery): Set<string> {
+	const out = new Set<string>();
+	for (const p of d.builtinProviders) for (const m of p.models) out.add(m.id);
+	for (const m of d.customPool) out.add(m.id);
+	return out;
+}

package/src/fetch-usage.ts

@@ -0,0 +1,103 @@
+// /api/usage client.
+//
+// GET <host>/api/usage with X-Plugin-Key. Returns the parsed document, with a
+// small in-memory TTL cache. Caller passes `force: true` to bypass the cache.
+
+import type { ProxyConfig } from "./config.ts";
+import { PLUGIN_USER_AGENT } from "./fetch-models.ts";
+import { log } from "./log.ts";
+
+const REQUEST_TIMEOUT_MS = 15_000;
+
+export interface UsageGroup {
+	id: string;
+	label: string;
+	remainingFraction: number;
+	resetTime: string | null;
+	models?: string[];
+}
+
+export interface UsageAccount {
+	provider: string;
+	account: string;
+	authIndex: string;
+	label: string;
+	status: string;
+	disabled: boolean;
+	unavailable: boolean;
+	success: number;
+	failed: number;
+	lastRequestAt: string | null;
+	supported: boolean;
+	error?: string;
+	groups?: UsageGroup[];
+}
+
+export interface UsageDocument {
+	schemaVersion: number;
+	generatedAt: string;
+	accounts: UsageAccount[];
+	unsupportedProviders: string[];
+}
+
+interface CacheEntry {
+	fetchedAt: number;
+	doc: UsageDocument;
+}
+
+let cache: CacheEntry | null = null;
+
+export function clearUsageCache(): void {
+	cache = null;
+}
+
+export async function fetchUsage(
+	cfg: ProxyConfig,
+	resolvedUsageKey: string,
+	opts: { force?: boolean } = {},
+): Promise<UsageDocument> {
+	if (
+		!opts.force &&
+		cache &&
+		Date.now() - cache.fetchedAt < cfg.usageCacheTtlMs
+	) {
+		return cache.doc;
+	}
+	if (!resolvedUsageKey) {
+		throw new Error(
+			"usage key not configured; set proxy.usageKey in config and rerun",
+		);
+	}
+	const url = new URL(
+		"/api/usage",
+		new URL(cfg.proxy.endpoint).origin,
+	).toString();
+	const ctrl = new AbortController();
+	const timer = setTimeout(
+		() => ctrl.abort(new Error("timeout")),
+		REQUEST_TIMEOUT_MS,
+	);
+	let resp: Response;
+	try {
+		resp = await fetch(url, {
+			headers: {
+				"X-Plugin-Key": resolvedUsageKey,
+				Accept: "application/json",
+				"User-Agent": PLUGIN_USER_AGENT,
+			},
+			signal: ctrl.signal,
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+	if (!resp.ok) {
+		throw new Error(`/api/usage returned ${resp.status}`);
+	}
+	const body = (await resp.json()) as UsageDocument;
+	if (!body || body.schemaVersion !== 1 || !Array.isArray(body.accounts)) {
+		throw new Error("/api/usage returned unexpected payload shape");
+	}
+	cache = { fetchedAt: Date.now(), doc: body };
+	log.debug("usage fetched, accounts:", body.accounts.length);
+	return body;
+}

package/src/log.ts

@@ -0,0 +1,19 @@
+// Tiny logger that prefixes all messages with the extension tag.
+// Uses console.* directly — pi pipes stdout/stderr into its log sink.
+
+const TAG = "[pi-cliproxyapi]";
+
+export const log = {
+	info(...args: unknown[]): void {
+		console.log(TAG, ...args);
+	},
+	warn(...args: unknown[]): void {
+		console.warn(TAG, ...args);
+	},
+	error(...args: unknown[]): void {
+		console.error(TAG, ...args);
+	},
+	debug(...args: unknown[]): void {
+		if (process.env.PI_CLIPROXYAPI_DEBUG) console.log(TAG, "[debug]", ...args);
+	},
+};