@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/model-scope.test.mjs

@@ -0,0 +1,193 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  try {
+    const { createJiti } = await import("jiti");
+    return createJiti(import.meta.url).import("./model-scope.ts");
+  } catch {
+    return import("./model-scope.ts");
+  }
+}
+
+const { resolveVisibleModels, selectInitialModelScope } = await loadSubject();
+
+const MODELS = [
+  { id: "claude-opus-5", provider: "anthropic", name: "Claude Opus 5" },
+  { id: "claude-sonnet-5", provider: "anthropic", name: "Claude Sonnet 5" },
+  { id: "claude-sonnet-4-6", provider: "anthropic", name: "Claude Sonnet 4.6" },
+  { id: "claude-opus-4-8", provider: "acme-gateway", name: "Claude Opus 4.8 (Acme)" },
+  { id: "claude-sonnet-5", provider: "acme-gateway", name: "Claude Sonnet 5 (Acme)" },
+  { id: "gpt-5.6-sol", provider: "acme-gateway-openai", name: "GPT-5.6 (Acme)" },
+];
+
+const runtime = { getAvailable: async () => MODELS };
+
+const refs = (result) => result.visible.map((m) => `${m.provider}/${m.id}`);
+
+test("returns every available model when no patterns are configured", async () => {
+  for (const patterns of [undefined, [], ["", "   "]]) {
+    const result = await resolveVisibleModels(runtime, patterns);
+    assert.deepEqual(refs(result), MODELS.map((m) => `${m.provider}/${m.id}`));
+    assert.deepEqual(result.scopedModels, []);
+    assert.deepEqual(result.warnings, []);
+  }
+});
+
+test("expands provider globs alongside exact references (#307)", async () => {
+  const result = await resolveVisibleModels(runtime, [
+    "anthropic/claude-sonnet-5",
+    "anthropic/claude-opus-5",
+    "acme-gateway/*",
+    "acme-gateway-openai/*",
+  ]);
+
+  assert.deepEqual(refs(result).sort(), [
+    "acme-gateway-openai/gpt-5.6-sol",
+    "acme-gateway/claude-opus-4-8",
+    "acme-gateway/claude-sonnet-5",
+    "anthropic/claude-opus-5",
+    "anthropic/claude-sonnet-5",
+  ]);
+  assert.deepEqual(result.warnings, []);
+});
+
+test("matches bare model id globs across providers without duplicates", async () => {
+  const result = await resolveVisibleModels(runtime, ["*sonnet*"]);
+
+  assert.deepEqual(refs(result).sort(), [
+    "acme-gateway/claude-sonnet-5",
+    "anthropic/claude-sonnet-4-6",
+    "anthropic/claude-sonnet-5",
+  ]);
+});
+
+test("rejects an ambiguous bare exact model id before fuzzy matching", async () => {
+  await assert.rejects(
+    resolveVisibleModels(runtime, ["claude-sonnet-5"]),
+    /Ambiguous enabledModels entry.*acme-gateway\/claude-sonnet-5.*anthropic\/claude-sonnet-5.*provider\/modelId/,
+  );
+});
+
+test("accepts provider-qualified and unique bare exact model ids", async () => {
+  const qualified = await resolveVisibleModels(runtime, ["acme-gateway/claude-sonnet-5"]);
+  assert.deepEqual(refs(qualified), ["acme-gateway/claude-sonnet-5"]);
+
+  const unique = await resolveVisibleModels(runtime, ["gpt-5.6-sol"]);
+  assert.deepEqual(refs(unique), ["acme-gateway-openai/gpt-5.6-sol"]);
+});
+
+test("rejects an ambiguous bare exact model id with a thinking suffix", async () => {
+  await assert.rejects(
+    resolveVisibleModels(runtime, ["claude-sonnet-5:high"]),
+    /Ambiguous enabledModels entry/,
+  );
+});
+
+test("keeps thinking-level suffixes out of the matched reference and reports them as pins", async () => {
+  const pinned = await resolveVisibleModels(runtime, ["anthropic/*:high"]);
+  assert.deepEqual(refs(pinned).sort(), [
+    "anthropic/claude-opus-5",
+    "anthropic/claude-sonnet-4-6",
+    "anthropic/claude-sonnet-5",
+  ]);
+  assert.deepEqual(pinned.thinkingLevelPins, {
+    "anthropic/claude-opus-5": "high",
+    "anthropic/claude-sonnet-5": "high",
+    "anthropic/claude-sonnet-4-6": "high",
+  });
+
+  const single = await resolveVisibleModels(runtime, ["acme-gateway/claude-opus-4-8:low"]);
+  assert.deepEqual(refs(single), ["acme-gateway/claude-opus-4-8"]);
+  assert.deepEqual(single.thinkingLevelPins, { "acme-gateway/claude-opus-4-8": "low" });
+});
+
+test("leaves models without a pinned thinking level unpinned", async () => {
+  const result = await resolveVisibleModels(runtime, ["anthropic/claude-opus-5:high", "acme-gateway/*"]);
+
+  assert.deepEqual(result.thinkingLevelPins, { "anthropic/claude-opus-5": "high" });
+});
+
+test("reports patterns that match nothing but keeps the models that matched", async () => {
+  const result = await resolveVisibleModels(runtime, ["anthropic/claude-opus-5", "ghost-gateway/*"]);
+
+  assert.deepEqual(refs(result), ["anthropic/claude-opus-5"]);
+  assert.equal(result.warnings.length, 1);
+  assert.match(result.warnings[0], /ghost-gateway\/\*/);
+});
+
+test("falls back to all available models when nothing matches at all", async () => {
+  const result = await resolveVisibleModels(runtime, ["ghost-gateway/*"]);
+
+  assert.deepEqual(refs(result), MODELS.map((m) => `${m.provider}/${m.id}`));
+  assert.equal(result.warnings.length, 1);
+  assert.deepEqual(result.scopedModels, []);
+  assert.deepEqual(result.thinkingLevelPins, {});
+});
+
+test("selects the saved scoped default and applies its thinking pin", async () => {
+  const scope = await resolveVisibleModels(runtime, [
+    "anthropic/claude-opus-5:high",
+    "acme-gateway/*:low",
+  ]);
+  const initial = selectInitialModelScope(scope, {
+    defaultModel: { provider: "acme-gateway", modelId: "claude-sonnet-5" },
+  });
+
+  assert.equal(`${initial.model.provider}/${initial.model.id}`, "acme-gateway/claude-sonnet-5");
+  assert.equal(initial.thinkingLevel, "low");
+  assert.equal(initial.scopedModels.length, 3);
+});
+
+test("uses the saved default without creating a synthetic scope when unconfigured", async () => {
+  const scope = await resolveVisibleModels(runtime, undefined);
+  const initial = selectInitialModelScope(scope, {
+    defaultModel: { provider: "acme-gateway-openai", modelId: "gpt-5.6-sol" },
+  });
+
+  assert.equal(`${initial.model.provider}/${initial.model.id}`, "acme-gateway-openai/gpt-5.6-sol");
+  assert.equal(initial.thinkingLevel, undefined);
+  assert.deepEqual(initial.scopedModels, []);
+});
+
+test("uses resolver order when the saved default is outside the enabled scope", async () => {
+  const scope = await resolveVisibleModels(runtime, [
+    "anthropic/claude-opus-5:high",
+    "anthropic/claude-sonnet-5:low",
+  ]);
+  const initial = selectInitialModelScope(scope, {
+    defaultModel: { provider: "acme-gateway-openai", modelId: "gpt-5.6-sol" },
+  });
+
+  assert.equal(`${initial.model.provider}/${initial.model.id}`, "anthropic/claude-opus-5");
+  assert.equal(initial.thinkingLevel, "high");
+});
+
+test("applies a requested scoped model pin unless thinking was explicitly overridden", async () => {
+  const scope = await resolveVisibleModels(runtime, ["anthropic/*:high"]);
+  const requestedModel = { provider: "anthropic", modelId: "claude-sonnet-5" };
+
+  assert.equal(
+    selectInitialModelScope(scope, { requestedModel }).thinkingLevel,
+    "high",
+  );
+  assert.equal(
+    selectInitialModelScope(scope, { requestedModel, thinkingLevel: "low" }).thinkingLevel,
+    "low",
+  );
+  assert.equal(
+    selectInitialModelScope(scope, { requestedModel, thinkingLevel: "off" }).thinkingLevel,
+    "off",
+  );
+});
+
+test("rejects an explicit model outside the enabled scope", async () => {
+  const scope = await resolveVisibleModels(runtime, ["anthropic/*"]);
+
+  assert.throws(
+    () => selectInitialModelScope(scope, {
+      requestedModel: { provider: "acme-gateway", modelId: "claude-sonnet-5" },
+    }),
+    /not available in the enabled scope/,
+  );
+});

