@samrito/pi-cliproxyapi-provider 0.16.0

package/src/model-ui.ts

@@ -0,0 +1,373 @@
+import { DynamicBorder, getSettingsListTheme, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Container, Key, matchesKey, type SelectItem, SelectList, type SettingItem, SettingsList, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+  CONTEXT_WINDOW_PRESETS,
+  loadModelOverrideLayers,
+  MAX_TOKEN_PRESETS,
+  saveModelOverride,
+} from "./config.ts";
+import type { ProviderCatalog } from "./catalog.ts";
+import { normalizeProviderModels } from "./registration.ts";
+import { saveProviderSettings, type ProviderSettings } from "./settings.ts";
+import type {
+  CpaProviderConfig,
+  ProviderModelConfigLike,
+  ProviderModelOverride,
+  ProviderModelOverrideLayer,
+} from "./types.ts";
+
+function modelOverride(model: ProviderModelConfigLike, overrides: Record<string, ProviderModelOverride>): ProviderModelOverride {
+  return overrides[model.id] ?? {};
+}
+
+function valuesFor(current: number, presets: number[]): string[] {
+  return ["auto", ...new Set([current, ...presets]).values()].map(String);
+}
+
+function effectiveReasoning(model: ProviderModelConfigLike, override: ProviderModelOverrideLayer): boolean {
+  return typeof override.reasoning === "boolean" ? override.reasoning : model.reasoning;
+}
+
+function effectiveNumber(
+  model: ProviderModelConfigLike,
+  override: ProviderModelOverrideLayer,
+  field: "contextWindow" | "maxTokens",
+): number {
+  return typeof override[field] === "number" ? override[field] : model[field];
+}
+
+function strictModeLabel(model: ProviderModelConfigLike): string {
+  const strict = (model.compat as { supportsStrictMode?: boolean } | undefined)?.supportsStrictMode;
+  return strict === false ? "disabled" : strict === true ? "enabled" : "auto";
+}
+
+function formattedOtherCompat(model: ProviderModelConfigLike): string {
+  const entries = Object.entries(model.compat ?? {}).filter(([key]) => key !== "supportsStrictMode");
+  return entries.length === 0 ? "none" : entries.map(([key, value]) => `${key}=${String(value)}`).join(", ");
+}
+
+function detailItems(model: ProviderModelConfigLike, override: ProviderModelOverrideLayer): SettingItem[] {
+  const reasoning = effectiveReasoning(model, override);
+  const contextWindow = effectiveNumber(model, override, "contextWindow");
+  const maxTokens = effectiveNumber(model, override, "maxTokens");
+  return [
+    {
+      id: "reasoning",
+      label: "Reasoning",
+      description: `Effective: ${reasoning ? "on" : "off"}. ${override.reasoning === undefined ? "Metadata/capability default." : "User override."}`,
+      currentValue: typeof override.reasoning !== "boolean" ? "auto" : override.reasoning ? "on" : "off",
+      values: ["auto", "on", "off"],
+    },
+    {
+      id: "contextWindow",
+      label: "Context window",
+      description: `Effective: ${contextWindow} tokens. ${override.contextWindow === undefined ? "Derived default." : "User override."}`,
+      currentValue: typeof override.contextWindow !== "number" ? "auto" : String(override.contextWindow),
+      values: valuesFor(contextWindow, [...CONTEXT_WINDOW_PRESETS]),
+    },
+    {
+      id: "maxTokens",
+      label: "Max output tokens",
+      description: `Effective: ${maxTokens} tokens. ${override.maxTokens === undefined ? "Derived default." : "User override."}`,
+      currentValue: typeof override.maxTokens !== "number" ? "auto" : String(override.maxTokens),
+      values: valuesFor(maxTokens, [...MAX_TOKEN_PRESETS]),
+    },
+  ];
+}
+
+/**
+ * Render the thinking levels pi will actually offer.
+ *
+ * Listing `Object.keys(thinkingLevelMap)` would be misleading: a key is present
+ * with value `null` precisely to mean "unsupported, hidden", so the keys alone
+ * include levels the user can never select. Show the mapped values instead and
+ * state the count of explicitly unsupported levels.
+ */
+function thinkingLevelSummary(map: ProviderModelConfigLike["thinkingLevelMap"]): string {
+  if (!map) return "none";
+
+  const offered = Object.entries(map)
+    .filter(([, value]) => typeof value === "string")
+    .map(([level]) => level);
+  const hidden = Object.values(map).filter((value) => value === null).length;
+  if (offered.length === 0) return "none";
+
+  return hidden > 0 ? `${offered.join(", ")} (${hidden} unsupported)` : offered.join(", ");
+}
+
+function details(model: ProviderModelConfigLike): string[] {
+  return [
+    `Name: ${model.name}`,
+    `API: ${model.api ?? "openai-completions (provider default)"}`,
+    `Input: ${model.input.join(", ")}`,
+    `Cost: in ${model.cost.input}, out ${model.cost.output}, cache read ${model.cost.cacheRead}, cache write ${model.cost.cacheWrite}`,
+    `Thinking map: ${thinkingLevelSummary(model.thinkingLevelMap)}`,
+    `Other compat: ${formattedOtherCompat(model)}`,
+  ];
+}
+
+function modelSelectorItems(
+  models: ProviderModelConfigLike[],
+  overrides: Record<string, ProviderModelOverride>,
+  showStrictMode: boolean,
+): SelectItem[] {
+  const sorted = [...models].sort((left, right) => left.id.localeCompare(right.id));
+  const idWidth = Math.max(...sorted.map((model) => visibleWidth(model.id)));
+  const apiWidth = Math.max(...sorted.map((model) => visibleWidth(model.api ?? "completions")));
+  const modeWidth = Math.max(...sorted.map((model) => visibleWidth(model.reasoning ? "reasoning" : "standard")));
+  const strictWidth = showStrictMode
+    ? Math.max(...sorted.map((model) => visibleWidth(strictModeLabel(model))))
+    : 0;
+  const contextWidth = Math.max(...sorted.map((model) => String(model.contextWindow).length));
+  const pad = (value: string, width: number) => `${value}${" ".repeat(Math.max(0, width - visibleWidth(value)))}`;
+
+  return sorted.map((model) => {
+    const override = modelOverride(model, overrides);
+    const overrideLabel = Object.keys(override).length > 0 ? " override" : "";
+    const api = model.api ?? "completions";
+    const mode = model.reasoning ? "reasoning" : "standard";
+    const strict = strictModeLabel(model);
+    const context = String(model.contextWindow).padStart(contextWidth);
+    return {
+      value: model.id,
+      label: pad(model.id, idWidth),
+      description: [
+        pad(api, apiWidth),
+        pad(mode, modeWidth),
+        ...(showStrictMode ? [`${pad(strict, strictWidth)} strict`] : []),
+        `${context} ctx${overrideLabel}`,
+      ].join("  "),
+    };
+  });
+}
+
+type ConfigTab = "Connection" | "Models" | "Display";
+
+const CONFIG_TABS: ConfigTab[] = ["Connection", "Models", "Display"];
+
+function providerSettingsItems(
+  tab: ConfigTab,
+  settings: ProviderSettings,
+  connection: CpaProviderConfig,
+): SettingItem[] {
+  if (tab === "Connection") {
+    return [{
+      id: "connection",
+      label: "Endpoint and authentication",
+      description: `${connection.providerName}  ${connection.baseUrl}  ${connection.authRequired ? "credentials required" : "no credentials"}`,
+      currentValue: "open",
+      values: ["open", "edit"],
+    }];
+  }
+  if (tab === "Models") return [
+    {
+      id: "gpt56ContextWindow",
+      label: "GPT-5.6 context window",
+      description: "canonical advertises 272000 tokens; full uses the models.dev limit.",
+      currentValue: settings.gpt56ContextWindow,
+      values: ["canonical", "full"],
+    },
+  ];
+  return [
+    {
+      id: "showStrictMode",
+      label: "Show strict tool schema",
+      description: "Show the published strict-schema compatibility value in the model selector.",
+      currentValue: settings.showStrictMode ? "enabled" : "disabled",
+      values: ["disabled", "enabled"],
+    },
+  ];
+}
+
+function nextTab(tab: ConfigTab, direction: 1 | -1): ConfigTab {
+  const index = CONFIG_TABS.indexOf(tab);
+  return CONFIG_TABS[(index + direction + CONFIG_TABS.length) % CONFIG_TABS.length] ?? "Connection";
+}
+
+export async function openProviderConfig(
+  ctx: ExtensionCommandContext,
+  settings: ProviderSettings,
+  connection: CpaProviderConfig,
+): Promise<"connection" | undefined> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify("/cliproxyapi config requires interactive TUI mode.", "warning");
+    return;
+  }
+
+  const edited: ProviderSettings = { ...settings };
+  const action = await ctx.ui.custom<"connection" | undefined>((tui, theme, _keybindings, done) => {
+    let activeTab: ConfigTab = "Connection";
+    let list: SettingsList;
+    const makeList = () => new SettingsList(
+      providerSettingsItems(activeTab, edited, connection),
+      8,
+      getSettingsListTheme(),
+      (id, value) => {
+        if (id === "connection" && value === "edit") {
+          done("connection");
+          return;
+        }
+        if (id === "gpt56ContextWindow" && (value === "canonical" || value === "full")) {
+          edited.gpt56ContextWindow = value;
+        }
+        if (id === "showStrictMode" && (value === "enabled" || value === "disabled")) {
+          edited.showStrictMode = value === "enabled";
+        }
+        list.updateValue(id, value);
+        tui.requestRender();
+      },
+      () => done(undefined),
+      { enableSearch: true },
+    );
+    list = makeList();
+    return {
+      render: (width) => {
+        const border = theme.fg("border", "─".repeat(Math.max(0, width)));
+        const tabs = CONFIG_TABS.map((tab) => tab === activeTab
+          ? theme.fg("accent", theme.bold(tab))
+          : theme.fg("muted", tab));
+        return [
+          border,
+          `  ${tabs.join(theme.fg("muted", " / "))}`,
+          border,
+          ...list.render(width),
+          theme.fg("dim", "  Enter/Space changes  Tab switches sections  Esc saves and reloads Pi"),
+          border,
+        ].map((line) => truncateToWidth(line, width, ""));
+      },
+      invalidate: () => list.invalidate(),
+      handleInput: (data) => {
+        if (matchesKey(data, Key.tab)) {
+          activeTab = nextTab(activeTab, 1);
+          list = makeList();
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.shift("tab"))) {
+          activeTab = nextTab(activeTab, -1);
+          list = makeList();
+          tui.requestRender();
+          return;
+        }
+        list.handleInput(data);
+      },
+    };
+  });
+
+  if (action === "connection") return action;
+  if (JSON.stringify(settings) === JSON.stringify(edited)) return;
+  try {
+    const path = saveProviderSettings(ctx.cwd, edited);
+    ctx.ui.notify(`Saved CLIProxyAPI configuration to ${path}. Reloading Pi...`, "info");
+    await ctx.reload();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Could not save CLIProxyAPI configuration: ${message}`, "error");
+  }
+}
+
+export async function openModelInspector(
+  ctx: ExtensionCommandContext,
+  catalog: ProviderCatalog,
+  overrides: Record<string, ProviderModelOverride>,
+  showStrictMode: boolean,
+): Promise<void> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify("/cliproxyapi models requires interactive TUI mode.", "warning");
+    return;
+  }
+
+  const snapshot = catalog.current() ?? await catalog.load();
+  const models = normalizeProviderModels(snapshot.built.models);
+  if (models.length === 0) {
+    ctx.ui.notify("No available models in the current CLIProxyAPI snapshot. Run /cliproxyapi refresh models first.", "warning");
+    return;
+  }
+
+  const selectedId = await ctx.ui.custom<string | undefined>((tui, theme, _keybindings, done) => {
+    const container = new Container();
+    container.addChild(new DynamicBorder((text) => theme.fg("border", text)));
+    container.addChild(new Text(theme.fg("accent", theme.bold("CLIProxyAPI models")), 1, 0));
+    container.addChild(new Text(theme.fg("muted", "Select a model to inspect or override bounded limits."), 1, 0));
+    const list = new SelectList(modelSelectorItems(models, overrides, showStrictMode), Math.min(models.length, 12), {
+      selectedPrefix: (text) => theme.fg("accent", text),
+      selectedText: (text) => theme.fg("accent", text),
+      description: (text) => theme.fg("muted", text),
+      scrollInfo: (text) => theme.fg("dim", text),
+      noMatch: (text) => theme.fg("warning", text),
+    });
+    list.onSelect = (item) => done(item.value);
+    list.onCancel = () => done(undefined);
+    container.addChild(list);
+    container.addChild(new Text(theme.fg("dim", "↑↓ navigate  Enter inspect  Esc close"), 1, 0));
+    container.addChild(new DynamicBorder((text) => theme.fg("border", text)));
+    return {
+      render: (width) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data) => { list.handleInput(data); tui.requestRender(); },
+    };
+  });
+  if (!selectedId) return;
+
+  const model = models.find((candidate) => candidate.id === selectedId);
+  if (!model) return;
+  const layers = loadModelOverrideLayers(ctx.cwd);
+  const globalOverride = layers.global[model.id] ?? {};
+  const original: ProviderModelOverrideLayer = layers.project[model.id] ?? {};
+  const edited: ProviderModelOverrideLayer = { ...original };
+  const selectAuto = (field: keyof ProviderModelOverrideLayer) => {
+    if (globalOverride[field] === undefined) delete edited[field];
+    else edited[field] = null;
+  };
+
+  await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+    const container = new Container();
+    container.addChild(new DynamicBorder((text) => theme.fg("border", text)));
+    container.addChild(new Text(theme.fg("accent", theme.bold(model.id)), 1, 0));
+    container.addChild(new Text(theme.fg("accent", `Strict tool schema: ${strictModeLabel(model)}`), 1, 0));
+    for (const line of details(model)) container.addChild(new Text(theme.fg("muted", line), 1, 0));
+
+    const onChange = (id: string, value: string) => {
+      if (id === "reasoning") {
+        if (value === "auto") selectAuto("reasoning");
+        else edited.reasoning = value === "on";
+      }
+      if (id === "contextWindow") {
+        if (value === "auto") selectAuto("contextWindow");
+        else edited.contextWindow = Number(value);
+      }
+      if (id === "maxTokens") {
+        if (value === "auto") selectAuto("maxTokens");
+        else edited.maxTokens = Number(value);
+      }
+      list.updateValue(id, value);
+      tui.requestRender();
+    };
+    const list = new SettingsList(
+      detailItems(model, edited),
+      8,
+      getSettingsListTheme(),
+      onChange,
+      () => done(undefined),
+      { enableSearch: true },
+    );
+    container.addChild(list);
+    container.addChild(new Text(theme.fg("dim", "Enter/Space changes  Esc saves and reloads Pi"), 1, 0));
+    container.addChild(new DynamicBorder((text) => theme.fg("border", text)));
+    return {
+      render: (width) => container.render(width),
+      invalidate: () => { container.invalidate(); list.invalidate(); },
+      handleInput: (data) => list.handleInput(data),
+    };
+  });
+
+  if (JSON.stringify(original) === JSON.stringify(edited)) return;
+  try {
+    const saved = saveModelOverride(ctx.cwd, model.id, edited);
+    ctx.ui.notify(`Saved overrides for ${model.id} to ${saved.path}. Reloading Pi...`, "info");
+    await ctx.reload();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Could not save model overrides: ${message}`, "error");
+  }
+}

