@buyong/pi-devin 0.1.4 → 0.1.6

package/src/pi/messages.ts

@@ -1,131 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { getCurrentSystemPrompt, getCurrentTools, type AssistantMessage, type TranscriptContext } from "@earendil-works/pi-ai";
-import { imageFromBase64, MAX_IMAGES_BYTES } from "../core/inference/images.ts";
-import { object, requiredString, type ChatMessage, type ChatTool, type ModelInfo } from "../core/types.ts";
-import { DEVIN_API } from "./models.ts";
-
-const REPLAY_PREFIX = "devin:v1:";
-const replayStrings = ["signature", "signatureType", "geminiThoughtSignature", "outputId", "thinkingId", "phase", "modelUid"] as const;
-type ReplayMetadata = Pick<ChatMessage, typeof replayStrings[number] | "thinkingRedacted">;
-
-export function encodeReplayMetadata(message: ChatMessage): string {
-  const metadata: ReplayMetadata = {};
-  for (const key of replayStrings) if (message[key] !== undefined) metadata[key] = message[key];
-  if (message.thinkingRedacted !== undefined) metadata.thinkingRedacted = message.thinkingRedacted;
-  return REPLAY_PREFIX + JSON.stringify(metadata);
-}
-function replayMetadata(value: string | undefined): ReplayMetadata | undefined {
-  if (!value?.startsWith(REPLAY_PREFIX)) return undefined;
-  let parsed: Record<string, unknown>;
-  try { parsed = object(JSON.parse(value.slice(REPLAY_PREFIX.length)), "Devin replay metadata"); }
-  catch { throw new Error("Invalid Devin response replay metadata."); }
-  const result: ReplayMetadata = {};
-  for (const key of replayStrings) {
-    if (parsed[key] !== undefined && typeof parsed[key] !== "string") throw new Error("Unexpected Devin response replay metadata format.");
-    if (typeof parsed[key] === "string") result[key] = parsed[key];
-  }
-  if (parsed.thinkingRedacted !== undefined) {
-    if (typeof parsed.thinkingRedacted !== "boolean") throw new Error("Invalid Devin redacted thinking metadata.");
-    result.thinkingRedacted = parsed.thinkingRedacted;
-  }
-  return result;
-}
-
-export function attachReplayMetadata(output: AssistantMessage, message: ChatMessage): void {
-  const signature = encodeReplayMetadata(message);
-  for (const block of output.content) {
-    if (block.type === "thinking") block.thinkingSignature = signature;
-    else if (block.type === "text") block.textSignature = signature;
-    else block.thoughtSignature = signature;
-  }
-}
-
-const SCHEMA_MAPS = new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]);
-const SCHEMA_DATA = new Set(["enum", "const", "default", "examples", "example"]);
-
-/** Devin's own tools give every schema a single `type`; its Gemini route rejects a list such as `["integer", "null"]`. */
-function toDevinToolSchema(schema: unknown): unknown {
-  if (Array.isArray(schema)) return schema.map(toDevinToolSchema);
-  if (!schema || typeof schema !== "object") return schema;
-  const result: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (SCHEMA_DATA.has(key)) result[key] = value;
-    else if (SCHEMA_MAPS.has(key) && value && typeof value === "object" && !Array.isArray(value)) {
-      result[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, toDevinToolSchema(child)]));
-    } else if (key === "type" && Array.isArray(value)) {
-      // Omitting the field still covers null; several remaining types become one branch each.
-      const types = value.filter((type) => type !== "null");
-      if (types.length === 1) result.type = types[0];
-      else if (types.length > 1 && !("anyOf" in schema)) result.anyOf = types.map((type) => ({ type }));
-      else result.type = value;
-    } else result[key] = toDevinToolSchema(value);
-  }
-  return result;
-}
-
-export function toDevinTranscript(context: TranscriptContext, model: ModelInfo): { messages: ChatMessage[]; tools: ChatTool[]; systemPrompt: string } {
-  const declarations = getCurrentTools(context.messages);
-  if (declarations.length && !model.supportsToolCalls) throw new Error("This model does not support the current Pi tool declarations.");
-  const tools = declarations.map((tool) => {
-    // Grammar sampling is optional; like Pi's providers without grammar tools, send the JSON schema instead.
-    if (tool.constrainedSampling && tool.constrainedSampling.type === "json_schema" && tool.constrainedSampling.strict === "require") {
-      throw new Error(`Devin does not support this tool's forced sampling format: ${tool.name}`);
-    }
-    return { name: tool.name, description: tool.description, jsonSchemaString: JSON.stringify(toDevinToolSchema(tool.parameters)) };
-  });
-  const failedCalls = new Set(context.messages.flatMap((message) => message.role === "assistant" && ["error", "aborted"].includes(message.stopReason)
-    ? message.content.filter((block) => block.type === "toolCall").map((block) => block.id) : []));
-  const messages: ChatMessage[] = [];
-  for (const message of context.messages) {
-    if (message.role === "system") continue;
-    if (message.role === "assistant") {
-      if (message.stopReason === "error" || message.stopReason === "aborted") continue;
-      if (message.stopReason === "pending") throw new Error("An unfinished assistant response cannot be sent as Devin history.");
-      const own = message.provider === "devin" && message.api === DEVIN_API;
-      const result: ChatMessage = { messageId: message.responseId ?? randomUUID(), source: "CHAT_MESSAGE_SOURCE_SYSTEM", prompt: "" };
-      let replay: ReplayMetadata | undefined;
-      for (const block of message.content) {
-        if (block.type === "text") result.prompt += block.text;
-        else if (block.type === "thinking") {
-          if (!block.redacted) result.thinking = (result.thinking ?? "") + block.thinking;
-          else result.thinkingRedacted = true;
-        } else {
-          result.toolCalls ??= [];
-          result.toolCalls.push({ id: requiredString(block.id, "tool call id"), name: block.namespace ? `${block.namespace}.${block.name}` : block.name,
-            argumentsJson: JSON.stringify(object(block.arguments, "tool arguments")) });
-        }
-        if (own) {
-          const metadata = replayMetadata(block.type === "text" ? block.textSignature : block.type === "thinking" ? block.thinkingSignature : block.thoughtSignature);
-          if (metadata) {
-            if (replay && JSON.stringify(replay) !== JSON.stringify(metadata)) throw new Error("Devin replay metadata differs within one response.");
-            replay = metadata;
-          }
-        }
-      }
-      Object.assign(result, replay);
-      if (own && message.providerThinkingLevel) result.modelUid = message.providerThinkingLevel;
-      if (result.thinkingRedacted) result.thinking = "";
-      messages.push(result);
-      continue;
-    }
-    if (message.role === "toolResult" && failedCalls.has(message.toolCallId)) continue;
-    const result: ChatMessage = {
-      messageId: randomUUID(), source: message.role === "toolResult" ? "CHAT_MESSAGE_SOURCE_TOOL" : "CHAT_MESSAGE_SOURCE_USER", prompt: "",
-      ...(message.role === "toolResult" ? { toolCallId: message.toolCallId, toolResultIsError: message.isError } : {}),
-    };
-    let imageBytes = 0;
-    const content = typeof message.content === "string" ? [{ type: "text" as const, text: message.content }] : message.content;
-    for (const block of content) {
-      if (block.type === "text") result.prompt += block.text;
-      else {
-        if (!model.supportsImages) throw new Error("This model does not support images in history or tool results.");
-        const converted = imageFromBase64(block.data, block.mimeType);
-        imageBytes += converted.sizeBytes;
-        if (imageBytes > MAX_IMAGES_BYTES) throw new Error(`Images in one message must total at most ${MAX_IMAGES_BYTES} bytes.`);
-        (result.images ??= []).push(converted.image);
-      }
-    }
-    messages.push(result);
-  }
-  return { messages, tools, systemPrompt: getCurrentSystemPrompt(context.messages) };
-}

