pi-better-model-select 0.1.3

package/extensions/lib/flows.ts

@@ -0,0 +1,503 @@
+// Add / update / delete flows against the effective model configuration.
+//
+// Each mutation asks which file to write, then re-reads that file immediately
+// before saving so another pi session's edit is not silently clobbered.
+
+import {
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_TOKENS,
+  fetchModelMeta,
+  listEndpointModels,
+  parsePositiveInt,
+  providerEndpoint,
+  resolveKey,
+  type ModelMeta,
+} from "./meta.ts";
+import {
+  configContainsModel,
+  loadConfig,
+  loadConfigFile,
+  saveConfig,
+  tombstoneModel,
+  upsertModel,
+  type ConfigTarget,
+  type ModelEntry,
+  type ModelsConfig,
+} from "./store.ts";
+
+// Minimal shape of the pi extension command context we rely on.
+export interface FlowCtx {
+  ui: {
+    notify: (message: string, level: string) => void;
+    select: (message: string, options: string[]) => Promise<string | undefined>;
+    input: (message: string, initial?: string) => Promise<string | undefined>;
+    confirm: (title: string, message: string) => Promise<boolean>;
+  };
+}
+
+const INPUT_OPTIONS: string[][] = [["text"], ["text", "image"]];
+
+const TARGET_LABELS = {
+  "models.local.json": "models.local.json (personal BMS overlay)",
+  "models.json": "models.json (Pi configuration)",
+} satisfies Record<ConfigTarget, string>;
+
+async function selectWriteTarget(
+  ctx: FlowCtx,
+  message = "Write changes to which file?",
+): Promise<ConfigTarget | undefined> {
+  const options = [TARGET_LABELS["models.local.json"], TARGET_LABELS["models.json"]];
+  const pick = await ctx.ui.select(message, options);
+  if (pick === TARGET_LABELS["models.local.json"]) return "models.local.json";
+  if (pick === TARGET_LABELS["models.json"]) return "models.json";
+  return undefined;
+}
+
+function providerOverlay(config: ModelsConfig, providerName: string): Record<string, unknown> {
+  const provider = config.providers?.[providerName] ?? {};
+  const { models: _models, ...settings } = provider;
+  return settings;
+}
+
+function completeModel(config: ModelsConfig, providerName: string, modelId: string): ModelEntry | undefined {
+  const model = config.providers?.[providerName]?.models?.find((entry) => entry.id === modelId);
+  return model ? structuredClone(model) : undefined;
+}
+
+function ensureProviderSettings(
+  targetConfig: ModelsConfig,
+  effectiveConfig: ModelsConfig,
+  providerName: string,
+): void {
+  targetConfig.providers = targetConfig.providers ?? {};
+  targetConfig.providers[providerName] = {
+    ...providerOverlay(effectiveConfig, providerName),
+    ...(targetConfig.providers[providerName] ?? {}),
+  };
+}
+
+/** Present a yes/no as a select so ESC can cancel — confirm() cannot. */
+async function selectYesNo(
+  ctx: FlowCtx,
+  message: string,
+  defaultYes: boolean,
+): Promise<boolean | undefined> {
+  const first = defaultYes ? "yes" : "no";
+  const pick = await ctx.ui.select(message, [first, defaultYes ? "no" : "yes"]);
+  return pick === undefined ? undefined : pick === "yes";
+}
+
+async function selectInput(
+  ctx: FlowCtx,
+  message: string,
+  current: string[],
+): Promise<string[] | undefined> {
+  const labels = INPUT_OPTIONS.map((o) => o.join("+"));
+  const idx = labels.indexOf(current.join("+"));
+  const def = labels[Math.max(idx, 0)]!;
+  const pick = await ctx.ui.select(message, [def, ...labels.filter((l) => l !== def)]);
+  if (pick === undefined) return undefined;
+  return INPUT_OPTIONS[labels.indexOf(pick)] ?? ["text"];
+}
+
+// ----- add -----------------------------------------------------------------
+
+export async function addFlow(ctx: FlowCtx): Promise<void> {
+  const config = loadConfig(ctx);
+  if (!config) return;
+  const providers = config.providers ?? {};
+
+  const names = Object.keys(providers).filter((n) => typeof providers[n]?.baseUrl === "string");
+  if (names.length === 0) {
+    ctx.ui.notify("No providers with a baseUrl in the effective model config", "warning");
+    return;
+  }
+
+  // Running breadcrumb of everything chosen so far, shown atop each prompt.
+  const crumbs: string[] = [];
+  const header = () =>
+    crumbs.length ? `Selected so far:\n${crumbs.map((c) => `  • ${c}`).join("\n")}\n\n` : "";
+
+  const providerName = await ctx.ui.select(`${header()}Select provider:`, names);
+  if (providerName === undefined) return;
+  const provider = providers[providerName]!;
+  crumbs.push(`Provider: ${providerName}`);
+
+  const base = String(provider.baseUrl).replace(/\/+$/, "");
+  const key = resolveKey(provider.apiKey);
+
+  let ids: string[];
+  try {
+    ids = await listEndpointModels(base, key);
+  } catch (e) {
+    ctx.ui.notify(`Failed to list models: ${e}`, "error");
+    return;
+  }
+
+  const existing = new Set((provider.models ?? []).map((m) => m.id));
+  const candidates = ids.filter((id) => !existing.has(id)).sort();
+  if (candidates.length === 0) {
+    ctx.ui.notify("All endpoint models are already configured", "info");
+    return;
+  }
+
+  const modelId = await ctx.ui.select(
+    `${header()}Add which model to "${providerName}"?`,
+    candidates,
+  );
+  if (modelId === undefined) return;
+  crumbs.push(`Model: ${modelId}`);
+
+  const meta = await fetchModelMeta(base, key, modelId);
+
+  const prefilled: string[] = [];
+  if (meta.contextWindow !== undefined) prefilled.push(`ctx=${meta.contextWindow}`);
+  if (meta.maxTokens !== undefined) prefilled.push(`max=${meta.maxTokens}`);
+  if (meta.reasoning !== undefined) prefilled.push(`reasoning=${meta.reasoning}`);
+  if (prefilled.length > 0) {
+    ctx.ui.notify(`Auto-filled from provider: ${prefilled.join(", ")}`, "info");
+  }
+
+  const nameRaw = await ctx.ui.input(`${header()}Display name:`, modelId);
+  if (nameRaw === undefined) return;
+  const name = nameRaw || modelId;
+  crumbs.push(`Name: ${name}`);
+
+  const cwDefault = meta.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+  const cwRaw = await ctx.ui.input(`${header()}Context window:`, String(cwDefault));
+  if (cwRaw === undefined) return;
+  const contextWindow = parsePositiveInt(cwRaw, cwDefault);
+  crumbs.push(`Context window: ${contextWindow}`);
+
+  const mtDefault = meta.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const mtRaw = await ctx.ui.input(`${header()}Max output tokens:`, String(mtDefault));
+  if (mtRaw === undefined) return;
+  const maxTokens = parsePositiveInt(mtRaw, mtDefault);
+  crumbs.push(`Max output tokens: ${maxTokens}`);
+
+  const reasoning = await selectYesNo(
+    ctx,
+    `${header()}Reasoning model?`,
+    Boolean(meta.reasoning),
+  );
+  if (reasoning === undefined) return;
+  crumbs.push(`Reasoning: ${reasoning ? "yes" : "no"}`);
+
+  const input = await selectInput(ctx, `${header()}Input modalities:`, meta.input ?? ["text"]);
+  if (input === undefined) return;
+  crumbs.push(`Input: ${input.join("+")}`);
+
+  const writeTarget = await selectWriteTarget(ctx);
+  if (!writeTarget) return;
+  const ok = await ctx.ui.confirm(
+    `${header()}Add this model to "${providerName}"?`,
+    `Write the entry to ${writeTarget}?`,
+  );
+  if (!ok) {
+    ctx.ui.notify("Cancelled. Nothing written.", "info");
+    return;
+  }
+
+  const freshEffective = loadConfig(ctx);
+  const freshTarget = loadConfigFile(ctx, writeTarget, writeTarget === "models.local.json");
+  if (!freshEffective || !freshTarget) return;
+  if (!freshEffective.providers?.[providerName]) {
+    ctx.ui.notify(`Provider "${providerName}" no longer exists.`, "error");
+    return;
+  }
+  if (configContainsModel(freshEffective, providerName, modelId)) {
+    ctx.ui.notify(`Model "${modelId}" is already configured in ${providerName}.`, "warning");
+    return;
+  }
+  ensureProviderSettings(freshTarget, freshEffective, providerName);
+  upsertModel(freshTarget, providerName, {
+    id: modelId,
+    name,
+    reasoning,
+    input,
+    contextWindow,
+    maxTokens,
+  });
+  saveConfig(freshTarget, writeTarget);
+  ctx.ui.notify(`Added "${modelId}" to ${providerName} in ${writeTarget}.`, "info");
+}
+
+// ----- update --------------------------------------------------------------
+
+interface Field {
+  key: string;
+  label: string;
+  current: string;
+  suggest?: string;
+  edit: (header: () => string) => Promise<unknown | undefined>;
+}
+
+export async function updateFlow(
+  ctx: FlowCtx,
+  preselect?: { provider: string; modelId: string },
+): Promise<void> {
+  const config = loadConfig(ctx);
+  if (!config) return;
+  const providers = config.providers ?? {};
+
+  let providerName: string;
+  let existing: ModelEntry;
+
+  if (preselect && providers[preselect.provider]?.models?.some((m) => m.id === preselect.modelId)) {
+    providerName = preselect.provider;
+    existing = providers[preselect.provider]!.models!.find((m) => m.id === preselect.modelId)!;
+  } else {
+    const map = new Map<string, { provider: string; model: ModelEntry }>();
+    for (const p of Object.keys(providers)) {
+      for (const m of providers[p]!.models ?? []) {
+        const label = `${m.name ?? m.id}   [${p}]  (ctx: ${m.contextWindow ?? "?"}, max: ${m.maxTokens ?? "?"}, reasoning: ${m.reasoning ? "yes" : "no"})`;
+        map.set(label, { provider: p, model: m });
+      }
+    }
+    if (map.size === 0) {
+      ctx.ui.notify("No models configured to update.", "info");
+      return;
+    }
+    const label = await ctx.ui.select("Update which model?", [...map.keys()]);
+    if (label === undefined) return;
+    const hit = map.get(label)!;
+    providerName = hit.provider;
+    existing = hit.model;
+  }
+
+  // Try to refresh metadata from the provider.
+  const ep = providerEndpoint(config, providerName);
+  let meta: ModelMeta = {};
+  if (ep) {
+    meta = await fetchModelMeta(ep.base, ep.key, existing.id);
+    const diffs: string[] = [];
+    if (meta.contextWindow !== undefined && meta.contextWindow !== existing.contextWindow)
+      diffs.push(`ctx: ${existing.contextWindow ?? "?"} → ${meta.contextWindow}`);
+    if (meta.maxTokens !== undefined && meta.maxTokens !== existing.maxTokens)
+      diffs.push(`max: ${existing.maxTokens ?? "?"} → ${meta.maxTokens}`);
+    if (meta.reasoning !== undefined && meta.reasoning !== (existing.reasoning ?? false))
+      diffs.push(`reasoning: ${existing.reasoning ?? false} → ${meta.reasoning}`);
+    if (meta.input !== undefined && meta.input.join("+") !== (existing.input ?? ["text"]).join("+"))
+      diffs.push(`input: ${(existing.input ?? ["text"]).join("+")} → ${meta.input.join("+")}`);
+    ctx.ui.notify(
+      diffs.length > 0
+        ? `Provider suggests updates: ${diffs.join(", ")}`
+        : "Provider info matches current config — no changes suggested.",
+      "info",
+    );
+  }
+
+  const fields: Field[] = [
+    {
+      key: "name",
+      label: "Display name",
+      current: existing.name ?? existing.id,
+      edit: async (header) => {
+        const raw = await ctx.ui.input(`${header()}Display name:`, existing.name ?? existing.id);
+        return raw === undefined ? undefined : raw || existing.id;
+      },
+    },
+    {
+      key: "contextWindow",
+      label: "Context window",
+      current: String(existing.contextWindow ?? DEFAULT_CONTEXT_WINDOW),
+      suggest: meta.contextWindow !== undefined ? String(meta.contextWindow) : undefined,
+      edit: async (header) => {
+        const cur = existing.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+        const def = meta.contextWindow ?? cur;
+        const hint =
+          meta.contextWindow !== undefined && meta.contextWindow !== cur
+            ? ` (provider: ${meta.contextWindow}, current: ${cur})`
+            : "";
+        const raw = await ctx.ui.input(`${header()}Context window${hint}:`, String(def));
+        return raw === undefined ? undefined : parsePositiveInt(raw, def);
+      },
+    },
+    {
+      key: "maxTokens",
+      label: "Max output tokens",
+      current: String(existing.maxTokens ?? DEFAULT_MAX_TOKENS),
+      suggest: meta.maxTokens !== undefined ? String(meta.maxTokens) : undefined,
+      edit: async (header) => {
+        const cur = existing.maxTokens ?? DEFAULT_MAX_TOKENS;
+        const def = meta.maxTokens ?? cur;
+        const hint =
+          meta.maxTokens !== undefined && meta.maxTokens !== cur
+            ? ` (provider: ${meta.maxTokens}, current: ${cur})`
+            : "";
+        const raw = await ctx.ui.input(`${header()}Max output tokens${hint}:`, String(def));
+        return raw === undefined ? undefined : parsePositiveInt(raw, def);
+      },
+    },
+    {
+      key: "reasoning",
+      label: "Reasoning model",
+      current: existing.reasoning ? "yes" : "no",
+      suggest: meta.reasoning !== undefined ? (meta.reasoning ? "yes" : "no") : undefined,
+      edit: async (header) =>
+        selectYesNo(
+          ctx,
+          `${header()}Reasoning model?`,
+          meta.reasoning ?? existing.reasoning ?? false,
+        ),
+    },
+    {
+      key: "input",
+      label: "Input modalities",
+      current: (existing.input ?? ["text"]).join("+"),
+      suggest: meta.input !== undefined ? meta.input.join("+") : undefined,
+      edit: async (header) =>
+        selectInput(
+          ctx,
+          `${header()}Input modalities:`,
+          meta.input ?? existing.input ?? ["text"],
+        ),
+    },
+  ];
+
+  const changes = new Map<string, unknown>();
+  for (;;) {
+    const options = fields.map(
+      (f) =>
+        `${changes.has(f.key) ? "•" : "·"} ${f.label}: ${f.current}${
+          f.suggest !== undefined && f.suggest !== f.current ? ` → provider: ${f.suggest}` : ""
+        }${changes.has(f.key) ? `  [changed: ${String(changes.get(f.key))}]` : ""}`,
+    );
+    const pick = await ctx.ui.select(
+      `Update which attribute of ${existing.id} [${providerName}]?\n(• = will be written, ESC to finish)`,
+      [...options, "Done — write changes"],
+    );
+    if (pick === undefined || pick.startsWith("Done")) break;
+    const idx = options.indexOf(pick);
+    const field = fields[idx];
+    if (!field) continue;
+    const value = await field.edit(() => `Model: ${existing.id} [${providerName}]\n`);
+    if (value === undefined) continue; // ESC in the field editor — back to list
+    changes.set(field.key, value);
+  }
+
+  if (changes.size === 0) {
+    ctx.ui.notify("No changes made.", "info");
+    return;
+  }
+
+  const writeTarget = await selectWriteTarget(ctx);
+  if (!writeTarget) return;
+  const ok = await ctx.ui.confirm(
+    `Update ${existing.id}?`,
+    `Write ${[...changes.keys()].join(", ")} to "${providerName}" in ${writeTarget}?`,
+  );
+  if (!ok) {
+    ctx.ui.notify("Cancelled. Nothing updated.", "info");
+    return;
+  }
+
+  const freshEffective = loadConfig(ctx);
+  const freshTarget = loadConfigFile(ctx, writeTarget, writeTarget === "models.local.json");
+  if (!freshEffective || !freshTarget) return;
+  const modelEntry = completeModel(freshEffective, providerName, existing.id);
+  if (!modelEntry) {
+    ctx.ui.notify(`Model "${existing.id}" no longer exists in ${providerName}.`, "error");
+    return;
+  }
+  Object.assign(modelEntry, Object.fromEntries(changes));
+  ensureProviderSettings(freshTarget, freshEffective, providerName);
+  upsertModel(freshTarget, providerName, modelEntry);
+  saveConfig(freshTarget, writeTarget);
+  ctx.ui.notify(
+    `Updated "${existing.id}" in ${providerName} via ${writeTarget}: ${[...changes.entries()]
+      .map(([k, v]) => `${k}=${Array.isArray(v) ? v.join("+") : String(v)}`)
+      .join(", ")}.`,
+    "info",
+  );
+}
+
+// ----- delete --------------------------------------------------------------
+
+export async function deleteFlow(
+  ctx: FlowCtx,
+  preselect?: { provider: string; modelId: string },
+): Promise<void> {
+  const config = loadConfig(ctx);
+  if (!config) return;
+  const providers = config.providers ?? {};
+
+  let provider: string;
+  let id: string;
+
+  if (preselect && providers[preselect.provider]?.models?.some((m) => m.id === preselect.modelId)) {
+    provider = preselect.provider;
+    id = preselect.modelId;
+  } else {
+    const map = new Map<string, { provider: string; id: string }>();
+    for (const p of Object.keys(providers)) {
+      for (const m of providers[p]!.models ?? []) {
+        map.set(`${m.id}   [${p}]`, { provider: p, id: m.id });
+      }
+    }
+    if (map.size === 0) {
+      ctx.ui.notify("No models configured to delete.", "info");
+      return;
+    }
+    const label = await ctx.ui.select("Delete which model?", [...map.keys()]);
+    if (label === undefined) return;
+    ({ provider, id } = map.get(label)!);
+  }
+
+  const base = loadConfigFile(ctx, "models.json");
+  const local = loadConfigFile(ctx, "models.local.json", true);
+  if (!base || !local) return;
+
+  const candidates: ConfigTarget[] = [];
+  if (configContainsModel(local, provider, id)) candidates.push("models.local.json");
+  if (configContainsModel(base, provider, id)) candidates.push("models.json");
+  if (candidates.length === 0) {
+    ctx.ui.notify(`Model "${id}" is no longer present in either config file.`, "warning");
+    return;
+  }
+
+  if (candidates.length === 1 && candidates[0] === "models.json") {
+    const ok = await ctx.ui.confirm(
+      `Hide inherited model ${id}?`,
+      "Keep models.json unchanged and add a BMS tombstone to models.local.json?",
+    );
+    if (!ok) {
+      ctx.ui.notify("Cancelled. Nothing deleted.", "info");
+      return;
+    }
+
+    const freshLocal = loadConfigFile(ctx, "models.local.json", true);
+    if (!freshLocal) return;
+    tombstoneModel(freshLocal, provider, id);
+    saveConfig(freshLocal, "models.local.json");
+    ctx.ui.notify(`Hidden inherited model "${id}" via models.local.json.`, "info");
+    return;
+  }
+
+  let writeTarget: ConfigTarget;
+  if (candidates.length === 1) {
+    writeTarget = candidates[0]!;
+  } else {
+    const selected = await selectWriteTarget(ctx, "Remove the model from which file?");
+    if (!selected) return;
+    writeTarget = selected;
+  }
+
+  const ok = await ctx.ui.confirm(
+    `Delete ${id}?`,
+    `Remove it from "${provider}" in ${writeTarget}?`,
+  );
+  if (!ok) {
+    ctx.ui.notify("Cancelled. Nothing deleted.", "info");
+    return;
+  }
+
+  const fresh = loadConfigFile(ctx, writeTarget, writeTarget === "models.local.json");
+  if (!fresh) return;
+  const target = fresh.providers?.[provider];
+  if (target?.models) {
+    target.models = target.models.filter((m) => m.id !== id);
+    saveConfig(fresh, writeTarget);
+    ctx.ui.notify(`Deleted "${id}" from ${provider} in ${writeTarget}.`, "info");
+  }
+}