package/src/models-dev.ts

@@ -0,0 +1,58 @@
+import { readFile } from "node:fs/promises";
+import type { ModelsDevCatalog, ModelsDevMetadata } from "./types.ts";
+import { withNetworkTimeout } from "./network.ts";
+
+export const MODELS_DEV_URL = "https://models.dev/api.json";
+
+function isMetadata(value: unknown): value is ModelsDevMetadata {
+  return !!value && typeof value === "object" && typeof (value as { id?: unknown }).id === "string";
+}
+
+export function parseModelsDevCatalog(payload: unknown): ModelsDevCatalog {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("models.dev catalog must be a JSON object");
+  }
+
+  const record = payload as Record<string, unknown>;
+  const catalog: ModelsDevCatalog = {};
+
+  for (const [key, value] of Object.entries(record)) {
+    const provider = value as { models?: unknown };
+    if (provider && typeof provider === "object" && provider.models && typeof provider.models === "object") {
+      for (const [modelId, metadata] of Object.entries(provider.models as Record<string, unknown>)) {
+        if (!isMetadata(metadata)) continue;
+        const canonicalId = metadata.id.includes("/") ? metadata.id : `${key}/${modelId}`;
+        const catalogKey = canonicalId.startsWith(`${key}/`) ? canonicalId : `${key}/${canonicalId}`;
+        catalog[catalogKey] = { ...metadata, id: canonicalId, sourceProvider: key };
+      }
+      continue;
+    }
+
+    if (isMetadata(value)) {
+      catalog[key] = value;
+    }
+  }
+
+  if (Object.keys(catalog).length === 0 && Object.keys(record).length > 0) {
+    throw new Error("models.dev catalog contained no valid models");
+  }
+  return catalog;
+}
+
+export async function fetchModelsDevCatalog(timeoutMs?: number, signal?: AbortSignal): Promise<ModelsDevCatalog> {
+  return withNetworkTimeout(async (reqSignal) => {
+    const response = await fetch(MODELS_DEV_URL, { headers: { Accept: "application/json" }, signal: reqSignal });
+    if (!response.ok) {
+      throw new Error(`models.dev fetch failed: HTTP ${response.status} ${response.statusText}`);
+    }
+    return parseModelsDevCatalog(await response.json());
+  }, timeoutMs, "models.dev fetch", signal);
+}
+
+export function hasSourceProviderMetadata(catalog: ModelsDevCatalog): boolean {
+  return Object.values(catalog).every((metadata) => typeof metadata.sourceProvider === "string");
+}
+
+export async function readBundledModelsDevFallback(path: string): Promise<ModelsDevCatalog> {
+  return parseModelsDevCatalog(JSON.parse(await readFile(path, "utf8")));
+}

