opencode-swarm 7.181.2 → 7.181.4

package/dist/cli/model-preflight-5b81adsj.js

@@ -1,170 +0,0 @@
-// @bun
-import {
-  DEFAULT_MODELS,
-  init_constants
-} from "./index-2t21pv2v.js";
-import"./index-zpsr8rpc.js";
-import"./index-a76rekgs.js";
-
-// src/services/model-preflight.ts
-init_constants();
-var PROVIDER_LIST_TIMEOUT_MS = 2000;
-function splitModelId(model) {
-  const separator = model.indexOf("/");
-  if (separator <= 0 || separator === model.length - 1)
-    return null;
-  return {
-    provider: model.slice(0, separator),
-    model: model.slice(separator + 1)
-  };
-}
-function collectConfiguredAgentModels(config) {
-  const collected = [];
-  const overriddenAgents = new Set;
-  const overrides = config?.agents ?? {};
-  for (const [agent, override] of Object.entries(overrides)) {
-    if (typeof override?.model === "string" && override.model.trim()) {
-      collected.push({
-        agent,
-        model: override.model.trim(),
-        source: "override"
-      });
-      overriddenAgents.add(agent);
-    }
-    for (const fallback of override?.fallback_models ?? []) {
-      if (typeof fallback === "string" && fallback.trim()) {
-        collected.push({
-          agent,
-          model: fallback.trim(),
-          source: "fallback"
-        });
-      }
-    }
-  }
-  for (const [agent, model] of Object.entries(DEFAULT_MODELS)) {
-    if (overriddenAgents.has(agent))
-      continue;
-    collected.push({ agent, model, source: "default" });
-  }
-  return collected;
-}
-var CATALOG_CACHE_TTL_MS = 30000;
-var catalogCacheByClient = new WeakMap;
-function invalidateProviderCatalogCache() {
-  catalogCacheByClient = new WeakMap;
-}
-async function fetchProviderCatalog(client) {
-  if (!client)
-    return null;
-  const cached = catalogCacheByClient.get(client);
-  if (cached && Date.now() - cached.fetchedAt < CATALOG_CACHE_TTL_MS) {
-    return cached.catalog;
-  }
-  let response;
-  try {
-    response = await _internals.providerList(client);
-  } catch {
-    return null;
-  }
-  const all = response?.data?.all;
-  if (!Array.isArray(all))
-    return null;
-  const catalog = new Map;
-  for (const provider of all) {
-    if (typeof provider?.id !== "string")
-      continue;
-    const models = new Set;
-    if (provider.models && typeof provider.models === "object") {
-      for (const modelKey of Object.keys(provider.models)) {
-        models.add(modelKey);
-      }
-    }
-    catalog.set(provider.id, models);
-  }
-  catalogCacheByClient.set(client, { fetchedAt: Date.now(), catalog });
-  return catalog;
-}
-function resolveAgainstCatalog(models, catalog) {
-  if (catalog === null) {
-    return {
-      catalogAvailable: false,
-      resolutions: models.map((entry) => ({
-        ...entry,
-        status: "unknown",
-        detail: "provider catalog unavailable; model resolution not checked"
-      }))
-    };
-  }
-  const resolutions = models.map((entry) => {
-    const split = splitModelId(entry.model);
-    if (!split) {
-      return {
-        ...entry,
-        status: "unknown",
-        detail: "model id has no provider prefix; resolution not checked against the catalog"
-      };
-    }
-    const providerModels = catalog.get(split.provider);
-    if (providerModels === undefined) {
-      return {
-        ...entry,
-        status: "unresolved",
-        detail: `provider "${split.provider}" is not present in the provider catalog`
-      };
-    }
-    if (!providerModels.has(split.model)) {
-      return {
-        ...entry,
-        status: "unresolved",
-        detail: `provider "${split.provider}" does not list model "${split.model}"`
-      };
-    }
-    return { ...entry, status: "ok" };
-  });
-  return { catalogAvailable: true, resolutions };
-}
-async function runModelPreflight(config, client) {
-  const models = collectConfiguredAgentModels(config);
-  const catalog = await fetchProviderCatalog(client);
-  return resolveAgainstCatalog(models, catalog);
-}
-async function checkSingleModelResolution(model, client) {
-  const catalog = await fetchProviderCatalog(client);
-  if (catalog === null)
-    return "unknown";
-  const split = splitModelId(model);
-  if (!split)
-    return "unknown";
-  const providerModels = catalog.get(split.provider);
-  if (providerModels === undefined || !providerModels.has(split.model)) {
-    return "unresolved";
-  }
-  return "ok";
-}
-var _internals = {
-  providerList: async (client) => {
-    let timer;
-    try {
-      return await Promise.race([
-        client.provider.list(),
-        new Promise((_, reject) => {
-          timer = setTimeout(() => reject(new Error("provider list timed out")), PROVIDER_LIST_TIMEOUT_MS);
-        })
-      ]);
-    } finally {
-      if (timer)
-        clearTimeout(timer);
-    }
-  }
-};
-export {
-  splitModelId,
-  runModelPreflight,
-  resolveAgainstCatalog,
-  invalidateProviderCatalogCache,
-  fetchProviderCatalog,
-  collectConfiguredAgentModels,
-  checkSingleModelResolution,
-  _internals,
-  PROVIDER_LIST_TIMEOUT_MS
-};