package/lib/model-scope.ts

@@ -0,0 +1,198 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import {
+  resolveModelScopeWithDiagnostics,
+  type ModelRuntime,
+  type ScopedModel,
+} from "@earendil-works/pi-coding-agent";
+import type { Api, Model } from "@earendil-works/pi-ai";
+
+const THINKING_LEVEL_SUFFIXES = new Set<ThinkingLevel>([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]);
+
+/**
+ * Model scoping shared by the UI selector and AgentSession startup.
+ *
+ * The `enabledModels` setting uses the same syntax as pi's `--models` flag:
+ * globs matched with minimatch against `provider/modelId` or a bare `modelId`,
+ * fuzzy matching for non-glob patterns, plus an optional `:thinkingLevel` suffix
+ * (`anthropic/*:high`). Exact string comparison silently drops every model
+ * behind a pattern like `my-gateway/*` (#307), so delegate to pi's own resolver
+ * instead of reimplementing the matching rules here.
+ */
+
+export interface ModelScopeResult {
+  /** Models the UI should offer, in resolver order (all available when unscoped). */
+  visible: readonly Model<Api>[];
+  /** SDK-native scope retained for AgentSession model cycling and extensions. */
+  scopedModels: readonly ScopedModel[];
+  /** `provider/modelId` → thinking level pinned with a `:level` pattern suffix. */
+  thinkingLevelPins: Record<string, string>;
+  /** Resolver diagnostics, e.g. a pattern that matched no model. */
+  warnings: string[];
+}
+
+export interface InitialModelScopeOptions {
+  requestedModel?: { provider: string; modelId: string };
+  defaultModel?: { provider: string; modelId: string };
+  thinkingLevel?: ThinkingLevel;
+}
+
+export interface InitialModelScopeResult {
+  model?: Model<Api>;
+  thinkingLevel?: ThinkingLevel;
+  scopedModels: ScopedModel[];
+}
+
+function matchesModel(
+  model: { provider: string; id: string },
+  ref: { provider: string; modelId: string },
+): boolean {
+  return model.provider === ref.provider && model.id === ref.modelId;
+}
+
+function hasGlob(pattern: string): boolean {
+  return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+}
+
+function exactReferenceMatches(pattern: string, models: readonly Model<Api>[]): Model<Api>[] {
+  const normalized = pattern.toLowerCase();
+  const canonical = models.filter(
+    (model) => `${model.provider}/${model.id}`.toLowerCase() === normalized,
+  );
+  if (canonical.length > 0) return canonical;
+  return models.filter((model) => model.id.toLowerCase() === normalized);
+}
+
+function assertNoAmbiguousExactPatterns(
+  patterns: readonly string[],
+  models: readonly Model<Api>[],
+): void {
+  for (const pattern of patterns) {
+    if (hasGlob(pattern)) continue;
+
+    let matches = exactReferenceMatches(pattern, models);
+    if (matches.length === 0) {
+      const colonIndex = pattern.lastIndexOf(":");
+      const suffix = colonIndex >= 0 ? pattern.slice(colonIndex + 1) : "";
+      if (THINKING_LEVEL_SUFFIXES.has(suffix as ThinkingLevel)) {
+        matches = exactReferenceMatches(pattern.slice(0, colonIndex), models);
+      }
+    }
+
+    if (matches.length > 1) {
+      const references = matches
+        .map((model) => `${model.provider}/${model.id}`)
+        .sort()
+        .join(", ");
+      throw new Error(
+        `Ambiguous enabledModels entry "${pattern}" matches multiple models: ${references}. Use provider/modelId.`,
+      );
+    }
+  }
+}
+
+/**
+ * Resolve the visible model list for `patterns`.
+ *
+ * Falls back to every available model when no patterns are configured or when
+ * the patterns resolve to nothing, so a stale or typo'd setting can never leave
+ * the UI without any selectable model.
+ */
+export async function resolveVisibleModels(
+  modelRuntime: ModelRuntime,
+  patterns: string[] | undefined,
+): Promise<ModelScopeResult> {
+  const cleaned = (patterns ?? []).map((pattern) => pattern.trim()).filter(Boolean);
+  if (cleaned.length === 0) {
+    return {
+      visible: await modelRuntime.getAvailable(),
+      scopedModels: [],
+      thinkingLevelPins: {},
+      warnings: [],
+    };
+  }
+
+  const available = await modelRuntime.getAvailable();
+  assertNoAmbiguousExactPatterns(cleaned, available);
+  const snapshotRuntime = {
+    getAvailable: async () => available,
+  } as ModelRuntime;
+  const { scopedModels, diagnostics } = await resolveModelScopeWithDiagnostics(cleaned, snapshotRuntime);
+  const warnings = diagnostics.map((diagnostic) => diagnostic.message);
+  if (scopedModels.length === 0) {
+    return {
+      visible: available,
+      scopedModels: [],
+      thinkingLevelPins: {},
+      warnings,
+    };
+  }
+
+  // `anthropic/*:high` pins a thinking level on every model the glob matched.
+  // pi applies the pin of the model a new session starts with; report them all
+  // so the client can look up whichever model it pre-selects.
+  const thinkingLevelPins: Record<string, string> = {};
+  for (const scoped of scopedModels) {
+    if (scoped.thinkingLevel) {
+      thinkingLevelPins[`${scoped.model.provider}/${scoped.model.id}`] = scoped.thinkingLevel;
+    }
+  }
+  return {
+    visible: scopedModels.map((scoped) => scoped.model),
+    scopedModels,
+    thinkingLevelPins,
+    warnings,
+  };
+}
+
+/**
+ * Select the model and thinking level used to create a new AgentSession.
+ *
+ * This mirrors pi's startup rule: prefer an explicit selection, otherwise use
+ * the saved default when it is in scope, then the first resolver-ordered model.
+ * A scoped-model thinking pin is applied unless the caller supplied an explicit
+ * thinking level.
+ */
+export function selectInitialModelScope(
+  scope: ModelScopeResult,
+  options: InitialModelScopeOptions = {},
+): InitialModelScopeResult {
+  const requestedRef = options.requestedModel;
+  const defaultRef = options.defaultModel;
+  const requested = requestedRef
+    ? scope.visible.find((model) => matchesModel(model, requestedRef))
+    : undefined;
+  if (requestedRef && !requested) {
+    throw new Error(
+      `Model is not available in the enabled scope: ${requestedRef.provider}/${requestedRef.modelId}`,
+    );
+  }
+
+  const requestedScoped = requested
+    ? scope.scopedModels.find((scoped) => scoped.model === requested
+      || matchesModel(scoped.model, { provider: requested.provider, modelId: requested.id }))
+    : undefined;
+  const defaultScoped = !requested && defaultRef
+    ? scope.scopedModels.find((scoped) => matchesModel(scoped.model, defaultRef))
+    : undefined;
+  const fallbackScoped = !requested ? (defaultScoped ?? scope.scopedModels[0]) : undefined;
+  const defaultVisible = !requested && !fallbackScoped && defaultRef
+    ? scope.visible.find((model) => matchesModel(model, defaultRef))
+    : undefined;
+  const selectedModel = requested ?? fallbackScoped?.model ?? defaultVisible;
+  const scopedSelection = requestedScoped ?? fallbackScoped;
+  const thinkingLevel = options.thinkingLevel ?? scopedSelection?.thinkingLevel;
+
+  return {
+    ...(selectedModel ? { model: selectedModel } : {}),
+    ...(thinkingLevel ? { thinkingLevel } : {}),
+    scopedModels: [...scope.scopedModels],
+  };
+}