package/src/pi/models.ts

@@ -1,379 +0,0 @@
-import { createHash } from "node:crypto";
-import type { Credential as HostCredential, Model, ModelsStoreEntry, RefreshModelsContext } from "@earendil-works/pi-ai";
-import { awaitWithSignal, endpoint } from "../core/protocol/transport.ts";
-import { object, type Credential, type JsonObject } from "../core/types.ts";
-import type { ModelCatalog } from "../core/models/catalog.ts";
-import {
-  EFFECTIVE_THINKING_LEVELS, modelIDForUID, projectModelVariants, resolveBackendSelection, restoreModelVariants,
-  type BackendModelSelection, type EffectiveThinkingLevel, type ModelVariant, type VariantProjection,
-} from "../core/models/variants.ts";
-
-export const DEVIN_API = "devin-connect";
-const CATALOG_VERSION = 1;
-const DEFAULT_FRESHNESS_MS = 5 * 60_000;
-/** Default sidekick when nothing is saved or the saved one is gone. The default lead is the group this UID belongs to. */
-export const FUSION_SIDEKICK_UID = "swe-2-medium";
-/** The single Fusion entry shown in `/model`. Lead and sidekick follow the global `/devin-fusion` choice. */
-export const FUSION_MODEL_ID = "fusion";
-/** The lead is a published group model ID; the sidekick is an exact variant model ID. Both come from `publicModelIDs`. */
-export interface FusionSelection { leadID: string; sidekickID: string }
-export interface FusionChoices {
-  leads: { id: string; name: string; recommended?: true }[];
-  /** `level` is the thinking level of this UID. It is passed to the sidekick child Pi as is. */
-  sidekicks: { id: string; name: string; groupName: string; level: EffectiveThinkingLevel; recommended?: true }[];
-}
-export interface DevinModel extends Model<typeof DEVIN_API> {
-  devin: {
-    version: number; scope: string; costsUnknown: true; configs: JsonObject[]; unavailable?: JsonObject[];
-    fusion?: FusionSelection;
-    /** Marked as recommended by the catalog. For a group, true when any variant is recommended. */
-    recommended?: true;
-  };
-}
-
-/** Options for projecting the model list. Defaults: group list, Fusion included, recommended filter off. */
-export interface ProjectionOptions {
-  /** Saved Fusion choice. false (sidekick child Pi) creates no Fusion entry. */
-  fusion?: FusionSelection | false;
-  /** Lists only models with a variant marked as recommended. Groups stay groups. The Fusion entry is unaffected. */
-  recommendedOnly?: boolean;
-  /** Also lists exact UIDs that a group already covers. Used only by the sidekick child Pi. */
-  listsAllExactModels?: boolean;
-}
-
-export function isFusionModelID(id: string): boolean { return id === FUSION_MODEL_ID; }
-
-/**
- * A model whose catalog entry marks 24-hour prompt cache retention as a variant attribute.
- * The request wire has no retention field, so this flag is the only basis for allowing long retention.
- */
-export function hasExtendedPromptCacheRetention(variant: ModelVariant): boolean {
-  return variant.dimensions.some((dimension) => dimension.key === "Prompt Cache Retention" && dimension.name === "24h");
-}
-
-export function catalogScope(credential: Credential): string {
-  return createHash("sha256").update(endpoint(credential.apiServerURL) + "\0" + credential.sessionToken).digest("hex");
-}
-
-function thinkingMap(mappings: Partial<Record<EffectiveThinkingLevel, string>>) {
-  return Object.fromEntries(EFFECTIVE_THINKING_LEVELS.map((level) => [level, mappings[level] ?? null]));
-}
-
-function modelDefinition(id: string, name: string, variants: ModelVariant[], mappings: Partial<Record<EffectiveThinkingLevel, string>>, credential: Credential): DevinModel {
-  const first = variants[0].model;
-  return {
-    id, name, api: DEVIN_API, provider: "devin", baseUrl: credential.apiServerURL,
-    reasoning: Object.keys(mappings).some((level) => level !== "off"), thinkingLevelMap: thinkingMap(mappings),
-    input: first.supportsImages ? ["text", "image"] : ["text"],
-    contextWindow: first.contextWindow, maxTokens: first.maxOutputTokens,
-    // Placeholder for Pi's required numeric fields. It does not mean free or a real USD price.
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    devin: { version: CATALOG_VERSION, scope: catalogScope(credential), costsUnknown: true, configs: variants.map((variant) => variant.config) },
-  };
-}
-
-type VariantGroup = VariantProjection["groups"][number];
-const byModelID = (a: ModelVariant, b: ModelVariant) => a.model.id < b.model.id ? -1 : a.model.id > b.model.id ? 1 : 0;
-const isUsable = (variant: ModelVariant) => variant.level !== undefined && !variant.unsupported;
-const publishedVariants = (group: VariantGroup) => group.variants.filter(isUsable).sort(byModelID);
-
-/**
- * Dimension labels that tell groups apart: only dimensions whose values differ among published groups of the same family name.
- * When the catalog value name is empty, 0 counts as the default and is omitted; an enabled value uses the dimension name.
- */
-function groupDistinctParts(projection: VariantProjection): Map<string, string[]> {
-  const families = new Map<string, VariantGroup[]>();
-  for (const group of projection.groups) families.set(group.name, [...(families.get(group.name) ?? []), group]);
-  const result = new Map<string, string[]>();
-  for (const groups of families.values()) {
-    const peers = groups.filter((group) => group.canPublish).length > 1 ? groups.filter((group) => group.canPublish) : groups;
-    const values = (key: string) => new Set(peers.map((group) => {
-      const dimension = group.dimensions.find((entry) => entry.key === key);
-      return dimension ? `${dimension.order}\0${dimension.name}` : "";
-    }));
-    for (const group of groups) {
-      const parts = group.dimensions.filter((dimension) => values(dimension.key).size > 1).flatMap((dimension) => {
-        if (dimension.name) return [`${dimension.key} ${dimension.name}`];
-        if (dimension.order === 0) return [];
-        const orders = new Set(peers.map((peer) => peer.dimensions.find((entry) => entry.key === dimension.key)).filter((entry) => entry && !entry.name && entry.order !== 0).map((entry) => entry!.order));
-        return [orders.size > 1 ? `${dimension.key} ${dimension.order}` : dimension.key];
-      });
-      result.set(group.id, parts);
-    }
-  }
-  return result;
-}
-
-/** Human-readable group name. Example: `Claude Opus 4.8 · Fast Mode`. */
-function groupDisplayNames(projection: VariantProjection): Map<string, string> {
-  const parts = groupDistinctParts(projection);
-  return new Map(projection.groups.map((group) => [group.id, [group.name, ...parts.get(group.id)!].join(" · ")]));
-}
-
-const slug = (text: string) => text.toLowerCase().replace(/[^a-z0-9.]+/g, "-").replace(/^-+|-+$/g, "");
-
-/** Model IDs shown in Pi lists. Groups are keyed by their internal `family:` key, variants by catalog UID. */
-export interface PublicModelIDs {
-  groups: ReadonlyMap<string, string>;
-  variants: ReadonlyMap<string, string>;
-  targets: ReadonlyMap<string, { group: VariantGroup } | { variant: ModelVariant }>;
-}
-
-const publicIDCache = new WeakMap<VariantProjection, PublicModelIDs>();
-/**
- * Pi `/model` shows IDs, not model names, so the IDs are made human-readable.
- * Published groups use `familyID[-differing dimensions]` (e.g. `claude-opus-4.8-fast-mode`); variants use the catalog UID (e.g. `swe-2-high`).
- * The same catalog always yields the same IDs regardless of display mode. On a clash, groups win and the variant gets `-exact`.
- */
-export function publicModelIDs(projection: VariantProjection): PublicModelIDs {
-  const cached = publicIDCache.get(projection);
-  if (cached) return cached;
-  const parts = groupDistinctParts(projection), taken = new Set([FUSION_MODEL_ID]);
-  const groups = new Map<string, string>(), variants = new Map<string, string>(), targets = new Map<string, { group: VariantGroup } | { variant: ModelVariant }>();
-  const claim = (base: string) => {
-    let id = base;
-    for (let suffix = 2; taken.has(id); suffix++) id = `${base}-${suffix}`;
-    taken.add(id);
-    return id;
-  };
-  for (const group of projection.groups.filter((entry) => entry.canPublish).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) {
-    const id = claim([slug(group.family), ...parts.get(group.id)!.map(slug)].filter(Boolean).join("-") || "model");
-    groups.set(group.id, id); targets.set(id, { group });
-  }
-  for (const variant of projection.variants.filter(isUsable).sort(byModelID)) {
-    const id = claim(taken.has(variant.model.id) ? `${variant.model.id}-exact` : variant.model.id);
-    variants.set(variant.model.id, id); targets.set(id, { variant });
-  }
-  const result = { groups, variants, targets };
-  publicIDCache.set(projection, result);
-  return result;
-}
-
-/**
- * Fusion candidates. The lead must call the sidekick tool and the sidekick works with Pi tools, so
- * only models that support tool calls qualify. All variants of a published group share capabilities.
- */
-export function fusionChoices(projection: VariantProjection): FusionChoices {
-  const names = groupDisplayNames(projection), ids = publicModelIDs(projection);
-  const leads = projection.groups.filter((group) => group.canPublish && publishedVariants(group)[0]?.model.supportsToolCalls)
-    .map((group) => ({ id: ids.groups.get(group.id)!, name: names.get(group.id)!,
-      ...(group.variants.some((variant) => variant.model.isRecommended) ? { recommended: true as const } : {}) }));
-  const groupOf = new Map<string, VariantGroup>();
-  for (const group of projection.groups) for (const variant of group.variants) groupOf.set(variant.model.id, group);
-  const sidekicks = projection.variants.filter((variant) => isUsable(variant) && variant.model.supportsToolCalls).sort(byModelID)
-    .map((variant) => {
-      const group = groupOf.get(variant.model.id);
-      return { id: ids.variants.get(variant.model.id)!, name: variant.model.name, groupName: group ? names.get(group.id)! : variant.model.name, level: variant.level!,
-        ...(variant.model.isRecommended ? { recommended: true as const } : {}) };
-    });
-  return { leads, sidekicks };
-}
-
-/** Saved values missing from the current list fall back to the defaults per item. Without defaults, no Fusion entry is built. */
-export function effectiveFusion(projection: VariantProjection, requested: FusionSelection | undefined): FusionSelection | undefined {
-  const { leads, sidekicks } = fusionChoices(projection), ids = publicModelIDs(projection);
-  const defaultSidekick = ids.variants.get(FUSION_SIDEKICK_UID);
-  const defaultGroup = projection.groups.find((group) => group.variants.some((variant) => variant.model.id === FUSION_SIDEKICK_UID));
-  const defaultLead = defaultGroup && ids.groups.get(defaultGroup.id);
-  // A choice saved in the legacy format (`family:…`, `uid:…`) is read as the same model's new ID.
-  const current = (id: string | undefined) => id?.startsWith("family:") ? ids.groups.get(id)
-    : id?.startsWith("uid:") ? ids.variants.get(decodeURIComponent(id.slice("uid:".length))) : id;
-  const pick = (options: readonly { id: string }[], wanted: string | undefined, fallback: string | undefined) =>
-    options.find((option) => option.id === current(wanted))?.id ?? options.find((option) => option.id === fallback)?.id;
-  const leadID = pick(leads, requested?.leadID, defaultLead), sidekickID = pick(sidekicks, requested?.sidekickID, defaultSidekick);
-  return leadID && sidekickID ? { leadID, sidekickID } : undefined;
-}
-
-/**
- * Exact UIDs covered by a published group are hidden and chosen with `/thinking`. Their catalog configs are stored on the group model.
- * `recommendedOnly` keeps only groups and uncovered exact UIDs that hold a recommended variant, so `/thinking` still picks the UID.
- * Without any recommended variant, it falls back to the default list.
- * `listsAllExactModels` is only for processes that pick exact UIDs directly, such as the sidekick child.
- */
-export function modelsFromProjection(projection: VariantProjection, credential: Credential, options: ProjectionOptions = {}): DevinModel[] {
-  const models: DevinModel[] = [], names = groupDisplayNames(projection), ids = publicModelIDs(projection);
-  const published = projection.groups.filter((group) => group.canPublish);
-  const recommendedUIDs = new Set(projection.variants.filter((variant) => isUsable(variant) && variant.model.isRecommended).map((variant) => variant.model.id));
-  // Fall back to the default projection so accounts without recommended flags never get an empty list.
-  const isRecommendedOnly = options.recommendedOnly === true && recommendedUIDs.size > 0;
-  const isListed = (uids: readonly string[]) => !isRecommendedOnly || uids.some((uid) => recommendedUIDs.has(uid));
-  for (const group of published) {
-    if (!isListed(Object.values(group.mappings))) continue;
-    const model = modelDefinition(ids.groups.get(group.id)!, names.get(group.id)!, publishedVariants(group), group.mappings, credential);
-    if (group.variants.some((variant) => variant.model.isRecommended)) model.devin.recommended = true;
-    models.push(model);
-  }
-  const covered = new Set(published.flatMap((group) => Object.values(group.mappings)));
-  const exact = projection.variants.filter((variant) => isUsable(variant) && isListed([variant.model.id])
-    && (options.listsAllExactModels === true || !covered.has(variant.model.id)));
-  const listedNames = new Set(models.map((model) => model.name));
-  for (const variant of exact) {
-    const name = listedNames.has(variant.model.name) ? `${variant.model.name} (${variant.model.id})` : variant.model.name;
-    const model = modelDefinition(ids.variants.get(variant.model.id)!, name, [variant], { [variant.level!]: variant.model.id }, credential);
-    if (variant.model.isRecommended) model.devin.recommended = true;
-    models.push(model);
-  }
-  const fusion = options.fusion;
-  const pair = fusion === false ? undefined : effectiveFusion(projection, fusion);
-  if (pair) {
-    const lead = projection.groups.find((group) => ids.groups.get(group.id) === pair.leadID)!;
-    const sidekick = projection.variants.find((variant) => ids.variants.get(variant.model.id) === pair.sidekickID)!;
-    const model = modelDefinition(FUSION_MODEL_ID, `Devin Fusion · ${names.get(lead.id)} + ${sidekick.model.name}`, publishedVariants(lead), lead.mappings, credential);
-    model.devin.fusion = pair;
-    models.push(model);
-  }
-  models.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-  if (models.length) models[0].devin.unavailable = projection.variants.filter((variant) => variant.unsupported)
-    .sort((a, b) => a.model.id < b.model.id ? -1 : a.model.id > b.model.id ? 1 : 0).map((variant) => variant.config);
-  return models;
-}
-
-function restoredProjection(stored: Readonly<ModelsStoreEntry> | undefined, credential: Credential): VariantProjection | undefined {
-  if (!stored?.models.length) return undefined;
-  const scope = catalogScope(credential), configs = new Map<string, JsonObject>();
-  for (const model of stored.models) {
-    const metadata = object((model as DevinModel).devin, "cached Devin metadata");
-    if ((model.type !== undefined && model.type !== "chat") || model.provider !== "devin" || model.api !== DEVIN_API || model.baseUrl !== credential.apiServerURL
-      || metadata.version !== CATALOG_VERSION || metadata.scope !== scope) return undefined;
-    if (!Array.isArray(metadata.configs)) return undefined;
-    const entries = [...metadata.configs, ...(Array.isArray(metadata.unavailable) ? metadata.unavailable : [])];
-    for (const value of entries) {
-      const config = object(value, "cached model config");
-      if (typeof config.modelUid !== "string") return undefined;
-      const previous = configs.get(config.modelUid);
-      if (previous && JSON.stringify(previous) !== JSON.stringify(config)) return undefined;
-      configs.set(config.modelUid, config);
-    }
-  }
-  return restoreModelVariants([...configs.values()]);
-}
-
-export interface DevinModelSource {
-  getModels(): readonly DevinModel[];
-  filterModels(models: readonly Model<typeof DEVIN_API>[], credential: HostCredential | undefined): readonly Model<typeof DEVIN_API>[];
-  refreshModels(context: RefreshModelsContext): Promise<void>;
-  resolve(modelID: string, level: EffectiveThinkingLevel, credential: Credential): BackendModelSelection;
-  /** Resolves a catalog UID chosen by a payload hook at that variant's thinking level, including UIDs hidden from the list. */
-  resolveUID(uid: string, credential: Credential): BackendModelSelection;
-  getUnsupported(): readonly { uid: string; reason: string }[];
-  /** Thinking level of a usable exact UID in the current catalog, including hidden ones. */
-  exactLevel(uid: string): EffectiveThinkingLevel | undefined;
-  /** Fusion candidates of the current catalog. undefined without a catalog or when the source has Fusion disabled. */
-  getFusionChoices(): FusionChoices | undefined;
-  /** Rebuilds the model list from the current catalog without network after a saved choice or setting changes. */
-  rebuildModels(): void;
-  invalidate(): void;
-}
-
-export function createDevinModelSource(options: {
-  credentialFromHost: (credential: HostCredential | undefined) => Credential | undefined;
-  fetchCatalog: (credential: Credential, signal: AbortSignal) => Promise<ModelCatalog>;
-  now?: () => number;
-  freshnessMs?: number;
-  /** Reads the saved Fusion choice. false creates no Fusion entry. */
-  fusion?: false | (() => FusionSelection | undefined);
-  /** Reads the saved recommended filter setting. */
-  recommendedOnly?: () => boolean;
-  /** Also lists exact UIDs that a group already covers. Used only by the sidekick child Pi. */
-  listsAllExactModels?: boolean;
-}): DevinModelSource {
-  const now = options.now ?? Date.now, freshnessMs = options.freshnessMs ?? DEFAULT_FRESHNESS_MS;
-  if (!Number.isSafeInteger(freshnessMs) || freshnessMs < 0) throw new Error("The model cache check interval must be an integer of 0 or more.");
-  const readFusion = options.fusion;
-  // The stored list is shared by every Pi process that uses the lead's agent directory. Only the default list is stored,
-  // without display filters or the sidekick-only exact list. It still holds every catalog config, so each process rebuilds its own list after restore.
-  const build = (next: VariantProjection, credential: Credential, isForStorage = false) => modelsFromProjection(next, credential, {
-    fusion: readFusion === false ? false : readFusion?.(),
-    recommendedOnly: !isForStorage && options.recommendedOnly?.() === true,
-    listsAllExactModels: !isForStorage && options.listsAllExactModels === true,
-  });
-  let models: DevinModel[] = [], projection: VariantProjection | undefined, scope: string | undefined;
-  let checkedAtMs = 0, endpointOverride: string | undefined, modelCredential: Credential | undefined;
-  const clear = () => { models = []; projection = undefined; scope = undefined; checkedAtMs = 0; modelCredential = undefined; };
-  const currentProjection = (credential: Credential) => {
-    if (!projection || scope !== catalogScope(credential)) throw new Error("No Devin model list matches the current account and endpoint. Refresh the model list.");
-    return projection;
-  };
-  const effectiveCredential = (credential: HostCredential | undefined, baseUrl?: string) => {
-    const resolved = options.credentialFromHost(credential);
-    return resolved ? { ...resolved, apiServerURL: endpoint(baseUrl ?? resolved.apiServerURL) } : undefined;
-  };
-  return {
-    getModels: () => models,
-    getUnsupported: () => projection?.unsupported ?? [],
-    exactLevel: (uid) => projection?.variants.find((variant) => variant.model.id === uid && isUsable(variant))?.level,
-    getFusionChoices: () => projection && readFusion !== false ? fusionChoices(projection) : undefined,
-    rebuildModels() {
-      if (projection && modelCredential) models = build(projection, modelCredential);
-    },
-    invalidate: clear,
-    filterModels(candidates, credential) {
-      try {
-        const resolved = effectiveCredential(credential, endpointOverride);
-        if (!resolved) return [];
-        const expected = catalogScope(resolved);
-        return candidates.filter((model) => model.provider === "devin" && model.api === DEVIN_API && model.baseUrl === resolved.apiServerURL && (model as DevinModel).devin?.scope === expected);
-      } catch { return []; }
-    },
-    resolve(modelID, level, credential) {
-      const current = currentProjection(credential);
-      let wanted = modelID;
-      if (isFusionModelID(modelID)) {
-        // Fusion lead requests use the same UID and thinking level as the selected lead group.
-        const fusion = models.find((model) => model.id === modelID)?.devin.fusion;
-        if (!fusion) throw new Error(`Fusion model unavailable: ${modelID}`);
-        wanted = fusion.leadID;
-      }
-      const target = publicModelIDs(current).targets.get(wanted);
-      if (!target) throw new Error(`Model or thinking level unavailable: ${modelID} (${level})`);
-      return resolveBackendSelection(current, "group" in target ? target.group.id : modelIDForUID(target.variant.model.id), level);
-    },
-    resolveUID(uid, credential) {
-      const current = currentProjection(credential);
-      const level = current.variants.find((variant) => variant.model.id === uid && isUsable(variant))?.level;
-      if (!level) throw new Error(`Model UID unavailable: ${uid}`);
-      return resolveBackendSelection(current, modelIDForUID(uid), level);
-    },
-    async refreshModels(context) {
-      context.signal.throwIfAborted();
-      const credential = effectiveCredential(context.credential, context.baseUrl);
-      if (!credential) {
-        await context.publish({ update: clear });
-        return;
-      }
-      const expectedScope = catalogScope(credential);
-      let restored: VariantProjection | undefined;
-      try { restored = restoredProjection(context.stored, credential); }
-      catch { /* A bad cache is never used as run data. The current good state is kept. */ }
-      if (restored && (scope !== expectedScope || !projection || (context.stored?.checkedAt ?? 0) > checkedAtMs)) {
-        const restoredModels = build(restored, credential);
-        const checkedAt = context.stored?.checkedAt;
-        const restoredAtMs = typeof checkedAt === "number" && Number.isFinite(checkedAt) && checkedAt >= 0 && checkedAt <= now() ? checkedAt : 0;
-        const accepted = await context.publish({ update: () => {
-          projection = restored; models = restoredModels; scope = expectedScope; modelCredential = credential;
-          checkedAtMs = restoredAtMs; endpointOverride = context.baseUrl;
-        } });
-        if (!accepted) return;
-      } else if (scope !== expectedScope || endpointOverride !== context.baseUrl) {
-        const accepted = await context.publish({ update: () => { clear(); endpointOverride = context.baseUrl; } });
-        if (!accepted) return;
-      }
-      if (!context.allowNetwork) return;
-      const ageMs = now() - checkedAtMs;
-      if (!context.force && scope === expectedScope && projection && checkedAtMs > 0 && ageMs >= 0 && ageMs < freshnessMs) return;
-      const catalog = await awaitWithSignal(options.fetchCatalog(credential, context.signal), context.signal);
-      context.signal.throwIfAborted();
-      const nextProjection = projectModelVariants(catalog);
-      const nextModels = build(nextProjection, credential);
-      const checkedAt = now();
-      if (!Number.isSafeInteger(checkedAt) || checkedAt < 0) throw new Error("Invalid model cache check time.");
-      await context.publish({
-        persist: { models: build(nextProjection, credential, true), checkedAt },
-        update: () => {
-          projection = nextProjection; models = nextModels; scope = expectedScope; modelCredential = credential;
-          checkedAtMs = checkedAt; endpointOverride = context.baseUrl;
-        },
-      });
-    },
-  };
-}