@2tle/pi-provider-manager 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2tle/pi-provider-manager",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Manage OpenAI-compatible providers and model catalogs in Pi Agent",
   "license": "Apache-2.0",
   "type": "module",

package/src/config.ts

@@ -0,0 +1,117 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import type { StoredProvider, StoredSecrets, StoredState } from "./types.js";
+
+const CONFIG_PATH = join(homedir(), ".pi", "agent", "pi-provider-manager.json");
+const SECRETS_PATH = join(homedir(), ".pi", "agent", "pi-provider-manager-secrets.json");
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asPositiveSafeInteger(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+function normalizeModelOverrides(value: unknown): StoredProvider["modelOverrides"] {
+	const overrides: NonNullable<StoredProvider["modelOverrides"]> = {};
+	for (const [modelId, rawOverride] of Object.entries(asRecord(value) ?? {})) {
+		const override = asRecord(rawOverride);
+		const contextWindow = asPositiveSafeInteger(override?.contextWindow);
+		const maxTokens = asPositiveSafeInteger(override?.maxTokens);
+		if (contextWindow !== undefined || maxTokens !== undefined) {
+			overrides[modelId] = {
+				...(contextWindow !== undefined ? { contextWindow } : {}),
+				...(maxTokens !== undefined ? { maxTokens } : {}),
+			};
+		}
+	}
+	return Object.keys(overrides).length > 0 ? overrides : undefined;
+}
+
+function normalizeBaseUrl(value: string): string {
+	return value.trim().replace(/\/+$/, "");
+}
+
+export function validateProviderId(id: string): void {
+	if (!/^[a-z0-9][a-z0-9._-]*$/.test(id)) {
+		throw new Error("Provider ID may contain only lowercase letters, numbers, '.', '_' or '-'.");
+	}
+}
+
+export function validateBaseUrl(value: string): string {
+	const baseUrl = normalizeBaseUrl(value);
+	let parsed: URL;
+	try {
+		parsed = new URL(baseUrl);
+	} catch {
+		throw new Error("Base URL is not a valid URL.");
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+		throw new Error("Base URL must use the http or https protocol.");
+	}
+	return baseUrl;
+}
+
+export async function loadState(): Promise<StoredState> {
+	try {
+		const raw = await readFile(CONFIG_PATH, "utf8");
+		const parsed = asRecord(JSON.parse(raw));
+		const providers = Array.isArray(parsed?.providers) ? parsed.providers : [];
+		const normalized: StoredProvider[] = [];
+		for (const item of providers) {
+			const record = asRecord(item);
+			const id = asNonEmptyString(record?.id);
+			const name = asNonEmptyString(record?.name);
+			const baseUrl = asNonEmptyString(record?.baseUrl);
+			if (!id || !name || !baseUrl) continue;
+			try {
+				validateProviderId(id);
+				const modelOverrides = normalizeModelOverrides(record?.modelOverrides);
+				normalized.push({ id, name, baseUrl: validateBaseUrl(baseUrl), ...(modelOverrides ? { modelOverrides } : {}) });
+			} catch {
+				// Ignore malformed entries so one broken provider does not prevent startup.
+			}
+		}
+		return { providers: normalized };
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return { providers: [] };
+		throw new Error(`Unable to read provider configuration: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+export async function loadSecrets(): Promise<StoredSecrets> {
+	try {
+		const raw = await readFile(SECRETS_PATH, "utf8");
+		const parsed = asRecord(JSON.parse(raw));
+		const apiKeys: Record<string, string> = {};
+		const rawApiKeys = asRecord(parsed?.apiKeys);
+		for (const [id, value] of Object.entries(rawApiKeys ?? {})) {
+			if (typeof value === "string" && value.trim()) apiKeys[id] = value;
+		}
+		return { apiKeys };
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return { apiKeys: {} };
+		throw new Error(`Unable to read provider API keys: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+async function saveJsonFile(path: string, value: object): Promise<void> {
+	await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+	const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+		await chmod(temporaryPath, 0o600);
+		await rename(temporaryPath, path);
+	} finally {
+		await unlink(temporaryPath).catch(() => undefined);
+	}
+}
+
+export const saveState = (state: StoredState): Promise<void> => saveJsonFile(CONFIG_PATH, state);
+export const saveSecrets = (secrets: StoredSecrets): Promise<void> => saveJsonFile(SECRETS_PATH, secrets);

package/src/models.ts

@@ -0,0 +1,85 @@
+import {
+	API,
+	CODEX_API,
+	DEFAULT_CONTEXT_WINDOW,
+	DEFAULT_MAX_TOKENS,
+	PI_THINKING_LEVELS,
+	type OpenAIModelPayload,
+	type ProviderModelConfig,
+	type PiThinkingLevel,
+	type StoredProvider,
+} from "./types.js";
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asPositiveNumber(value: unknown, fallback: number): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function getReasoningEfforts(value: unknown): Set<string> {
+	if (!Array.isArray(value)) return new Set();
+	return new Set(value.flatMap((item) => {
+		if (typeof item === "string") return [item.toLowerCase()];
+		const record = asRecord(item);
+		const effort = asNonEmptyString(record?.value ?? record?.effort);
+		return effort ? [effort.toLowerCase()] : [];
+	}));
+}
+
+function thinkingLevelMap(efforts: Set<string>): Partial<Record<PiThinkingLevel, string | null>> | undefined {
+	if (efforts.size === 0) return undefined;
+	const map: Partial<Record<PiThinkingLevel, string | null>> = {};
+	for (const level of PI_THINKING_LEVELS) {
+		if (efforts.has(level)) map[level] = level;
+		else if (level === "max" && efforts.has("ultra")) map[level] = "ultra";
+		else map[level] = null;
+	}
+	return map;
+}
+
+export function modelFromPayload(provider: StoredProvider, payload: OpenAIModelPayload): ProviderModelConfig | undefined {
+	const id = asNonEmptyString(payload.id);
+	if (!id) return undefined;
+
+	const override = provider.modelOverrides?.[id];
+	const capabilities = asRecord(payload.capabilities);
+	const cost = asRecord(payload.cost);
+	const inputModalities = Array.isArray(payload.input) ? payload.input : payload.input_modalities ?? capabilities?.input_modalities;
+	const input: ("text" | "image")[] = Array.isArray(inputModalities) && inputModalities.includes("image")
+		? ["text", "image"]
+		: ["text"];
+	const efforts = getReasoningEfforts(payload.reasoning_efforts ?? payload.supported_reasoning_levels ?? capabilities?.reasoning_effort);
+	const reasoning = payload.reasoning === true || payload.supports_reasoning === true ||
+		payload.supports_reasoning_effort === true || capabilities?.supports_reasoning === true || efforts.size > 0;
+
+	const isCodex = provider.baseUrl.trim().replace(/\/+$/, "").endsWith("/codex");
+
+	return {
+		id,
+		name: asNonEmptyString(payload.name) ?? id,
+		api: isCodex ? CODEX_API : API,
+		reasoning,
+		...(reasoning ? { thinkingLevelMap: thinkingLevelMap(efforts), compat: { supportsReasoningEffort: true } } : {}),
+		input,
+		cost: {
+			input: asPositiveNumber(cost?.input, 0),
+			output: asPositiveNumber(cost?.output, 0),
+			cacheRead: asPositiveNumber(cost?.cacheRead, 0),
+			cacheWrite: asPositiveNumber(cost?.cacheWrite, 0),
+		},
+		contextWindow: asPositiveNumber(override?.contextWindow, asPositiveNumber(
+			payload.context_window ?? payload.contextWindow ?? capabilities?.context_length,
+			DEFAULT_CONTEXT_WINDOW,
+		)),
+		maxTokens: asPositiveNumber(override?.maxTokens, asPositiveNumber(
+			payload.max_tokens ?? payload.maxTokens ?? capabilities?.max_output_tokens,
+			DEFAULT_MAX_TOKENS,
+		)),
+	};
+}

package/src/provider.ts

@@ -0,0 +1,60 @@
+import type { RefreshModelsContext } from "@earendil-works/pi-ai";
+import { modelFromPayload } from "./models.js";
+import { CODEX_API } from "./types.js";
+import type { ManagedProviderConfig, OpenAIModelsPayload, OpenAIModelPayload, ProviderModelConfig, StoredProvider } from "./types.js";
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
+}
+
+function normalizeBaseUrl(value: string): string {
+	return value.trim().replace(/\/+$/, "");
+}
+
+function modelsUrl(baseUrl: string): string {
+	return new URL("models", `${normalizeBaseUrl(baseUrl)}/`).toString();
+}
+
+export async function fetchProviderModels(
+	provider: StoredProvider,
+	context: RefreshModelsContext,
+	getApiKey: () => string | undefined,
+): Promise<ProviderModelConfig[]> {
+	const apiKey = getApiKey();
+	if (!apiKey) throw new Error(`API key for provider '${provider.id}' is not configured.`);
+	const response = await fetch(modelsUrl(provider.baseUrl), {
+		signal: context.signal,
+		headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+	});
+	if (!response.ok) throw new Error(`Failed to fetch model list (${response.status} ${response.statusText})`);
+
+	const payload = (await response.json()) as OpenAIModelsPayload | unknown[];
+	const data = Array.isArray(payload) ? payload : asRecord(payload)?.data ?? asRecord(payload)?.models;
+	if (!Array.isArray(data)) throw new Error("Model list response does not contain a data/models array.");
+	return data.map((item) => {
+		const record = asRecord(item);
+		if (!record) return undefined;
+		// Codex's catalog uses slug/display_name instead of OpenAI's id/name.
+		const normalized: OpenAIModelPayload = provider.baseUrl.trim().replace(/\/+$/, "").endsWith("/codex")
+			? { ...record, id: record.id ?? record.slug, name: record.name ?? record.display_name }
+			: record;
+		return modelFromPayload(provider, normalized);
+	}).filter((model): model is ProviderModelConfig => model !== undefined);
+}
+
+export function createManagedProvider(
+	config: StoredProvider,
+	getApiKey: () => string | undefined,
+): ManagedProviderConfig {
+	const isCodex = config.baseUrl.trim().replace(/\/+$/, "").endsWith("/codex");
+	return {
+		name: config.name,
+		baseUrl: config.baseUrl,
+		// Codex gateways expose Responses at /codex/responses; using the
+		// completions transport would POST /codex/chat/completions (405).
+		api: isCodex ? CODEX_API : "openai-completions",
+		apiKey: getApiKey() ?? "local",
+		models: [],
+		refreshModels: (context) => fetchProviderModels(config, context, getApiKey),
+	};
+}

package/src/types.ts

@@ -0,0 +1,82 @@
+import type { RefreshModelsContext } from "@earendil-works/pi-ai";
+
+export const API = "openai-completions" as const;
+export const CODEX_API = "openai-responses" as const;
+export const DEFAULT_CONTEXT_WINDOW = 128_000;
+export const DEFAULT_MAX_TOKENS = 16_384;
+export const REFRESH_TIMEOUT_MS = 30_000;
+export const PI_THINKING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+export type PiThinkingLevel = (typeof PI_THINKING_LEVELS)[number];
+
+export interface ModelOverride {
+	contextWindow?: number;
+	maxTokens?: number;
+}
+
+export interface StoredProvider {
+	id: string;
+	name: string;
+	baseUrl: string;
+	modelOverrides?: Record<string, ModelOverride>;
+}
+
+export interface StoredState {
+	providers: StoredProvider[];
+}
+
+export interface StoredSecrets {
+	apiKeys: Record<string, string>;
+}
+
+export interface ProviderModelConfig {
+	id: string;
+	name: string;
+	api: typeof API | typeof CODEX_API;
+	reasoning: boolean;
+	thinkingLevelMap?: Partial<Record<PiThinkingLevel, string | null>>;
+	compat?: {
+		supportsReasoningEffort: boolean;
+	};
+	input: ("text" | "image")[];
+	cost: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+	};
+	contextWindow: number;
+	maxTokens: number;
+}
+
+export interface ManagedProviderConfig {
+	name: string;
+	baseUrl: string;
+	api: typeof API | typeof CODEX_API;
+	apiKey: string;
+	models: ProviderModelConfig[];
+	refreshModels(context: RefreshModelsContext): Promise<ProviderModelConfig[]>;
+}
+
+export interface OpenAIModelPayload {
+	id?: unknown;
+	name?: unknown;
+	context_window?: unknown;
+	contextWindow?: unknown;
+	max_tokens?: unknown;
+	maxTokens?: unknown;
+	reasoning?: unknown;
+	supports_reasoning?: unknown;
+	supports_reasoning_effort?: unknown;
+	reasoning_efforts?: unknown;
+	supported_reasoning_levels?: unknown;
+	input?: unknown;
+	input_modalities?: unknown;
+	cost?: unknown;
+	capabilities?: unknown;
+}
+
+export interface OpenAIModelsPayload {
+	data?: unknown;
+	models?: unknown;
+}

package/src/ui.ts

@@ -0,0 +1,63 @@
+import { DynamicBorder, keyHint } from "@earendil-works/pi-coding-agent";
+import { Container, CURSOR_MARKER, getKeybindings, Input, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
+
+export function maskInputLine(line: string): string {
+	const prompt = line.startsWith("> ") ? "> " : "";
+	let result = "";
+	for (let index = prompt.length; index < line.length;) {
+		if (line.startsWith(CURSOR_MARKER, index)) {
+			result += CURSOR_MARKER;
+			index += CURSOR_MARKER.length;
+			continue;
+		}
+		if (line[index] === "\x1b") {
+			const ansi = line.slice(index).match(/^\x1b\[[0-9;?]*[ -/]*[@-~]/)?.[0];
+			if (ansi) {
+				result += ansi;
+				index += ansi.length;
+				continue;
+			}
+		}
+		const character = line[index++];
+		result += /\s/u.test(character) ? character : "*";
+	}
+	return prompt + result;
+}
+
+class MaskedInput extends Input {
+	override render(width: number): string[] {
+		const terminalWidth = process.stdout.columns;
+		const safeWidth = Math.max(1, Number.isFinite(terminalWidth) ? Math.min(width, terminalWidth) : width);
+		return super.render(safeWidth).map((line) => truncateToWidth(maskInputLine(line), safeWidth, "", false));
+	}
+}
+
+export class SecretInputDialog extends Container {
+	private readonly input = new MaskedInput();
+	private _focused = false;
+
+	constructor(done: (value: string | undefined) => void, title: string, helpText: string, border: (text: string) => string) {
+		super();
+		this.addChild(new DynamicBorder(border));
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(title, 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(this.input);
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(helpText, 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder(border));
+		this.done = done;
+	}
+
+	private readonly done: (value: string | undefined) => void;
+	get focused(): boolean { return this._focused; }
+	set focused(value: boolean) { this._focused = value; this.input.focused = value; }
+
+	handleInput(data: string): void {
+		const keybindings = getKeybindings();
+		if (keybindings.matches(data, "tui.select.confirm") || data === "\n") this.done(this.input.getValue());
+		else if (keybindings.matches(data, "tui.select.cancel")) this.done(undefined);
+		else this.input.handleInput(data);
+	}
+}