package/lib/models-cache.test.mjs

@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  invalidateModelsCache,
+  loadModelsWithCache,
+  withModelRuntimeError,
+  withSafeModelLoadFailure,
+} from "./models-cache.ts";
+
+function modelsData(id) {
+  return {
+    models: { [`provider:${id}`]: id },
+    modelList: [{ id, name: id, provider: "provider" }],
+    defaultModel: null,
+    thinkingLevels: {},
+    thinkingLevelMaps: {},
+  };
+}
+
+test("caches model data independently for each cwd", async () => {
+  invalidateModelsCache();
+  let firstLoads = 0;
+  let secondLoads = 0;
+
+  const first = await loadModelsWithCache("/first", async () => {
+    firstLoads += 1;
+    return modelsData("first");
+  });
+  await loadModelsWithCache("/second", async () => {
+    secondLoads += 1;
+    return modelsData("second");
+  });
+  const firstAgain = await loadModelsWithCache("/first", async () => {
+    firstLoads += 1;
+    return modelsData("replacement");
+  });
+
+  assert.deepEqual(firstAgain, first);
+  assert.equal(firstLoads, 1);
+  assert.equal(secondLoads, 1);
+});
+
+test("shares one loader between concurrent requests for the same cwd", async () => {
+  invalidateModelsCache();
+  let loads = 0;
+  let finishLoad;
+  const loader = () => {
+    loads += 1;
+    return new Promise((resolve) => { finishLoad = resolve; });
+  };
+
+  const first = loadModelsWithCache("/shared", loader);
+  const second = loadModelsWithCache("/shared", loader);
+  await Promise.resolve();
+
+  assert.equal(loads, 1);
+  finishLoad(modelsData("shared"));
+  assert.deepEqual(await second, await first);
+});
+
+test("does not cache a stale load that finishes after invalidation", async () => {
+  invalidateModelsCache();
+  let finishOldLoad;
+  const oldLoad = loadModelsWithCache("/stale", () => new Promise((resolve) => { finishOldLoad = resolve; }));
+  await Promise.resolve();
+
+  invalidateModelsCache();
+  let freshLoads = 0;
+  const fresh = await loadModelsWithCache("/stale", async () => {
+    freshLoads += 1;
+    return modelsData("fresh");
+  });
+  finishOldLoad(modelsData("stale"));
+  await oldLoad;
+
+  const cached = await loadModelsWithCache("/stale", async () => {
+    freshLoads += 1;
+    return modelsData("unexpected");
+  });
+  assert.deepEqual(cached, fresh);
+  assert.equal(freshLoads, 1);
+});
+
+test("retries after a model load fails", async () => {
+  invalidateModelsCache();
+  await assert.rejects(
+    loadModelsWithCache("/failed", async () => { throw new Error("load failed"); }),
+    /load failed/,
+  );
+
+  let retries = 0;
+  const fresh = await loadModelsWithCache("/failed", async () => {
+    retries += 1;
+    return modelsData("fresh");
+  });
+  assert.deepEqual(fresh, modelsData("fresh"));
+  assert.equal(retries, 1);
+});
+
+test("adds runtime errors without discarding available models", () => {
+  const data = modelsData("builtin");
+  const result = withModelRuntimeError(data, "Invalid models.json schema");
+
+  assert.deepEqual(result, {
+    ...data,
+    modelError: "Invalid models.json schema",
+  });
+});
+
+test("uses a safe error for unexpected model load failures", () => {
+  const data = {
+    ...modelsData("builtin"),
+    modelError: "Failed to load /Users/example/.pi/agent/models.json with token secret",
+  };
+  const result = withSafeModelLoadFailure(data);
+
+  assert.deepEqual(result, {
+    ...data,
+    modelError: "Model list is temporarily unavailable. Check your configuration and try again.",
+  });
+});