package/src/network.ts

@@ -0,0 +1,47 @@
+export async function withNetworkTimeout<T>(
+  operation: (signal: AbortSignal) => Promise<T>,
+  timeoutMs = 10_000,
+  label = "network request",
+  parentSignal?: AbortSignal,
+): Promise<T> {
+  const controller = new AbortController();
+  const timeoutError = new Error(`${label} timed out after ${timeoutMs}ms`);
+
+  const onParentAbort = () => {
+    controller.abort(parentSignal?.reason ?? new Error(`${label} aborted`));
+  };
+
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      controller.abort(parentSignal.reason ?? new Error(`${label} aborted`));
+    } else {
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+    }
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const operationPromise = operation(controller.signal);
+  const timeoutPromise = new Promise<never>((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      controller.abort(timeoutError);
+      reject(timeoutError);
+    }, timeoutMs);
+  });
+
+  try {
+    return await Promise.race([operationPromise, timeoutPromise]);
+  } catch (error) {
+    if (parentSignal?.aborted) {
+      throw parentSignal.reason ?? error;
+    }
+    if (controller.signal.aborted && controller.signal.reason instanceof Error) {
+      throw controller.signal.reason;
+    }
+    throw error;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    if (parentSignal) {
+      parentSignal.removeEventListener("abort", onParentAbort);
+    }
+  }
+}

