@jeffusion/bungee-core 5.10.0 → 5.11.0

package/dist/plugins/models-dev/control.js

@@ -0,0 +1,1042 @@
+// @bun
+// plugins/models-dev/contract.ts
+var MODELS_DEV_SOURCE_URL = "https://models.dev/api.json";
+var MODELS_DEV_CATALOG_SERVICE_ID = "models-dev.catalog.v1";
+var MODELS_DEV_CATALOG_CONTRACT_VERSION = 1;
+var MODELS_DEV_CATALOG_SNAPSHOT_ID = "models-dev.catalog.snapshot.v1";
+var MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT_VERSION = 1;
+var MODELS_DEV_CATALOG_SNAPSHOT_SCHEMA = Object.freeze({
+  type: "object",
+  properties: {
+    version: { type: "number", integer: true, minimum: 1 },
+    fetchedAt: { type: "number", minimum: 0 },
+    catalog: { type: "json", maxBytes: 32 * 1024 * 1024 }
+  }
+});
+var MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT = Object.freeze({
+  id: MODELS_DEV_CATALOG_SNAPSHOT_ID,
+  version: MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT_VERSION,
+  content: MODELS_DEV_CATALOG_SNAPSHOT_SCHEMA
+});
+
+// plugins/models-dev/server/model-names.ts
+function resourceName(name) {
+  return name.replace(/^(?:projects\/[^/]+\/locations\/[^/]+\/)?publishers\/google\/models\//, "").replace(/^models\//, "");
+}
+function claudeVersion(name) {
+  return name.replace(/^(claude-(?:(?:opus|sonnet|haiku)-)?\d+)-(\d+)(?=-|$)/, "$1.$2");
+}
+function withoutDate(name) {
+  return name.replace(/-(?:\d{8}|\d{4}-\d{2}-\d{2})$/, "");
+}
+function withoutEffort(name) {
+  return name.replace(/-(?:minimal|low|medium|high|xhigh)$/, "");
+}
+function withoutPreview(name) {
+  return name.replace(/-(?:latest|preview|exp)$/, "");
+}
+function estimateNames(model) {
+  const names = new Set([model.trim().toLowerCase()]);
+  const transforms = [resourceName, claudeVersion, withoutDate, withoutEffort, withoutPreview];
+  for (const name of names) {
+    for (const transform of transforms) {
+      const candidate = transform(name);
+      if (candidate && names.size < 32)
+        names.add(candidate);
+    }
+  }
+  return [...names];
+}
+function canonicalModelName(model) {
+  return claudeVersion(resourceName(model.trim().toLowerCase()));
+}
+function modelFamily(model) {
+  let name = canonicalModelName(model);
+  for (;; ) {
+    const next = withoutPreview(withoutEffort(withoutDate(name)));
+    if (next === name)
+      return name;
+    name = next;
+  }
+}
+function modelDate(model) {
+  return model.toLowerCase().match(/-(\d{8}|\d{4}-\d{2}-\d{2})(?:-(?:minimal|low|medium|high|xhigh|latest|preview|exp))*$/)?.[1]?.replaceAll("-", "") ?? "";
+}
+function originalLab(model) {
+  const name = resourceName(model.trim().toLowerCase());
+  if (/^(?:gpt-|o\d+(?:-|$))/.test(name))
+    return "openai";
+  if (name.startsWith("claude-"))
+    return "anthropic";
+  if (name.startsWith("gemini-"))
+    return "google";
+  if (name.startsWith("grok-"))
+    return "xai";
+  return null;
+}
+
+// plugins/models-dev/server/catalog.ts
+var MAX_PROVIDERS = 4096;
+var MAX_MODELS_PER_PROVIDER = 16384;
+var MAX_MODEL_OPTION_PAGE_SIZE = 100;
+var MAX_RESOLVE_CANDIDATES = 20000;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finiteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function contextTier(cost, minimumInputTokens) {
+  if (!isRecord(cost) || !Number.isSafeInteger(minimumInputTokens) || minimumInputTokens < 0)
+    return null;
+  const input = finiteNonNegative(cost.input);
+  const output = finiteNonNegative(cost.output);
+  if (input === null || output === null)
+    return null;
+  return Object.freeze({
+    minimumInputTokens,
+    input,
+    output,
+    cacheRead: finiteNonNegative(cost.cache_read),
+    cacheWrite: finiteNonNegative(cost.cache_write)
+  });
+}
+function contextTiers(cost) {
+  if (Array.isArray(cost.tiers) && cost.tiers.length > 0) {
+    const tiers = [];
+    const thresholds = new Set;
+    for (const value of cost.tiers) {
+      const tier = isRecord(value) && isRecord(value.tier) && (value.tier.type === undefined || value.tier.type === "context") ? contextTier(value, value.tier.size) : null;
+      if (tier === null || thresholds.has(tier.minimumInputTokens)) {
+        tiers.length = 0;
+        break;
+      }
+      thresholds.add(tier.minimumInputTokens);
+      tiers.push(tier);
+    }
+    if (tiers.length > 0)
+      return Object.freeze(tiers.sort((a, b) => a.minimumInputTokens - b.minimumInputTokens));
+  }
+  const legacy = contextTier(cost.context_over_200k, 200001);
+  return Object.freeze(legacy === null ? [] : [legacy]);
+}
+function normalizePrice(cost) {
+  if (!isRecord(cost))
+    return null;
+  const input = finiteNonNegative(cost.input);
+  const output = finiteNonNegative(cost.output);
+  if (input === null || output === null)
+    return null;
+  const tiered = "tiers" in cost || "context_over_200k" in cost;
+  return Object.freeze({
+    input,
+    output,
+    cacheRead: finiteNonNegative(cost.cache_read),
+    cacheWrite: finiteNonNegative(cost.cache_write),
+    tiered,
+    contextTiers: contextTiers(cost)
+  });
+}
+function parseApiBase(api) {
+  if (typeof api !== "string" || api.length === 0 || api.length > 2048)
+    return null;
+  let parsed;
+  try {
+    parsed = new URL(api.replace(/\$\{[^}]*\}/g, "wildcard"));
+  } catch {
+    return null;
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (!host)
+    return null;
+  const pathSegments = parsed.pathname.split("/").filter(Boolean).map((segment) => segment.toLowerCase());
+  return { host, pathSegments };
+}
+function pathMatches(template, request) {
+  if (template.length > request.length)
+    return false;
+  for (let index = 0;index < template.length; index += 1) {
+    if (template[index] !== "*" && template[index] !== request[index])
+      return false;
+  }
+  return true;
+}
+function nameIndexes(models) {
+  const lowerModels = new Map;
+  const familyModels = new Map;
+  for (const model of models.values()) {
+    if (model.price === null)
+      continue;
+    for (const lower of new Set([model.id.toLowerCase(), canonicalModelName(model.id)])) {
+      lowerModels.set(lower, lowerModels.has(lower) ? null : model);
+    }
+    const family = modelFamily(model.id);
+    const current = familyModels.get(family);
+    const rank = (entry) => `${canonicalModelName(entry.id) === family ? "1" : "0"}:${modelDate(entry.id)}`;
+    if (current === undefined || rank(model) > rank(current) || rank(model) === rank(current) && model.id < current.id)
+      familyModels.set(family, model);
+  }
+  return { lowerModels, familyModels };
+}
+function buildCatalogIndex(record) {
+  if (!isRecord(record.catalog))
+    throw new Error("models-dev catalog record is invalid");
+  const providers = [];
+  const byProvider = new Map;
+  let modelCount = 0;
+  for (const [providerKey, providerValue] of Object.entries(record.catalog)) {
+    if (!isRecord(providerValue))
+      continue;
+    if (providers.length >= MAX_PROVIDERS)
+      throw new Error("models-dev catalog exceeds the provider budget");
+    const id = typeof providerValue.id === "string" && providerValue.id.trim() ? providerValue.id.trim() : providerKey.trim();
+    if (!id || id.length > 256)
+      continue;
+    const name = typeof providerValue.name === "string" && providerValue.name.trim() ? providerValue.name.trim() : id;
+    const parsedApi = parseApiBase(providerValue.api);
+    const models = new Map;
+    if (isRecord(providerValue.models)) {
+      for (const [modelKey, modelValue] of Object.entries(providerValue.models)) {
+        if (!isRecord(modelValue))
+          continue;
+        if (models.size >= MAX_MODELS_PER_PROVIDER)
+          throw new Error("models-dev catalog exceeds the model budget");
+        const modelId = typeof modelValue.id === "string" && modelValue.id.trim() ? modelValue.id.trim() : modelKey.trim();
+        if (!modelId || modelId.length > 512)
+          continue;
+        const modelName = typeof modelValue.name === "string" && modelValue.name.trim() ? modelValue.name.trim() : modelId;
+        models.set(modelId, Object.freeze({ id: modelId, name: modelName, price: normalizePrice(modelValue.cost), raw: modelValue }));
+        modelCount += 1;
+      }
+    }
+    const provider = Object.freeze({
+      id,
+      name,
+      api: typeof providerValue.api === "string" ? providerValue.api : null,
+      apiHost: parsedApi?.host ?? null,
+      apiPathSegments: parsedApi === null ? null : Object.freeze(parsedApi.pathSegments.map((segment) => segment.includes("wildcard") ? "*" : segment)),
+      models,
+      ...nameIndexes(models),
+      raw: providerValue
+    });
+    providers.push(provider);
+    if (!byProvider.has(id))
+      byProvider.set(id, provider);
+  }
+  providers.sort((left, right) => left.id.localeCompare(right.id));
+  const exactModels = new Map;
+  const lowerModels = new Map;
+  const familyModels = new Map;
+  const byApiHost = new Map;
+  for (const provider of providers) {
+    if (provider.apiHost !== null) {
+      const sameHost = byApiHost.get(provider.apiHost) ?? [];
+      sameHost.push(provider);
+      byApiHost.set(provider.apiHost, sameHost);
+    }
+    for (const model of provider.models.values()) {
+      const match = catalogModelIn(provider, model.id);
+      if (match === null)
+        continue;
+      exactModels.set(model.id, exactModels.has(model.id) ? null : match);
+      const lower = model.id.toLowerCase();
+      lowerModels.set(lower, lowerModels.has(lower) ? null : match);
+    }
+    for (const [family, model] of provider.familyModels) {
+      familyModels.set(family, familyModels.has(family) ? null : catalogModelIn(provider, model.id));
+    }
+  }
+  for (const providers of byApiHost.values())
+    Object.freeze(providers);
+  return Object.freeze({ version: record.version, fetchedAt: record.fetchedAt, providers: Object.freeze(providers), byProvider, modelCount, exactModels, lowerModels, familyModels, byApiHost });
+}
+function emptyStatus() {
+  return Object.freeze({ state: "empty", version: null, fetchedAt: null, providerCount: 0, modelCount: 0, error: null });
+}
+function statusOf(index, state, error) {
+  if (index === null)
+    return Object.freeze({ state: error === null ? "empty" : "failed", version: null, fetchedAt: null, providerCount: 0, modelCount: 0, error });
+  return Object.freeze({ state, version: index.version, fetchedAt: index.fetchedAt, providerCount: index.providers.length, modelCount: index.modelCount, error });
+}
+function resolveProviderFromUrl(index, rawUrl) {
+  if (index === null || typeof rawUrl !== "string" || rawUrl.length === 0 || rawUrl.length > 8192)
+    return null;
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return null;
+  }
+  const host = parsed.hostname.toLowerCase();
+  const segments = parsed.pathname.split("/").filter(Boolean).map((segment) => segment.toLowerCase());
+  const matches = [];
+  for (const provider of index.byApiHost.get(host) ?? []) {
+    if (provider.apiHost !== host || provider.apiPathSegments === null)
+      continue;
+    if (!pathMatches(provider.apiPathSegments, segments))
+      continue;
+    matches.push(provider.id);
+    if (matches.length > 1)
+      return null;
+  }
+  return matches.length === 1 ? Object.freeze({ provider: matches[0] }) : null;
+}
+function catalogModelIn(provider, modelId) {
+  const model = provider.models.get(modelId);
+  if (model === undefined || model.price === null)
+    return null;
+  return Object.freeze({
+    provider: provider.id,
+    model: model.id,
+    input: model.price.input,
+    output: model.price.output,
+    cacheRead: model.price.cacheRead,
+    cacheWrite: model.price.cacheWrite,
+    tiered: model.price.tiered,
+    contextTiers: model.price.contextTiers
+  });
+}
+function providerPrefix(model) {
+  const colon = model.indexOf(":");
+  const slash = model.indexOf("/");
+  const index = [colon, slash].filter((value) => value > 0).sort((left, right) => left - right)[0];
+  if (index === undefined)
+    return null;
+  const provider = model.slice(0, index);
+  const modelId = model.slice(index + 1);
+  return provider && modelId ? { provider, modelId } : null;
+}
+function resolveModelInCatalog(index, input) {
+  if (index === null || typeof input.model !== "string" || input.model.length === 0 || input.model.length > 512)
+    return null;
+  if (input.mode === "estimate")
+    return resolveEstimate(index, input);
+  const model = input.model;
+  const hintProvider = typeof input.pricingProvider === "string" && input.pricingProvider.length > 0 && input.pricingProvider.length <= 512 ? input.pricingProvider : undefined;
+  if (hintProvider !== undefined) {
+    const direct = index.byProvider.get(hintProvider);
+    if (direct !== undefined) {
+      return catalogModelIn(direct, model);
+    }
+    if (hintProvider.includes("://") || hintProvider.includes("/")) {
+      const resolved = resolveProviderFromUrl(index, hintProvider);
+      return resolved === null ? null : catalogModelIn(index.byProvider.get(resolved.provider), model);
+    }
+    return null;
+  }
+  if (input.url !== undefined && input.url.length > 0) {
+    const resolved = resolveProviderFromUrl(index, input.url);
+    if (resolved !== null)
+      return catalogModelIn(index.byProvider.get(resolved.provider), model);
+  }
+  const prefixed = providerPrefix(model);
+  if (prefixed !== null) {
+    const provider = index.byProvider.get(prefixed.provider);
+    if (provider !== undefined) {
+      const match = catalogModelIn(provider, prefixed.modelId);
+      if (match !== null)
+        return match;
+    }
+  }
+  return index.exactModels.get(model) ?? null;
+}
+function estimateIn(provider, model) {
+  const exact = catalogModelIn(provider, model);
+  if (exact !== null)
+    return exact;
+  for (const name of estimateNames(model)) {
+    const candidate = provider.lowerModels.get(name);
+    if (candidate)
+      return catalogModelIn(provider, candidate.id);
+  }
+  const family = provider.familyModels.get(modelFamily(model));
+  return family === undefined ? null : catalogModelIn(provider, family.id);
+}
+function resolveEstimate(index, input) {
+  const model = input.model.trim();
+  if (!model)
+    return null;
+  const hint = input.pricingProvider;
+  const direct = hint ? index.byProvider.get(hint) : undefined;
+  if (direct !== undefined)
+    return estimateIn(direct, model);
+  const hintIsUrl = typeof hint === "string" && (hint.includes("://") || hint.includes("/"));
+  if (hint && !hintIsUrl) {
+    const provider = index.byProvider.get(hint);
+    return provider === undefined ? null : estimateIn(provider, model);
+  }
+  const prefixed = providerPrefix(model);
+  if (prefixed !== null) {
+    const provider = index.byProvider.get(prefixed.provider.toLowerCase());
+    if (provider !== undefined)
+      return estimateIn(provider, prefixed.modelId);
+  }
+  const url = hintIsUrl ? hint : input.url;
+  if (url) {
+    const resolved = resolveProviderFromUrl(index, url);
+    if (resolved !== null) {
+      const match = estimateIn(index.byProvider.get(resolved.provider), model);
+      if (match !== null)
+        return match;
+    }
+  }
+  const exact = index.exactModels.get(model);
+  if (exact)
+    return exact;
+  const lower = index.lowerModels.get(model.toLowerCase());
+  if (lower)
+    return lower;
+  const lab = originalLab(model);
+  if (lab !== null) {
+    const provider = index.byProvider.get(lab);
+    return provider === undefined ? null : estimateIn(provider, model);
+  }
+  for (const name of estimateNames(model)) {
+    const match = index.lowerModels.get(name);
+    if (match)
+      return match;
+  }
+  return index.familyModels.get(modelFamily(model)) ?? null;
+}
+function providerSummaries(index) {
+  if (index === null)
+    return Object.freeze([]);
+  return Object.freeze(index.providers.map((provider) => Object.freeze({
+    provider: provider.id,
+    name: provider.name,
+    api: provider.api,
+    modelCount: provider.models.size
+  })));
+}
+function modelOptions(index, input = {}) {
+  const pageSize = Math.min(Math.max(1, Math.trunc(input.pageSize ?? 50)), MAX_MODEL_OPTION_PAGE_SIZE);
+  const requestedPage = Math.max(1, Math.trunc(input.page ?? 1));
+  if (index === null)
+    return Object.freeze({ models: Object.freeze([]), total: 0, page: 1, pageSize });
+  const providerFilter = input.provider;
+  const search = input.search;
+  const needle = typeof search === "string" && search.length > 0 ? search.toLocaleLowerCase() : null;
+  const providers = providerFilter === undefined ? index.providers : index.providers.filter((provider) => provider.id === providerFilter);
+  const matchesSearch = (provider, model) => needle === null || `${model.id}
+${model.name}
+${provider.id}
+${provider.name}`.toLocaleLowerCase().includes(needle);
+  let total = 0;
+  for (const provider of providers) {
+    if (needle === null)
+      total += provider.models.size;
+    else
+      for (const model of provider.models.values())
+        if (matchesSearch(provider, model))
+          total++;
+    if (total > MAX_RESOLVE_CANDIDATES)
+      throw new Error("models-dev model option scan exceeded the budget");
+  }
+  const lastPage = Math.max(1, Math.ceil(total / pageSize));
+  const page = Math.min(requestedPage, lastPage);
+  let skip = (page - 1) * pageSize;
+  const models = [];
+  for (const provider of providers) {
+    if (needle === null && skip >= provider.models.size) {
+      skip -= provider.models.size;
+      continue;
+    }
+    for (const model of provider.models.values()) {
+      if (!matchesSearch(provider, model))
+        continue;
+      if (skip > 0) {
+        skip--;
+        continue;
+      }
+      models.push({ provider: provider.id, providerName: provider.name, model: model.id, name: model.name });
+      if (models.length === pageSize)
+        break;
+    }
+    if (models.length === pageSize)
+      break;
+  }
+  return Object.freeze({ models: Object.freeze(models), total, page, pageSize });
+}
+
+// plugins/models-dev/server/download.ts
+var MAX_CATALOG_BODY_BYTES = 16 * 1024 * 1024;
+async function readBoundedBody(response, maxBytes, signal) {
+  if (signal?.aborted)
+    throw new Error("catalog download cancelled");
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    await response.body?.cancel();
+    throw new Error("catalog body limit exceeded");
+  }
+  if (response.body === null)
+    return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (;; ) {
+      if (signal?.aborted)
+        throw new Error("catalog download cancelled");
+      const part = await reader.read();
+      if (part.done)
+        break;
+      total += part.value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        throw new Error("catalog body limit exceeded");
+      }
+      chunks.push(part.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(body);
+}
+async function downloadModelsDevCatalog(input = {}) {
+  const url = input.url ?? MODELS_DEV_SOURCE_URL;
+  const maxBytes = input.maxBytes ?? MAX_CATALOG_BODY_BYTES;
+  const response = await (input.fetch ?? globalThis.fetch)(url, {
+    ...input.signal === undefined ? {} : { signal: input.signal },
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok)
+    throw new Error(`catalog download failed with status ${response.status}`);
+  const body = await readBoundedBody(response, maxBytes, input.signal);
+  if (input.signal?.aborted)
+    throw new Error("catalog download cancelled");
+  const parsed = JSON.parse(body);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("catalog payload is invalid");
+  return parsed;
+}
+
+// plugins/models-dev/server/local.ts
+import { createHash } from "crypto";
+
+// plugins/models-dev/server/store.ts
+var MODELS_DEV_SETTINGS_KEY = "catalog:settings:v2";
+var MODELS_DEV_CATALOG_KEY = "catalog:v1";
+var MODELS_DEV_STATUS_KEY = "catalog:status:v1";
+var DEFAULT_MODELS_DEV_SETTINGS = { autoRefresh: true, intervalHours: 24, timeoutSeconds: 15 };
+function parseModelsDevSettings(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("invalid_input");
+  const record = value;
+  if (Object.keys(record).some((key) => !["autoRefresh", "intervalHours", "timeoutSeconds"].includes(key)) || typeof record.autoRefresh !== "boolean" || !Number.isInteger(record.intervalHours) || record.intervalHours < 1 || record.intervalHours > 24 || !Number.isInteger(record.timeoutSeconds) || record.timeoutSeconds < 5 || record.timeoutSeconds > 120) {
+    throw new Error("invalid_input");
+  }
+  return { autoRefresh: record.autoRefresh, intervalHours: record.intervalHours, timeoutSeconds: record.timeoutSeconds };
+}
+function parsePersistedStatus(value) {
+  const empty = { lastAttemptAt: null, lastSuccessAt: null, lastError: null, consecutiveFailures: 0 };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return empty;
+  const record = value;
+  const numberOrNull = (candidate) => typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0 ? candidate : null;
+  return {
+    lastAttemptAt: numberOrNull(record.lastAttemptAt),
+    lastSuccessAt: numberOrNull(record.lastSuccessAt),
+    lastError: typeof record.lastError === "string" && record.lastError.length > 0 && record.lastError.length <= 64 ? record.lastError : null,
+    consecutiveFailures: Number.isSafeInteger(record.consecutiveFailures) && record.consecutiveFailures >= 0 ? record.consecutiveFailures : 0
+  };
+}
+async function strictRead(storage, key) {
+  if (typeof storage.readStrict === "function") {
+    const result = await storage.readStrict(key);
+    return result.found ? result.value : undefined;
+  }
+  const value = await storage.get(key);
+  return value === null ? undefined : value;
+}
+async function readModelsDevSettings(storage) {
+  const stored = await strictRead(storage, MODELS_DEV_SETTINGS_KEY);
+  if (stored === undefined)
+    return { ...DEFAULT_MODELS_DEV_SETTINGS };
+  return parseModelsDevSettings(stored);
+}
+async function writeModelsDevSettings(storage, settings) {
+  await storage.set(MODELS_DEV_SETTINGS_KEY, settings);
+}
+async function readCatalogRecord(storage) {
+  if (typeof storage.readStrict !== "function")
+    throw new Error("models-dev requires strict plugin storage reads");
+  const result = await storage.readStrict(MODELS_DEV_CATALOG_KEY);
+  if (!result.found)
+    return null;
+  return parseCatalogRecord(result.value);
+}
+function parseCatalogRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("models-dev catalog record is invalid");
+  const record = value;
+  if (!Number.isSafeInteger(record.version) || record.version < 1 || typeof record.fetchedAt !== "number" || !Number.isFinite(record.fetchedAt) || record.fetchedAt < 0 || record.catalog === null || typeof record.catalog !== "object" || Array.isArray(record.catalog)) {
+    throw new Error("models-dev catalog record is invalid");
+  }
+  return { version: record.version, fetchedAt: record.fetchedAt, catalog: record.catalog };
+}
+async function readPersistedStatus(storage) {
+  const stored = await strictRead(storage, MODELS_DEV_STATUS_KEY);
+  return stored === undefined ? parsePersistedStatus(undefined) : parsePersistedStatus(stored);
+}
+async function writePersistedStatus(storage, status) {
+  await (storage.uncached?.() ?? storage).set(MODELS_DEV_STATUS_KEY, status);
+}
+
+// plugins/models-dev/server/local.ts
+class CatalogView {
+  #index = null;
+  #state = "empty";
+  #error = null;
+  apply(index, state = "ready", error = null) {
+    this.#index = index;
+    this.#state = state;
+    this.#error = error;
+  }
+  fail(error) {
+    this.#error = error;
+    this.#state = this.#index === null ? "failed" : "stale";
+  }
+  loaded() {
+    return this.#index !== null;
+  }
+  status() {
+    return this.#index === null && this.#state === "empty" ? emptyStatus() : statusOf(this.#index, this.#state === "empty" ? "ready" : this.#state, this.#error);
+  }
+  providers() {
+    return providerSummaries(this.#index);
+  }
+  modelOptions(input) {
+    return modelOptions(this.#index, input);
+  }
+  resolveModel(input) {
+    return resolveModelInCatalog(this.#index, input);
+  }
+  resolveProvider(input) {
+    return resolveProviderFromUrl(this.#index, input.url);
+  }
+}
+function catalogServiceOf(view) {
+  return {
+    status: () => view.status(),
+    providers: () => view.providers(),
+    modelOptions: (input) => view.modelOptions(input),
+    resolveModel: (input) => view.resolveModel(input),
+    resolveProvider: (input) => view.resolveProvider(input)
+  };
+}
+function decodeCatalogSnapshot(bytes, version) {
+  const record = parseCatalogRecord(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)));
+  if (record.version !== version)
+    throw new Error("catalog_version_mismatch");
+  return record;
+}
+async function readCatalogSnapshot(source) {
+  const { size, chunkBytes, digest, version } = source.descriptor;
+  if (!Number.isSafeInteger(size) || size < 1 || size > 32 * 1024 * 1024 || !Number.isSafeInteger(chunkBytes) || chunkBytes < 1)
+    throw new Error("catalog_snapshot_size");
+  source.retain?.();
+  try {
+    const bytes = new Uint8Array(size);
+    for (let offset = 0;offset < size; offset += chunkBytes) {
+      const length = Math.min(chunkBytes, size - offset);
+      const chunk = await source.read(offset, length);
+      if (chunk.byteLength !== length)
+        throw new Error("catalog_snapshot_truncated");
+      bytes.set(chunk, offset);
+    }
+    if (`sha256:${createHash("sha256").update(bytes).digest("hex")}` !== digest)
+      throw new Error("catalog_snapshot_digest");
+    return decodeCatalogSnapshot(bytes, version);
+  } finally {
+    source.release?.();
+  }
+}
+
+// plugins/models-dev/server/control.ts
+var MAX_RESPONSE_BYTES = 256 * 1024;
+var MAX_PAGE_RESPONSE_BYTES = 4 * 1024 * 1024;
+var MAX_QUERY_BYTES = 512;
+var MAX_PAGE = 400;
+
+class ModelsDevCatalogManager {
+  storage;
+  publisher;
+  options;
+  view = new CatalogView;
+  settings = { ...DEFAULT_MODELS_DEV_SETTINGS };
+  status = { lastAttemptAt: null, lastSuccessAt: null, lastError: null, consecutiveFailures: 0 };
+  refreshing = false;
+  nextRefreshAt = null;
+  timer;
+  controller;
+  inFlight;
+  initialization;
+  stopped = false;
+  now;
+  constructor(storage, publisher, options = {}) {
+    this.storage = storage;
+    this.publisher = publisher;
+    this.options = options;
+    this.now = options.now ?? Date.now;
+  }
+  async start() {
+    await (this.initialization ??= this.restore());
+  }
+  statusSnapshot() {
+    const catalog = this.view.status();
+    return {
+      source: MODELS_DEV_SOURCE_URL,
+      state: catalog.state,
+      settings: { ...this.settings },
+      refreshing: this.refreshing,
+      lastAttemptAt: this.status.lastAttemptAt,
+      lastSuccessAt: this.status.lastSuccessAt,
+      nextRefreshAt: this.nextRefreshAt,
+      lastError: this.status.lastError,
+      consecutiveFailures: this.status.consecutiveFailures,
+      modelCount: catalog.modelCount,
+      providerCount: catalog.providerCount,
+      version: catalog.version
+    };
+  }
+  async configure(settings) {
+    await this.start();
+    if (this.stopped)
+      throw new Error("disposed");
+    const parsed = parseModelsDevSettings(settings);
+    await writeModelsDevSettings(this.storage, parsed);
+    this.settings = parsed;
+    this.schedule();
+    return this.statusSnapshot();
+  }
+  refresh() {
+    if (this.stopped)
+      return Promise.resolve();
+    if (this.inFlight)
+      return this.inFlight;
+    this.clearTimer();
+    this.nextRefreshAt = null;
+    this.refreshing = true;
+    this.status.lastAttemptAt = this.now();
+    const task = this.load().finally(() => {
+      if (this.inFlight === task)
+        this.inFlight = undefined;
+    });
+    this.inFlight = task;
+    return task;
+  }
+  async stop() {
+    this.stopped = true;
+    this.clearTimer();
+    this.controller?.abort();
+    await Promise.allSettled([this.initialization, this.inFlight].filter((task) => task !== undefined));
+  }
+  async restore() {
+    try {
+      this.settings = await readModelsDevSettings(this.storage);
+    } catch {
+      this.status.lastError = "storage";
+    }
+    try {
+      this.status = { ...this.status, ...await readPersistedStatus(this.storage) };
+    } catch {
+      this.status.lastError = "storage";
+    }
+    try {
+      let source = this.publisher.current();
+      if (source === null) {
+        const legacy = await readCatalogRecord(this.storage);
+        if (legacy !== null) {
+          buildCatalogIndex(legacy);
+          this.publisher.publish(legacy.version, new TextEncoder().encode(JSON.stringify(legacy)));
+          source = this.publisher.current();
+        }
+      }
+      const record = source === null ? null : await readCatalogSnapshot(source);
+      if (record !== null) {
+        const index = buildCatalogIndex(record);
+        this.view.apply(index, this.status.lastError === null ? "ready" : "stale", this.status.lastError);
+        this.status.lastSuccessAt = record.fetchedAt;
+      } else {
+        this.status.lastSuccessAt = null;
+      }
+    } catch {
+      this.view.fail("snapshot");
+      this.status.lastError = "snapshot";
+    }
+    if (this.stopped)
+      return;
+    this.schedule();
+  }
+  async load() {
+    const controller = new AbortController;
+    this.controller = controller;
+    let timeout;
+    let onAbort;
+    let timedOut = false;
+    let phase = "storage";
+    try {
+      try {
+        await writePersistedStatus(this.storage, this.status);
+      } catch {
+        this.status.lastError = "storage";
+      }
+      if (this.stopped)
+        return;
+      phase = "network";
+      const failure = new Promise((_resolve, reject) => {
+        onAbort = () => reject(new Error("aborted"));
+        controller.signal.addEventListener("abort", onAbort, { once: true });
+        timeout = (this.options.schedule ?? setTimeout)(() => {
+          timedOut = true;
+          controller.abort();
+        }, this.settings.timeoutSeconds * 1000);
+      });
+      const catalog = await Promise.race([
+        downloadModelsDevCatalog({ ...this.options.fetch ? { fetch: this.options.fetch } : {}, signal: controller.signal }),
+        failure
+      ]);
+      if (this.stopped)
+        return;
+      phase = "invalid_catalog";
+      const version = (this.publisher.current()?.descriptor.version ?? 0) + 1;
+      if (!Number.isSafeInteger(version))
+        throw new Error("catalog_version_overflow");
+      const fetchedAt = Math.max(this.now(), (this.status.lastSuccessAt ?? -1) + 1);
+      const record = { version, fetchedAt, catalog };
+      const index = buildCatalogIndex(record);
+      phase = "snapshot";
+      this.publisher.publish(version, new TextEncoder().encode(JSON.stringify(record)));
+      if (this.stopped)
+        return;
+      this.view.apply(index, "ready", null);
+      this.status.lastSuccessAt = fetchedAt;
+      this.status.lastError = null;
+      this.status.consecutiveFailures = 0;
+    } catch (error) {
+      if (this.stopped)
+        return;
+      this.status.lastError = timedOut ? "timeout" : phase === "invalid_catalog" ? "invalid_catalog" : phase;
+      this.status.consecutiveFailures += 1;
+      this.view.fail(this.status.lastError);
+    } finally {
+      if (timeout !== undefined)
+        (this.options.cancel ?? clearTimeout)(timeout);
+      if (onAbort)
+        controller.signal.removeEventListener("abort", onAbort);
+      if (this.controller === controller)
+        this.controller = undefined;
+      this.refreshing = false;
+      if (!this.stopped) {
+        this.schedule();
+        try {
+          await writePersistedStatus(this.storage, this.status);
+        } catch {
+          this.status.lastError = "storage";
+          this.view.fail("storage");
+        }
+      }
+    }
+  }
+  clearTimer() {
+    if (this.timer !== undefined)
+      (this.options.cancel ?? clearTimeout)(this.timer);
+    this.timer = undefined;
+  }
+  schedule() {
+    this.clearTimer();
+    this.nextRefreshAt = null;
+    if (this.stopped || this.refreshing || !this.settings.autoRefresh)
+      return;
+    const interval = this.settings.intervalHours * 60 * 60 * 1000;
+    const due = this.status.consecutiveFailures ? this.now() + Math.min(interval, 60000 * Math.min(15, 2 ** Math.min(this.status.consecutiveFailures - 1, 4))) : this.status.lastSuccessAt === null ? this.now() : Math.max(this.now(), this.status.lastSuccessAt + interval);
+    this.nextRefreshAt = due;
+    this.timer = (this.options.schedule ?? setTimeout)(() => {
+      this.refresh();
+    }, Math.max(0, due - this.now()));
+  }
+}
+function jsonResponse(value, status = 200, maxBytes = MAX_RESPONSE_BYTES) {
+  const body = JSON.stringify(value);
+  if (new TextEncoder().encode(body).byteLength > maxBytes) {
+    return new Response(JSON.stringify({ error: "response_limit" }), { status: 500, headers: { "content-type": "application/json; charset=utf-8" } });
+  }
+  return new Response(body, { status, headers: { "content-type": "application/json; charset=utf-8" } });
+}
+async function readBody(request, maxBytes) {
+  const reader = request.body?.getReader();
+  if (!reader)
+    throw new Error("invalid_input");
+  const chunks = [];
+  let size = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      size += value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel();
+        throw new Error("invalid_input");
+      }
+      chunks.push(value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+class ModelsDevControl {
+  host;
+  api;
+  rpc = [];
+  disposed = false;
+  manager;
+  store;
+  abortListener;
+  constructor(host, options) {
+    this.host = host;
+    const snapshot = host.services?.snapshot;
+    if (snapshot === undefined || typeof snapshot.store !== "function") {
+      throw new Error("models-dev requires a durable host snapshot store capability");
+    }
+    const store = snapshot.store({ id: "models-dev.catalog.v1", schemaVersion: 1, maxVersions: 3, maxBytes: 32 * 1024 * 1024 });
+    if (store === null)
+      throw new Error("models-dev requires a durable host snapshot store capability");
+    this.store = store;
+    this.manager = new ModelsDevCatalogManager(host.storage.uncached?.() ?? host.storage, {
+      publish: (version, bytes) => {
+        store.publish(version, bytes);
+      },
+      current: () => store.current()
+    }, options);
+    this.abortListener = () => {
+      this.dispose();
+    };
+    if (host.signal.aborted)
+      this.disposed = true;
+    else
+      host.signal.addEventListener("abort", this.abortListener, { once: true });
+    snapshot.provide(MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT, {
+      current: () => this.store.current(),
+      version: (version) => this.store.version(version)
+    });
+    if (host.services !== undefined) {
+      host.services.publish(MODELS_DEV_CATALOG_SERVICE_ID, MODELS_DEV_CATALOG_CONTRACT_VERSION, catalogServiceOf(this.manager.view));
+    }
+    this.api = this.buildApi();
+  }
+  assertAlive(signal) {
+    if (this.disposed || this.host.signal.aborted)
+      throw new Error("disposed");
+    if (signal?.aborted)
+      throw new Error("request_cancelled");
+  }
+  buildApi() {
+    const invoke = (handler) => async (context) => {
+      try {
+        this.assertAlive(context.requestSignal);
+        return await handler(context);
+      } catch (error) {
+        return jsonResponse({ error: error instanceof Error && error.message === "invalid_input" ? "invalid_input" : "internal_error" }, 500);
+      }
+    };
+    return [{
+      path: "/catalog/status",
+      methods: ["GET"],
+      handler: "getCatalogStatus",
+      invoke: invoke(async () => {
+        await this.manager.start();
+        return jsonResponse(this.manager.statusSnapshot());
+      })
+    }, {
+      path: "/catalog/providers",
+      methods: ["GET"],
+      handler: "getCatalogProviders",
+      invoke: invoke(async () => jsonResponse({ providers: this.manager.view.providers() }, 200, MAX_PAGE_RESPONSE_BYTES))
+    }, {
+      path: "/catalog/models",
+      methods: ["GET"],
+      handler: "getCatalogModels",
+      invoke: invoke(async (context) => {
+        const query = parseModelQuery(context.request);
+        if (query === null)
+          return jsonResponse({ error: "invalid_query" }, 400);
+        await this.manager.start();
+        return jsonResponse(this.manager.view.modelOptions(query), 200, MAX_PAGE_RESPONSE_BYTES);
+      })
+    }, {
+      path: "/catalog/settings",
+      methods: ["PUT"],
+      handler: "configureCatalog",
+      invoke: invoke(async (context) => {
+        let settings;
+        try {
+          settings = parseModelsDevSettings(await readBody(context.request, 4096));
+        } catch {
+          return jsonResponse({ error: "invalid_input" }, 400);
+        }
+        return jsonResponse(await this.manager.configure(settings));
+      })
+    }, {
+      path: "/catalog/refresh",
+      methods: ["POST"],
+      handler: "refreshCatalog",
+      invoke: invoke(async () => {
+        await this.manager.start();
+        this.manager.refresh();
+        return jsonResponse(this.manager.statusSnapshot(), 202);
+      })
+    }];
+  }
+  async start() {
+    this.assertAlive();
+    await this.manager.start();
+  }
+  async dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    const stopped = this.manager.stop();
+    this.host.signal.removeEventListener("abort", this.abortListener);
+    await stopped;
+  }
+}
+function parseModelQuery(request) {
+  const params = new URL(request.url).searchParams;
+  const encoder = new TextEncoder;
+  for (const key of ["provider", "search", "page"])
+    if (params.getAll(key).length > 1)
+      return null;
+  const provider = params.get("provider") ?? undefined;
+  const search = params.get("search") ?? undefined;
+  const rawPage = params.get("page");
+  const page = rawPage === null ? 1 : Number(rawPage);
+  if (provider !== undefined && encoder.encode(provider).byteLength > MAX_QUERY_BYTES || search !== undefined && encoder.encode(search).byteLength > MAX_QUERY_BYTES || !Number.isSafeInteger(page) || page < 1 || page > MAX_PAGE)
+    return null;
+  return { provider, search, page };
+}
+function createControl(context, options) {
+  return new ModelsDevControl(context, options);
+}
+var control_default = { createControl };
+export {
+  ModelsDevCatalogManager,
+  createControl,
+  control_default as default
+};
+
+//# debugId=0376174D0A69321964756E2164756E21