package/lib/models-cache.ts

@@ -0,0 +1,90 @@
+export interface ModelsData {
+  models: Record<string, string>;
+  modelList: { id: string; name: string; provider: string }[];
+  defaultModel: { provider: string; modelId: string } | null;
+  thinkingLevels: Record<string, string[]>;
+  thinkingLevelMaps: Record<string, Record<string, string | null>>;
+  /** `provider/modelId` → thinking level pinned by an `enabledModels` `:level` suffix. */
+  thinkingLevelPins: Record<string, string>;
+  modelError?: string;
+  /** Warnings from resolving the `enabledModels` scope (e.g. a pattern matched nothing). */
+  modelScopeWarnings?: string[];
+}
+
+interface ModelsCacheState {
+  entries: Map<string, { data: ModelsData; expiresAt: number }>;
+  inFlight: Map<string, Promise<ModelsData>>;
+  generation: number;
+}
+
+declare global {
+  var __piModelsCacheState: ModelsCacheState | undefined;
+}
+
+const MODELS_CACHE_TTL_MS = 60_000;
+const MAX_MODELS_CACHE_ENTRIES = 32;
+// Never interpolate the caught error here; SDK errors can contain paths and provider details.
+const SAFE_MODEL_LOAD_FAILURE_MESSAGE = "Model list is temporarily unavailable. Check your configuration and try again.";
+
+function getModelsCacheState(): ModelsCacheState {
+  if (!globalThis.__piModelsCacheState) {
+    globalThis.__piModelsCacheState = {
+      entries: new Map(),
+      inFlight: new Map(),
+      generation: 0,
+    };
+  }
+  return globalThis.__piModelsCacheState;
+}
+
+export function invalidateModelsCache(): void {
+  const state = getModelsCacheState();
+  state.generation += 1;
+  state.entries.clear();
+  state.inFlight.clear();
+}
+
+export function withModelRuntimeError(data: ModelsData, modelError: string | undefined): ModelsData {
+  return modelError ? { ...data, modelError } : data;
+}
+
+export function withSafeModelLoadFailure(data: ModelsData): ModelsData {
+  return { ...data, modelError: SAFE_MODEL_LOAD_FAILURE_MESSAGE };
+}
+
+export function loadModelsWithCache(cwd: string, loader: () => Promise<ModelsData>): Promise<ModelsData> {
+  const state = getModelsCacheState();
+  const cached = state.entries.get(cwd);
+  if (cached) {
+    if (cached.expiresAt > Date.now()) return Promise.resolve(cached.data);
+    state.entries.delete(cwd);
+  }
+
+  const existingLoad = state.inFlight.get(cwd);
+  if (existingLoad) return existingLoad;
+
+  const generation = state.generation;
+  const loadPromise: Promise<ModelsData> = Promise.resolve()
+    .then(loader)
+    .then((data) => {
+      if (state.generation === generation && state.inFlight.get(cwd) === loadPromise) {
+        const now = Date.now();
+        for (const [key, entry] of state.entries) {
+          if (entry.expiresAt <= now) state.entries.delete(key);
+        }
+        while (state.entries.size >= MAX_MODELS_CACHE_ENTRIES) {
+          const oldestKey = state.entries.keys().next().value;
+          if (oldestKey === undefined) break;
+          state.entries.delete(oldestKey);
+        }
+        state.entries.set(cwd, { data, expiresAt: now + MODELS_CACHE_TTL_MS });
+      }
+      return data;
+    })
+    .finally(() => {
+      if (state.inFlight.get(cwd) === loadPromise) state.inFlight.delete(cwd);
+    });
+
+  state.inFlight.set(cwd, loadPromise);
+  return loadPromise;
+}