package/extensions/lib/meta.ts

@@ -0,0 +1,171 @@
+// Provider metadata discovery.
+//
+// Tries, in order: LiteLLM /model/info, OpenAI-style /models/{id}, then the
+// public LiteLLM cost map. Every step is best-effort — a plain OpenAI-compatible
+// endpoint yields nothing and the caller falls back to explicit defaults.
+
+import type { ModelsConfig } from "./store.ts";
+
+export const DEFAULT_CONTEXT_WINDOW = 128000;
+export const DEFAULT_MAX_TOKENS = 32768;
+
+export interface ModelMeta {
+  contextWindow?: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  input?: string[];
+}
+
+/** Parse a positive integer; falls back instead of writing NaN on bad input. */
+export function parsePositiveInt(raw: string | undefined, fallback: number): number {
+  const n = parseInt(raw ?? "", 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+/** apiKey in models.json may be a literal ("sk-...") or an env ref ("$ENV_VAR"). */
+export function resolveKey(apiKey?: string): string {
+  if (!apiKey) return "";
+  return apiKey.startsWith("$") ? process.env[apiKey.slice(1)] ?? "" : apiKey;
+}
+
+/** Resolve provider API key (literal or $ENV_REF) + base URL. */
+export function providerEndpoint(
+  config: ModelsConfig,
+  providerName: string,
+): { base: string; key: string } | null {
+  const provider = config.providers?.[providerName];
+  if (!provider?.baseUrl) return null;
+  return {
+    base: String(provider.baseUrl).replace(/\/+$/, ""),
+    key: resolveKey(provider.apiKey),
+  };
+}
+
+/** List model ids advertised by an OpenAI-compatible /models endpoint. */
+export async function listEndpointModels(base: string, key: string): Promise<string[]> {
+  const headers: Record<string, string> = key ? { Authorization: `Bearer ${key}` } : {};
+  const res = await fetch(`${base}/models`, { headers });
+  if (!res.ok) throw new Error(`GET ${base}/models -> ${res.status} ${res.statusText}`);
+  const body = (await res.json()) as { data?: Array<{ id?: string }> };
+  return (body.data ?? []).map((m) => m.id).filter((id): id is string => Boolean(id));
+}
+
+export async function fetchModelMeta(
+  base: string,
+  key: string,
+  modelId: string,
+): Promise<ModelMeta> {
+  let metaContext: number | undefined;
+  let metaMaxTokens: number | undefined;
+  let metaReasoning: boolean | undefined;
+  let metaInput: string[] | undefined;
+
+  // Heuristic: common reasoning-model name patterns.
+  const reasoningPattern = /o\d|reasoning|think|deepseek|r1|qwq|glm-5/i;
+  const heuristicReasoning = reasoningPattern.test(modelId);
+
+  const authHeaders: Record<string, string> = key ? { Authorization: `Bearer ${key}` } : {};
+
+  // 1) LiteLLM /model/info
+  try {
+    const infoRes = await fetch(`${base}/model/info`, {
+      headers: authHeaders,
+      signal: AbortSignal.timeout(5000),
+    });
+    if (infoRes.ok) {
+      const infoBody = (await infoRes.json()) as { data?: unknown[] } | unknown[];
+      const models = (Array.isArray(infoBody) ? infoBody : infoBody?.data ?? []) as Array<{
+        model_name?: string;
+        litellm_params?: { model?: string; tags?: string[] };
+        model_info?: Record<string, unknown> & { key?: string };
+      }>;
+      const match = models.find(
+        (m) =>
+          m.model_name === modelId ||
+          m.litellm_params?.model === modelId ||
+          m.model_info?.key === modelId,
+      );
+      if (match?.model_info) {
+        const mi = match.model_info as Record<string, any>;
+        metaContext = mi.max_input_tokens ?? mi.max_tokens;
+        // Only trust an explicit output cap — LiteLLM's generic `max_tokens`
+        // is often a default (e.g. 4096/128000), not the model's real cap.
+        if (typeof mi.max_output_tokens === "number") metaMaxTokens = mi.max_output_tokens;
+
+        let vision = Boolean(mi.supports_vision);
+        const tags = match.litellm_params?.tags ?? [];
+        if (tags.includes("visual") || tags.includes("vision")) vision = true;
+        if (typeof mi.litellm_provider === "string" && mi.litellm_provider.length > 0) {
+          metaInput = mi.litellm_provider.includes("image") ? ["text", "image"] : ["text"];
+        } else if (vision) {
+          metaInput = ["text", "image"];
+        }
+      }
+    }
+  } catch {
+    // Not a LiteLLM proxy or endpoint unavailable — ignore.
+  }
+
+  // 2) OpenAI-style per-model GET
+  if (metaContext === undefined) {
+    try {
+      const modelRes = await fetch(`${base}/models/${encodeURIComponent(modelId)}`, {
+        headers: authHeaders,
+        signal: AbortSignal.timeout(5000),
+      });
+      if (modelRes.ok) {
+        const b = (await modelRes.json()) as Record<string, any>;
+        // OpenAI /v1/models/{id} does not return token limits, but some proxies
+        // add custom fields like max_context_length or max_model_tokens.
+        metaContext =
+          b.max_context_length ?? b.max_input_tokens ?? b.context_window ?? b.max_tokens;
+        metaMaxTokens = b.max_output_tokens ?? b.max_completion_tokens ?? metaContext;
+      }
+    } catch {
+      // Endpoint not supported — ignore.
+    }
+  }
+
+  // 3) LiteLLM public model cost map
+  if (metaContext === undefined) {
+    try {
+      const costRes = await fetch(
+        "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json",
+        { signal: AbortSignal.timeout(5000) },
+      );
+      if (costRes.ok) {
+        const costMap = (await costRes.json()) as Record<string, any>;
+        for (const candidate of [modelId, ...modelId.split("/").slice(1)]) {
+          const entry = costMap[candidate];
+          if (!entry) continue;
+          metaContext = entry.max_input_tokens ?? entry.max_tokens;
+          metaMaxTokens = entry.max_output_tokens ?? entry.max_tokens;
+          metaReasoning =
+            entry.mode === "reasoning" || entry.reasoning === true || heuristicReasoning;
+          if (entry.input_cost_per_token > 0 || entry.output_cost_per_token > 0) {
+            metaInput = entry.supports_vision ? ["text", "image"] : ["text"];
+          }
+          break;
+        }
+      }
+    } catch {
+      // No internet or fetch failed — ignore.
+    }
+  }
+
+  // Heuristic defaults for anything still undetermined. Note: no default is
+  // invented for maxTokens — callers fall back to a constant explicitly so we
+  // never write NaN into models.json.
+  if (metaReasoning === undefined) metaReasoning = heuristicReasoning;
+  if (metaInput === undefined) {
+    const visionPattern = /vision|claude-3-opus|gpt-4o|gpt-5|gemini|llava/i;
+    metaInput = visionPattern.test(modelId) ? ["text", "image"] : ["text"];
+  }
+
+  return {
+    contextWindow: metaContext,
+    maxTokens: metaMaxTokens,
+    reasoning: metaReasoning,
+    input: metaInput,
+  };
+}