package/src/provider.ts

@@ -0,0 +1,200 @@
+import type { CpaModel } from "./cpa.ts";
+import { findMetadataMatch, type MetadataMatchMethod } from "./matching.ts";
+import { getModelApiOverride, isGpt56Model, type ModelApiContext } from "./model-api.ts";
+import { getModelCapabilityOverrides } from "./model-capabilities.ts";
+import { thinkingLevelMapFromReasoningOptions } from "./reasoning-levels.ts";
+import type { Gpt56ContextWindowMode } from "./settings.ts";
+import type {
+  InputModality,
+  ModelsDevCatalog,
+  ModelsDevMetadata,
+  ProviderModelConfigLike,
+  ProviderModelOverrides,
+} from "./types.ts";
+
+export const GPT_5_6_CANONICAL_CONTEXT_WINDOW = 272000;
+
+export const PI_MODEL_DEFAULTS = {
+  reasoning: false,
+  input: ["text"] as InputModality[],
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  contextWindow: 128000,
+  maxTokens: 16384,
+};
+
+export interface BuildProviderModelsStats {
+  total: number;
+  enriched: number;
+  unmatched: number;
+  matchMethods: Record<MetadataMatchMethod, number>;
+  unmatchedModelIds: string[];
+}
+
+export interface BuildProviderModelsResult {
+  models: ProviderModelConfigLike[];
+  stats: BuildProviderModelsStats;
+}
+
+function inputFromMetadata(metadata: ModelsDevMetadata): InputModality[] {
+  const input = metadata.modalities?.input ?? [];
+  return input.includes("image") ? ["text", "image"] : ["text"];
+}
+
+function costFromMetadata(metadata: ModelsDevMetadata): ProviderModelConfigLike["cost"] {
+  const tiers = metadata.cost?.tiers?.flatMap((tier) => {
+    const threshold = tier.tier?.size;
+    if (tier.tier?.type !== "context" || typeof threshold !== "number") return [];
+    return [{
+      inputTokensAbove: threshold,
+      input: tier.input ?? 0,
+      output: tier.output ?? 0,
+      cacheRead: tier.cache_read ?? 0,
+      cacheWrite: tier.cache_write ?? 0,
+    }];
+  });
+
+  return {
+    input: metadata.cost?.input ?? 0,
+    output: metadata.cost?.output ?? 0,
+    cacheRead: metadata.cost?.cache_read ?? 0,
+    cacheWrite: metadata.cost?.cache_write ?? 0,
+    ...(tiers && tiers.length > 0 ? { tiers } : {}),
+  };
+}
+
+function contextWindowForModel(
+  context: ModelApiContext,
+  metadataContextWindow: number | undefined,
+  mode: Gpt56ContextWindowMode,
+): number {
+  if (!isGpt56Model(context)) return metadataContextWindow ?? PI_MODEL_DEFAULTS.contextWindow;
+  if (mode === "full") return metadataContextWindow ?? GPT_5_6_CANONICAL_CONTEXT_WINDOW;
+  return GPT_5_6_CANONICAL_CONTEXT_WINDOW;
+}
+
+function modelFromMetadata(
+  cpaModel: CpaModel,
+  metadata: ModelsDevMetadata,
+  gpt56ContextWindow: Gpt56ContextWindowMode,
+): ProviderModelConfigLike {
+  const capabilityContext = {
+    availableModelId: cpaModel.id,
+    metadataModelId: metadata.id,
+  };
+  const capabilityOverrides = getModelCapabilityOverrides(capabilityContext);
+  const api = getModelApiOverride(capabilityContext);
+
+  // Precedence: models.dev wins when it publishes a level list, because that
+  // list tracks the model's current capability while the rules were written
+  // against an older catalog. Measured against a live CLIProxyAPI instance, the
+  // gpt-5.6 rule is now stale: it maps `minimal`, which the proxy rejects with
+  // `400 level "minimal" not supported`, whereas the models.dev list for the
+  // same model omits `minimal` and matches the proxy exactly. The rules still
+  // fill the gap when metadata is absent or carries no effort list.
+  const thinkingLevelMap =
+    thinkingLevelMapFromReasoningOptions(metadata.reasoning_options) ?? capabilityOverrides.thinkingLevelMap;
+
+  return {
+    id: cpaModel.id,
+    name: metadata.name ?? cpaModel.id,
+    reasoning: capabilityOverrides.reasoning ?? metadata.reasoning ?? PI_MODEL_DEFAULTS.reasoning,
+    ...(api ? { api } : {}),
+    ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
+    input: inputFromMetadata(metadata),
+    cost: costFromMetadata(metadata),
+    contextWindow: contextWindowForModel(capabilityContext, metadata.limit?.context, gpt56ContextWindow),
+    maxTokens: metadata.limit?.output ?? PI_MODEL_DEFAULTS.maxTokens,
+  };
+}
+
+function cloneModelDefaults(): typeof PI_MODEL_DEFAULTS {
+  return {
+    ...PI_MODEL_DEFAULTS,
+    input: [...PI_MODEL_DEFAULTS.input],
+    cost: { ...PI_MODEL_DEFAULTS.cost },
+  };
+}
+
+function defaultModel(cpaModel: CpaModel, gpt56ContextWindow: Gpt56ContextWindowMode): ProviderModelConfigLike {
+  const modelContext = { availableModelId: cpaModel.id };
+  const capabilityOverrides = getModelCapabilityOverrides(modelContext);
+  const api = getModelApiOverride(modelContext);
+
+  return {
+    id: cpaModel.id,
+    name: cpaModel.id,
+    ...cloneModelDefaults(),
+    ...capabilityOverrides,
+    ...(api ? { api } : {}),
+    contextWindow: contextWindowForModel(modelContext, undefined, gpt56ContextWindow),
+  };
+}
+
+function emptyMatchMethods(): Record<MetadataMatchMethod, number> {
+  return {
+    alias: 0,
+    exact: 0,
+    "owner-prefix": 0,
+    "owner-hint": 0,
+    suffix: 0,
+    "normalized-suffix": 0,
+    "provider-fallback": 0,
+  };
+}
+
+function applyModelOverride(
+  model: ProviderModelConfigLike,
+  overrides: ProviderModelOverrides,
+): ProviderModelConfigLike {
+  const override = overrides[model.id];
+  if (!override) return model;
+  return {
+    ...model,
+    ...(override.reasoning !== undefined ? { reasoning: override.reasoning } : {}),
+    ...(override.contextWindow !== undefined ? { contextWindow: override.contextWindow } : {}),
+    ...(override.maxTokens !== undefined ? { maxTokens: override.maxTokens } : {}),
+  };
+}
+
+export function buildUnavailableProviderModels(id = "login-required"): ProviderModelConfigLike[] {
+  return [{ id, name: id, ...cloneModelDefaults() }];
+}
+
+export function buildProviderModels(
+  cpaModels: CpaModel[],
+  catalog: ModelsDevCatalog,
+  aliases: Record<string, string>,
+  gpt56ContextWindow: Gpt56ContextWindowMode = "canonical",
+  overrides: ProviderModelOverrides = {},
+  metadataFallbackProvider: string | null = "openrouter",
+): BuildProviderModelsResult {
+  const matchMethods = emptyMatchMethods();
+  const unmatchedModelIds: string[] = [];
+  let enriched = 0;
+
+  const models = cpaModels.map((cpaModel) => {
+    const match = findMetadataMatch(cpaModel, catalog, aliases, metadataFallbackProvider);
+    if (!match) {
+      unmatchedModelIds.push(cpaModel.id);
+      return applyModelOverride(defaultModel(cpaModel, gpt56ContextWindow), overrides);
+    }
+
+    enriched += 1;
+    matchMethods[match.method] += 1;
+    return applyModelOverride(
+      modelFromMetadata(cpaModel, match.metadata, gpt56ContextWindow),
+      overrides,
+    );
+  });
+
+  return {
+    models,
+    stats: {
+      total: cpaModels.length,
+      enriched,
+      unmatched: unmatchedModelIds.length,
+      matchMethods,
+      unmatchedModelIds,
+    },
+  };
+}