@explyt/ai-agent 0.1.5 → 0.2.1

package/dist/vendor/model-probe/src/index.js

@@ -0,0 +1,983 @@
+/*
+ * model-probe@0.6.0 -- MIT License, Copyright (c) 2025 ratatulieoi, Copyright (c) 2026 real-wudaoshi.
+ * Compiled unobfuscated and unmodified by Explyt AI Agent. Full license text: THIRD-PARTY-NOTICES.md.
+ */
+
+// release/node_modules/model-probe/src/known-models.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var BUILTIN_RULES_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "rules.json");
+var programmaticRules = [];
+var cache = null;
+function registerKnownModelRules(rules) {
+  programmaticRules.push(...rules);
+  cache = null;
+}
+function reloadKnownModelRules() {
+  cache = null;
+}
+function compileRules(raw, source) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object" || typeof entry.pattern !== "string") continue;
+    try {
+      out.push({
+        regex: new RegExp(entry.pattern, typeof entry.flags === "string" ? entry.flags : "i"),
+        contextWindow: typeof entry.contextWindow === "number" ? entry.contextWindow : void 0,
+        maxTokens: typeof entry.maxTokens === "number" ? entry.maxTokens : void 0,
+        image: typeof entry.image === "boolean" ? entry.image : void 0,
+        video: typeof entry.video === "boolean" ? entry.video : void 0,
+        reasoning: typeof entry.reasoning === "boolean" ? entry.reasoning : void 0
+      });
+    } catch {
+      console.warn(`model-probe: skipping invalid rule in ${source}: ${entry.pattern}`);
+    }
+  }
+  return out;
+}
+function readRulesFile(path) {
+  try {
+    return compileRules(JSON.parse(readFileSync(path, "utf8")), path);
+  } catch {
+    return [];
+  }
+}
+function userRulesPath() {
+  return process.env.MODEL_PROBE_RULES || join(homedir(), ".model-probe-rules.json");
+}
+function loadRules() {
+  if (cache) return cache;
+  const rules = [...compileRules(programmaticRules, "registerKnownModelRules")];
+  const userPath = userRulesPath();
+  if (existsSync(userPath)) rules.push(...readRulesFile(userPath));
+  rules.push(...readRulesFile(BUILTIN_RULES_PATH));
+  cache = rules;
+  return rules;
+}
+function normalizeModelIdCandidates(modelId) {
+  const candidates = [];
+  const push = (v) => {
+    if (v && !candidates.includes(v)) candidates.push(v);
+  };
+  const raw = modelId.trim();
+  push(raw);
+  const lower = raw.toLowerCase();
+  push(lower);
+  const withoutAt = lower.split("@")[0];
+  push(withoutAt);
+  const withoutSuffix = withoutAt.replace(/\[1m\]$/i, "");
+  push(withoutSuffix);
+  push(withoutSuffix.replace(/-20\d{6}$/, ""));
+  push(withoutSuffix.replace(/-\d{2,9}$/, ""));
+  push(
+    withoutSuffix.replace(
+      /-(?:latest|recent|free|preview|stable|thinking|reasoning|turbo|hi|highspeed|dev|beta|auto|labs)$/,
+      ""
+    )
+  );
+  const lastSegment = withoutSuffix.split("/").pop() ?? "";
+  if (lastSegment && lastSegment !== withoutSuffix) {
+    push(lastSegment);
+    push(lastSegment.replace(/-20\d{6}$/, ""));
+  }
+  return candidates;
+}
+function matchKnownModelRule(modelId) {
+  const info = {};
+  let matched = false;
+  for (const candidate of normalizeModelIdCandidates(modelId)) {
+    for (const rule of loadRules()) {
+      if (!rule.regex.test(candidate)) continue;
+      matched = true;
+      if (info.contextWindow === void 0 && rule.contextWindow !== void 0) info.contextWindow = rule.contextWindow;
+      if (info.maxTokens === void 0 && rule.maxTokens !== void 0) info.maxTokens = rule.maxTokens;
+      if (info.image === void 0 && rule.image !== void 0) info.image = rule.image;
+      if (info.video === void 0 && rule.video !== void 0) info.video = rule.video;
+      if (info.reasoning === void 0 && rule.reasoning !== void 0) info.reasoning = rule.reasoning;
+    }
+    if (info.contextWindow !== void 0 && info.maxTokens !== void 0 && info.image !== void 0 && info.video !== void 0 && info.reasoning !== void 0) {
+      return info;
+    }
+  }
+  return matched ? info : void 0;
+}
+function applyKnownModelFallback(modelId, info) {
+  const known = matchKnownModelRule(modelId);
+  if (!known) return info;
+  const filled = {};
+  const inferredFields = [];
+  if (info?.contextWindow === void 0 && known.contextWindow !== void 0) {
+    filled.contextWindow = known.contextWindow;
+    inferredFields.push("contextWindow");
+  }
+  if (info?.maxTokens === void 0 && known.maxTokens !== void 0) {
+    filled.maxTokens = known.maxTokens;
+    inferredFields.push("maxTokens");
+  }
+  if (info?.image === void 0 && known.image !== void 0) {
+    filled.image = known.image;
+    inferredFields.push("image");
+  }
+  if (info?.video === void 0 && known.video !== void 0) {
+    filled.video = known.video;
+    inferredFields.push("video");
+  }
+  if (info?.reasoning === void 0 && known.reasoning !== void 0) {
+    filled.reasoning = known.reasoning;
+    inferredFields.push("reasoning");
+  }
+  if (inferredFields.length === 0) return info;
+  return { ...info ?? {}, ...filled, inferred: true, inferredFields };
+}
+
+// release/node_modules/model-probe/src/types.ts
+var FULL_PROFILE = {
+  modelInfo: true,
+  modelGroupInfo: true,
+  publicCatalog: true,
+  perModelDetails: true,
+  modelsDev: true
+};
+var PROBE_CONCURRENCY = 4;
+var PROBE_TIMEOUT_MS = 4e3;
+
+// release/node_modules/model-probe/src/url.ts
+function dedupe(values) {
+  return Array.from(new Set(values));
+}
+function buildProbeUrl(baseUrl) {
+  const withSlash = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL("models", withSlash).toString();
+}
+function getPath(obj, path) {
+  let current = obj;
+  for (const key of path.split(".")) {
+    if (!current || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function firstFiniteNumber(obj, ...paths) {
+  for (const path of paths) {
+    const value = getPath(obj, path);
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+  }
+  return void 0;
+}
+
+// release/node_modules/model-probe/src/probe.ts
+var ProbeRetryable = class extends Error {
+};
+function isLocalHost(hostname) {
+  const lower = hostname.toLowerCase();
+  return lower === "localhost" || lower.endsWith(".local") || lower.startsWith("127.") || lower.startsWith("0.0.0.0") || lower.startsWith("10.") || lower.startsWith("192.168.") || /^172\.(1[6-9]|2\d|3[01])\./.test(lower) || lower === "[::1]";
+}
+function probeBaseVariants(baseUrl) {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  try {
+    const url = new URL(trimmed);
+    let pathVariant = null;
+    if (url.pathname.endsWith("/v1")) {
+      url.pathname = url.pathname.slice(0, -3) || "/";
+      pathVariant = url.toString().replace(/\/+$/, "");
+    } else if (url.pathname === "" || url.pathname === "/") {
+      url.pathname = "/v1";
+      pathVariant = url.toString().replace(/\/+$/, "");
+    }
+    const variants = [trimmed, ...pathVariant ? [pathVariant] : []];
+    if (url.protocol === "http:" && !isLocalHost(url.hostname)) {
+      for (const v of [...variants]) {
+        const secure = new URL(v);
+        secure.protocol = "https:";
+        variants.push(secure.toString().replace(/\/+$/, ""));
+      }
+    }
+    return dedupe(variants);
+  } catch {
+  }
+  return [trimmed];
+}
+async function fetchModelsList(baseUrl, headers) {
+  const probeUrl = buildProbeUrl(baseUrl);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(probeUrl, { headers, signal: controller.signal });
+  } catch (error) {
+    if (controller.signal.aborted) {
+      throw new ProbeRetryable(`Probe timed out after ${PROBE_TIMEOUT_MS / 1e3}s: ${probeUrl}`);
+    }
+    throw new ProbeRetryable(error instanceof Error ? error.message : String(error));
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 404) {
+    throw new ProbeRetryable(`Probe failed (404 Not Found): ${probeUrl}`);
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Probe failed (${response.status} ${response.statusText})${body ? `: ${body.slice(0, 200)}` : ""}`);
+  }
+  try {
+    return await response.json();
+  } catch {
+    throw new ProbeRetryable(`Probe got a non-JSON response (a web page, not an API): ${probeUrl}`);
+  }
+}
+async function probeModels(baseUrl, apiKey) {
+  const headers = {
+    accept: "application/json",
+    "accept-encoding": "identity"
+  };
+  if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+    headers["x-goog-api-key"] = apiKey;
+  }
+  const variants = probeBaseVariants(baseUrl);
+  let json;
+  let resolvedBaseUrl = variants[0];
+  for (let i = 0; i < variants.length; i++) {
+    try {
+      json = await fetchModelsList(variants[i], headers);
+      resolvedBaseUrl = variants[i];
+      break;
+    } catch (error) {
+      if (!(error instanceof ProbeRetryable) || i === variants.length - 1) throw error;
+    }
+  }
+  const rawModels = Array.isArray(json) ? json : Array.isArray(json?.data) ? json.data : Array.isArray(json?.models) ? json.models : [];
+  const infoById = /* @__PURE__ */ new Map();
+  const ids = dedupe(
+    rawModels.map((item) => {
+      const rawId = typeof item?.id === "string" ? item.id : typeof item?.name === "string" ? item.name : "";
+      if (!rawId.trim()) return "";
+      const id = rawId.trim().replace(/^models\//, "");
+      const info = parseModelListItem(item);
+      if (info) infoById.set(id, info);
+      return id;
+    }).filter(Boolean)
+  ).sort((a, b) => a.localeCompare(b));
+  return { ids, infoById, baseUrl: resolvedBaseUrl };
+}
+var API_FALLBACK_LIMITS = {
+  "anthropic-messages": { contextWindow: 2e5, maxTokens: 32e3 },
+  "google-generative-ai": { contextWindow: 1048576, maxTokens: 65536 },
+  "openai-completions": { contextWindow: 258e3, maxTokens: 32e3 },
+  "openai-responses": { contextWindow: 258e3, maxTokens: 32e3 }
+};
+var MAX_OUTPUT_TOKEN_CAP = 32e3;
+function normalizeModelLimits(contextWindow, maxTokens) {
+  if (contextWindow <= 0 || maxTokens < contextWindow) return { contextWindow, maxTokens };
+  return {
+    contextWindow,
+    maxTokens: Math.min(MAX_OUTPUT_TOKEN_CAP, Math.max(1, Math.floor(contextWindow / 4)))
+  };
+}
+var MODEL_INFO_DEFAULTS = { image: false, video: false, reasoning: true };
+function applyModelDefaults(info) {
+  const out = { ...info ?? {} };
+  const defaulted = [...info?.defaultedFields ?? []];
+  if (out.image === void 0) {
+    out.image = MODEL_INFO_DEFAULTS.image;
+    defaulted.push("image");
+  }
+  if (out.video === void 0) {
+    out.video = MODEL_INFO_DEFAULTS.video;
+    defaulted.push("video");
+  }
+  if (out.reasoning === void 0) {
+    out.reasoning = MODEL_INFO_DEFAULTS.reasoning;
+    defaulted.push("reasoning");
+  }
+  if (defaulted.length > 0) out.defaultedFields = defaulted;
+  return out;
+}
+function probeInfoSummary(info) {
+  if (!info) return [];
+  const defaulted = new Set(info.defaultedFields ?? []);
+  const parts = [];
+  if (info.contextWindow !== void 0 && !defaulted.has("contextWindow")) parts.push("context");
+  if (info.maxTokens !== void 0 && !defaulted.has("maxTokens")) parts.push("maxTokens");
+  if (info.reasoning !== void 0 && !defaulted.has("reasoning")) parts.push("reasoning");
+  if (info.image !== void 0 && !defaulted.has("image")) parts.push("image");
+  if (info.video !== void 0 && !defaulted.has("video")) parts.push("video");
+  return parts;
+}
+function hasProbeInfo(info) {
+  if (!info) return false;
+  return probeInfoSummary(info).length > 0 || info.endpointTypes !== void 0 && info.endpointTypes.length > 0;
+}
+function describeProbeInfo(info) {
+  if (!info) return void 0;
+  const inferred = new Set(info.inferredFields ?? []);
+  const fromModelsDev = new Set(info.modelsDevFields ?? []);
+  const defaulted = new Set(info.defaultedFields ?? []);
+  const tag = (field) => inferred.has(field) ? " [local rules]" : fromModelsDev.has(field) ? " [models.dev]" : "";
+  const parts = [];
+  if (info.contextWindow !== void 0 && !defaulted.has("contextWindow")) parts.push(`ctx ${info.contextWindow}${tag("contextWindow")}`);
+  if (info.maxTokens !== void 0 && !defaulted.has("maxTokens")) parts.push(`max-out ${info.maxTokens}${tag("maxTokens")}`);
+  if (info.image === true) parts.push(`image${tag("image")}`);
+  if (info.video === true) parts.push(`video${tag("video")}`);
+  if (info.reasoning === false) parts.push(`no reasoning${tag("reasoning")}`);
+  else if (info.reasoning === true && info.alwaysThinking) parts.push(`reasoning (always on)${tag("reasoning")}`);
+  if (info.endpointTypes && info.endpointTypes.length > 0) parts.push(info.endpointTypes.join("/"));
+  return parts.length > 0 ? parts.join(" \u2022 ") : void 0;
+}
+function parseGatewayMetaFields(source, info) {
+  const meta = source?.meta;
+  if (!meta || typeof meta !== "object") return;
+  if (info.contextWindow === void 0) {
+    const contextWindow = firstFiniteNumber(meta, "context_window", "max_input_tokens");
+    if (contextWindow !== void 0) info.contextWindow = contextWindow;
+  }
+  if (info.maxTokens === void 0) {
+    const maxTokens = firstFiniteNumber(meta, "max_output_tokens", "max_tokens");
+    if (maxTokens !== void 0) info.maxTokens = maxTokens;
+  }
+  const capabilities = meta.capabilities;
+  if (capabilities && typeof capabilities === "object") {
+    if (info.image === void 0 && typeof capabilities.vision === "boolean") info.image = capabilities.vision;
+    if (info.reasoning === void 0 && typeof capabilities.reasoning === "boolean") info.reasoning = capabilities.reasoning;
+    if (info.reasoning === void 0 && typeof capabilities.thinking === "boolean") info.reasoning = capabilities.thinking;
+  }
+  if (info.image === void 0 && typeof meta.supports_vision === "boolean") info.image = meta.supports_vision;
+  if (info.reasoning === void 0 && typeof meta.supports_reasoning === "boolean") info.reasoning = meta.supports_reasoning;
+}
+function parseModelListItem(item) {
+  if (!item || typeof item !== "object") return void 0;
+  const info = {};
+  const contextWindow = firstFiniteNumber(item, "context_length", "context_window", "max_input_tokens", "inputTokenLimit");
+  if (contextWindow !== void 0) info.contextWindow = contextWindow;
+  const maxTokens = firstFiniteNumber(item, "max_output_tokens", "max_completion_tokens", "outputTokenLimit");
+  if (maxTokens !== void 0) info.maxTokens = maxTokens;
+  else if (typeof item.top_provider === "object" && item.top_provider !== null) {
+    const top = firstFiniteNumber(item.top_provider, "max_completion_tokens");
+    if (top !== void 0) info.maxTokens = top;
+  }
+  if (typeof item.reasoning === "boolean") info.reasoning = item.reasoning;
+  const modalities = Array.isArray(item.architecture?.input_modalities) ? item.architecture.input_modalities : Array.isArray(item.modalities) ? item.modalities : void 0;
+  if (modalities) {
+    info.image = modalities.includes("image");
+    info.video = modalities.includes("video");
+  }
+  if (Array.isArray(item.capabilities)) {
+    if (info.reasoning === void 0) info.reasoning = item.capabilities.includes("thinking") || item.capabilities.includes("reasoning");
+    if (info.image === void 0) info.image = item.capabilities.includes("vision");
+  }
+  if (Array.isArray(item.supported_endpoint_types)) {
+    const types = item.supported_endpoint_types.filter((t) => typeof t === "string");
+    if (types.length > 0) info.endpointTypes = types;
+  }
+  parseGatewayMetaFields(item, info);
+  return hasProbeInfo(info) ? info : void 0;
+}
+function parseOpenAIModelDetail(json) {
+  if (!json || typeof json !== "object") return void 0;
+  const info = {};
+  const contextWindow = firstFiniteNumber(json, "context_window", "inputTokenLimit");
+  if (contextWindow !== void 0) info.contextWindow = contextWindow;
+  const maxTokens = firstFiniteNumber(json, "max_output_tokens", "outputTokenLimit");
+  if (maxTokens !== void 0) info.maxTokens = maxTokens;
+  const capabilities = json.capabilities;
+  if (capabilities && typeof capabilities === "object") {
+    if (capabilities.vision && typeof capabilities.vision === "object" && typeof capabilities.vision.supported === "boolean") {
+      info.image = capabilities.vision.supported;
+    }
+    const reasoning = capabilities.reasoning;
+    if (reasoning && typeof reasoning === "object") {
+      const type = typeof reasoning.type === "string" ? reasoning.type : "";
+      if (type === "none") {
+        info.reasoning = false;
+      } else if (type === "minimal") {
+        info.reasoning = true;
+        info.alwaysThinking = true;
+      } else if (type === "effort") {
+        info.reasoning = true;
+        if (Array.isArray(reasoning.effort_options)) {
+          info.effortOptions = reasoning.effort_options.filter((option) => typeof option === "string");
+        }
+      }
+    }
+  }
+  parseGatewayMetaFields(json, info);
+  return probeInfoSummary(info).length > 0 ? info : void 0;
+}
+function parseModelGroupInfo(json, out) {
+  if (!json || typeof json !== "object") return false;
+  const entries = Array.isArray(json) ? json : Array.isArray(json.data) ? json.data : [];
+  if (entries.length === 0) return false;
+  let found = false;
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    const name = typeof entry.model_group === "string" ? entry.model_group.trim() : "";
+    if (!name) continue;
+    const parsed = {};
+    const contextWindow = firstFiniteNumber(entry, "max_input_tokens", "context_window");
+    if (contextWindow !== void 0) parsed.contextWindow = contextWindow;
+    const maxTokens = firstFiniteNumber(entry, "max_output_tokens", "max_tokens");
+    if (maxTokens !== void 0) parsed.maxTokens = maxTokens;
+    if (typeof entry.supports_vision === "boolean") parsed.image = entry.supports_vision;
+    if (typeof entry.supports_reasoning === "boolean") parsed.reasoning = entry.supports_reasoning;
+    if (probeInfoSummary(parsed).length > 0) {
+      out.set(name, parsed);
+      found = true;
+    }
+  }
+  return found;
+}
+async function enrichLiteLLMModelGroupInfo(baseUrl, apiKey) {
+  const out = /* @__PURE__ */ new Map();
+  if (!apiKey) return out;
+  const headers = { accept: "application/json", authorization: `Bearer ${apiKey}` };
+  let roots;
+  try {
+    roots = [new URL(baseUrl).origin, baseUrl];
+  } catch {
+    roots = [baseUrl];
+  }
+  for (const root of roots) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+      const response = await fetch(`${root.replace(/\/+$/, "")}/model_group/info`, {
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!response.ok) continue;
+      const json = await response.json().catch(() => null);
+      if (parseModelGroupInfo(json, out)) return out;
+    } catch {
+    }
+  }
+  return out;
+}
+function parsePublicModelList(json, out) {
+  if (!Array.isArray(json)) return false;
+  let found = false;
+  for (const entry of json) {
+    if (!entry || typeof entry !== "object") continue;
+    const name = typeof entry.litellm_model_name === "string" ? entry.litellm_model_name.trim() : typeof entry.model_name === "string" ? entry.model_name.trim() : typeof entry.id === "string" ? entry.id.trim() : "";
+    if (!name) continue;
+    if (entry.status === "draft" || entry.status === "archived" || entry.is_visible === false) continue;
+    const parsed = {};
+    const contextWindow = firstFiniteNumber(entry, "context_window", "contextWindow", "max_input_tokens");
+    if (contextWindow !== void 0) parsed.contextWindow = contextWindow;
+    const maxTokens = firstFiniteNumber(entry, "max_output_tokens", "maxTokens", "max_tokens");
+    if (maxTokens !== void 0) parsed.maxTokens = maxTokens;
+    if (typeof entry.supports_vision === "boolean") parsed.image = entry.supports_vision;
+    if (typeof entry.supports_reasoning === "boolean") parsed.reasoning = entry.supports_reasoning;
+    if (probeInfoSummary(parsed).length > 0) {
+      out.set(name, parsed);
+      found = true;
+    }
+  }
+  return found;
+}
+async function enrichPublicModelInfo(baseUrl) {
+  const out = /* @__PURE__ */ new Map();
+  const roots = /* @__PURE__ */ new Set();
+  try {
+    const url = new URL(baseUrl);
+    roots.add(url.origin);
+    roots.add(`https://${url.hostname.replace(/^api\./i, "")}`);
+  } catch {
+    roots.add(baseUrl);
+  }
+  for (const root of roots) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+      const response = await fetch(`${root.replace(/\/+$/, "")}/api/models/public`, {
+        headers: { accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!response.ok) continue;
+      const json = await response.json().catch(() => null);
+      if (parsePublicModelList(json, out)) return out;
+    } catch {
+    }
+  }
+  return out;
+}
+function parseLiteLLMModelInfo(json, out) {
+  if (!json || typeof json !== "object") return false;
+  const entries = Array.isArray(json.data) ? json.data : Array.isArray(json?.data?.data) ? json.data.data : [];
+  if (entries.length === 0) return false;
+  let found = false;
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    const name = typeof entry.model_name === "string" ? entry.model_name.trim() : "";
+    const info = entry.model_info;
+    if (!name || !info || typeof info !== "object") continue;
+    const parsed = {};
+    const contextWindow = firstFiniteNumber(info, "context_window", "max_input_tokens");
+    if (contextWindow !== void 0) parsed.contextWindow = contextWindow;
+    const maxTokens = firstFiniteNumber(info, "max_output_tokens", "max_tokens");
+    if (maxTokens !== void 0) parsed.maxTokens = maxTokens;
+    if (typeof info.supports_vision === "boolean") parsed.image = info.supports_vision;
+    if (typeof info.supports_reasoning === "boolean") parsed.reasoning = info.supports_reasoning;
+    if (probeInfoSummary(parsed).length > 0) {
+      out.set(name, parsed);
+      found = true;
+    }
+  }
+  return found;
+}
+async function enrichLiteLLMModelInfo(baseUrl, apiKey) {
+  const headers = { accept: "application/json", "accept-encoding": "identity" };
+  if (apiKey) headers.authorization = `Bearer ${apiKey}`;
+  const out = /* @__PURE__ */ new Map();
+  let roots;
+  try {
+    const origin = new URL(baseUrl).origin;
+    const trimmedBase = baseUrl.replace(/\/+$/, "");
+    roots = origin === trimmedBase ? [trimmedBase] : [origin, trimmedBase];
+  } catch {
+    roots = [baseUrl.replace(/\/+$/, "")];
+  }
+  for (const root of roots) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    let response;
+    try {
+      response = await fetch(`${root}/model/info`, { headers, signal: controller.signal });
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+    if (response?.ok) {
+      const json = await response.json().catch(() => null);
+      if (parseLiteLLMModelInfo(json, out)) return out;
+    }
+  }
+  return out;
+}
+async function enrichOpenAIModelDetails(baseUrl, apiKey, ids) {
+  const headers = { accept: "application/json", "accept-encoding": "identity" };
+  if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+    headers["x-goog-api-key"] = apiKey;
+  }
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const out = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  async function worker() {
+    while (cursor < ids.length) {
+      const id = ids[cursor++];
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+        const response = await fetch(new URL(`models/${encodeURIComponent(id)}`, base).toString(), {
+          headers,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (!response.ok) continue;
+        const json = await response.json().catch(() => null);
+        const info = parseOpenAIModelDetail(json);
+        if (info) out.set(id, info);
+      } catch {
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(PROBE_CONCURRENCY, Math.max(1, ids.length)) }, worker));
+  return out;
+}
+function ollamaNativeRoot(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    const pathname = url.pathname.replace(/\/+$/, "");
+    if (pathname.endsWith("/v1")) url.pathname = pathname.slice(0, -3) || "/";
+    return url.toString().replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+async function enrichOllamaModelDetails(baseUrl, apiKey, ids) {
+  const root = ollamaNativeRoot(baseUrl);
+  if (!root) return /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Map();
+  const headers = { accept: "application/json" };
+  if (apiKey) headers.authorization = `Bearer ${apiKey}`;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    const response = await fetch(`${root}/api/tags`, { headers, signal: controller.signal });
+    clearTimeout(timer);
+    if (response.ok) {
+      const json = await response.json().catch(() => null);
+      for (const model of Array.isArray(json?.models) ? json.models : []) {
+        const name = typeof model?.name === "string" ? model.name.trim() : "";
+        if (!name) continue;
+        const info = {};
+        if (Array.isArray(model.capabilities)) info.image = model.capabilities.includes("vision");
+        if (Object.keys(info).length > 0) out.set(name, info);
+      }
+    }
+  } catch {
+  }
+  let cursor = 0;
+  async function worker() {
+    while (cursor < ids.length) {
+      const id = ids[cursor++];
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+        const response = await fetch(`${root}/api/show`, {
+          method: "POST",
+          headers: { "content-type": "application/json", ...headers },
+          body: JSON.stringify({ name: id }),
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (!response.ok) continue;
+        const json = await response.json().catch(() => null);
+        const info = { ...out.get(id) ?? {} };
+        const modelInfo = json?.model_info;
+        if (modelInfo && typeof modelInfo === "object") {
+          for (const [key, value] of Object.entries(modelInfo)) {
+            if (key.endsWith(".context_length") && typeof value === "number" && value > 0) {
+              info.contextWindow = value;
+            }
+          }
+        }
+        if (Array.isArray(json?.capabilities)) info.image = json.capabilities.includes("vision");
+        out.set(id, info);
+      } catch {
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(PROBE_CONCURRENCY, Math.max(1, ids.length)) }, worker));
+  return out;
+}
+
+// release/node_modules/model-probe/src/developer-role.ts
+async function probeDeveloperRole(baseUrl, apiKey, modelId) {
+  const headers = {
+    accept: "application/json",
+    "content-type": "application/json"
+  };
+  if (apiKey) headers.authorization = `Bearer ${apiKey}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(`${baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: modelId,
+        messages: [
+          { role: "developer", content: "You are a helpful assistant." },
+          { role: "user", content: "Say ok." }
+        ],
+        max_tokens: 1,
+        stream: false
+      }),
+      signal: controller.signal
+    });
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.ok) return true;
+  if (response.status >= 400 && response.status < 500) {
+    const body = await response.text().catch(() => "");
+    if (/developer/i.test(body) || /role[^a-z]{0,20}(not|invalid|unsupported|unknown)/i.test(body)) return false;
+  }
+  return void 0;
+}
+
+// release/node_modules/model-probe/src/modelsdev.ts
+import { existsSync as existsSync2, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Models } from "./opencode-models.js";
+var DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com/v1",
+  groq: "https://api.groq.com/openai/v1",
+  mistral: "https://api.mistral.ai/v1",
+  xai: "https://api.x.ai/v1",
+  cerebras: "https://api.cerebras.ai/v1",
+  togetherai: "https://api.together.xyz/v1",
+  deepinfra: "https://api.deepinfra.com/v1/openai",
+  perplexity: "https://api.perplexity.ai",
+  venice: "https://api.venice.ai/api/v1",
+  aihubmix: "https://aihubmix.com/v1"
+};
+var catalogCache = null;
+var catalogPromise = null;
+var SNAPSHOT_CDN_URL = "https://cdn.jsdelivr.net/npm/@opencode-ai/models@latest/dist/snapshot.js";
+async function loadLatestSnapshot() {
+  const day = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const file = join2(tmpdir(), `model-probe-modelsdev-${day}.mjs`);
+  if (!existsSync2(file)) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS * 2);
+    try {
+      const response = await fetch(SNAPSHOT_CDN_URL, { headers: { "user-agent": "model-probe" }, signal: controller.signal });
+      if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+      const text = await response.text();
+      if (!text.includes("providers")) throw new Error("unexpected snapshot content");
+      writeFileSync(file, text);
+      for (const old of readdirSync(tmpdir())) {
+        if (old.startsWith("model-probe-modelsdev-") && old !== `model-probe-modelsdev-${day}.mjs`) {
+          try {
+            unlinkSync(join2(tmpdir(), old));
+          } catch {
+          }
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  const mod = await import(pathToFileURL(file).href);
+  const providers = mod.providers ?? mod.default?.providers;
+  if (!providers || Object.keys(providers).length === 0) throw new Error("snapshot had no providers");
+  return providers;
+}
+async function loadCatalog() {
+  if (catalogCache) return catalogCache;
+  catalogPromise ??= (async () => {
+    try {
+      const client = Models.make();
+      const map = await client.providers({ signal: AbortSignal.timeout(PROBE_TIMEOUT_MS * 2) });
+      if (!map || Object.keys(map).length === 0) throw new Error("models.dev returned no providers");
+      catalogCache = map;
+      return map;
+    } catch {
+    }
+    try {
+      catalogCache = await loadLatestSnapshot();
+      return catalogCache;
+    } catch {
+    }
+    const snapshot = await import("./opencode-models-snapshot.js");
+    catalogCache = snapshot.providers;
+    return catalogCache;
+  })();
+  return catalogPromise;
+}
+function toProviderEntry(provider) {
+  const baseUrl = provider.api?.trim() || DEFAULT_BASE_URLS[provider.id];
+  if (!baseUrl) return null;
+  return {
+    id: provider.id,
+    name: provider.name?.trim() || provider.id,
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    env: Array.isArray(provider.env) ? provider.env.filter((v) => typeof v === "string") : [],
+    doc: provider.doc
+  };
+}
+function parseModelEntry(model) {
+  const info = {};
+  if (Number.isFinite(model.limit?.context) && model.limit.context > 0) info.contextWindow = model.limit.context;
+  if (Number.isFinite(model.limit?.output) && model.limit.output > 0) info.maxTokens = model.limit.output;
+  if (info.contextWindow !== void 0 && info.maxTokens !== void 0) {
+    const limited = normalizeModelLimits(info.contextWindow, info.maxTokens);
+    info.contextWindow = limited.contextWindow;
+    info.maxTokens = limited.maxTokens;
+  }
+  if (Array.isArray(model.modalities?.input)) {
+    info.image = model.modalities.input.includes("image");
+    info.video = model.modalities.input.includes("video");
+  }
+  if (typeof model.reasoning === "boolean") info.reasoning = model.reasoning;
+  const effort = model.reasoning_options?.find((o) => o.type === "effort");
+  if (effort && effort.type === "effort") {
+    info.effortOptions = effort.values.filter((v) => typeof v === "string");
+  }
+  return Object.keys(info).length > 0 ? info : void 0;
+}
+async function fetchModelsDevProviders() {
+  const catalog = await loadCatalog();
+  const out = /* @__PURE__ */ new Map();
+  for (const provider of Object.values(catalog)) {
+    if (!provider || typeof provider !== "object") continue;
+    const entry = toProviderEntry(provider);
+    if (entry) out.set(entry.id, entry);
+  }
+  if (out.size === 0) throw new Error("models.dev catalog contained no usable providers");
+  return out;
+}
+async function fetchModelsDevModels(providerId) {
+  const catalog = await loadCatalog();
+  const out = /* @__PURE__ */ new Map();
+  const models = catalog[providerId]?.models;
+  if (models && typeof models === "object") {
+    for (const [id, model] of Object.entries(models)) {
+      const info = parseModelEntry(model);
+      if (info) out.set(id, info);
+    }
+  }
+  return out;
+}
+function sameBaseUrl(a, b) {
+  try {
+    const ua = new URL(a);
+    const ub = new URL(b);
+    if (ua.host.toLowerCase() !== ub.host.toLowerCase()) return false;
+    const strip = (p) => p.replace(/\/+$/, "").replace(/\/v1$/i, "");
+    return strip(ua.pathname) === strip(ub.pathname);
+  } catch {
+    return false;
+  }
+}
+async function fetchModelsDevInfoForBaseUrl(baseUrl) {
+  try {
+    const providers = await fetchModelsDevProviders();
+    for (const provider of providers.values()) {
+      if (sameBaseUrl(provider.baseUrl, baseUrl)) {
+        return await fetchModelsDevModels(provider.id);
+      }
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Map();
+}
+
+// release/node_modules/model-probe/src/detect.ts
+async function fetchGatewayWideInfo(baseUrl, options = {}) {
+  const out = /* @__PURE__ */ new Map();
+  if (options.ollama) return out;
+  const profile = { ...FULL_PROFILE, ...options.profile };
+  if (profile.modelInfo) {
+    for (const [id, info] of await enrichLiteLLMModelInfo(baseUrl, options.apiKey)) {
+      out.set(id, info);
+    }
+  }
+  if (profile.publicCatalog) {
+    for (const [id, info] of await enrichPublicModelInfo(baseUrl)) {
+      out.set(id, { ...out.get(id) ?? {}, ...info });
+    }
+  }
+  if (profile.modelGroupInfo) {
+    for (const [id, info] of await enrichLiteLLMModelGroupInfo(baseUrl, options.apiKey)) {
+      const existing = out.get(id);
+      if (!existing) {
+        out.set(id, info);
+        continue;
+      }
+      const filled = { ...existing };
+      if (filled.contextWindow === void 0 && info.contextWindow !== void 0) filled.contextWindow = info.contextWindow;
+      if (filled.maxTokens === void 0 && info.maxTokens !== void 0) filled.maxTokens = info.maxTokens;
+      if (filled.image === void 0 && info.image !== void 0) filled.image = info.image;
+      if (filled.video === void 0 && info.video !== void 0) filled.video = info.video;
+      if (filled.reasoning === void 0 && info.reasoning !== void 0) filled.reasoning = info.reasoning;
+      out.set(id, filled);
+    }
+  }
+  return out;
+}
+async function fetchPerModelInfo(baseUrl, ids, options = {}) {
+  if (options.ollama) return enrichOllamaModelDetails(baseUrl, options.apiKey, ids);
+  return enrichOpenAIModelDetails(baseUrl, options.apiKey, ids);
+}
+function applyModelsDevFallback(info, modelsDev) {
+  if (!modelsDev) return info;
+  const out = { ...info ?? {} };
+  const tagged = [...info?.modelsDevFields ?? []];
+  for (const field of ["contextWindow", "maxTokens", "image", "video", "reasoning"]) {
+    if (out[field] === void 0 && modelsDev[field] !== void 0) {
+      out[field] = modelsDev[field];
+      tagged.push(field);
+    }
+  }
+  if (out.effortOptions === void 0 && modelsDev.effortOptions !== void 0) out.effortOptions = modelsDev.effortOptions;
+  if (tagged.length > 0) out.modelsDevFields = tagged;
+  return out;
+}
+function applyApiFallback(info, api) {
+  const fallback = api ? API_FALLBACK_LIMITS[api] : void 0;
+  if (!fallback) return info;
+  const out = { ...info };
+  const defaulted = [...info.defaultedFields ?? []];
+  if (out.contextWindow === void 0) {
+    out.contextWindow = fallback.contextWindow;
+    defaulted.push("contextWindow");
+  }
+  if (out.maxTokens === void 0) {
+    out.maxTokens = fallback.maxTokens;
+    defaulted.push("maxTokens");
+  }
+  out.defaultedFields = defaulted;
+  return out;
+}
+function resolveModelInfo(modelId, info, modelsDev, api) {
+  return applyModelDefaults(applyApiFallback(applyKnownModelFallback(modelId, applyModelsDevFallback(info, modelsDev?.get(modelId))) ?? {}, api));
+}
+function finalizeModelInfo(ids, maps, options = {}) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const map of maps) {
+    for (const [id, info] of map) {
+      merged.set(id, { ...merged.get(id) ?? {}, ...info });
+    }
+  }
+  for (const id of ids) {
+    merged.set(id, resolveModelInfo(id, merged.get(id), options.modelsDev, options.api));
+  }
+  return merged;
+}
+async function detectModels(baseUrl, options = {}) {
+  const profile = { ...FULL_PROFILE, ...options.profile };
+  const probed = await probeModels(baseUrl, options.apiKey);
+  const gatewayWide = await fetchGatewayWideInfo(probed.baseUrl, { apiKey: options.apiKey, profile, ollama: options.ollama });
+  let details = /* @__PURE__ */ new Map();
+  if (options.ollama) {
+    details = await fetchPerModelInfo(probed.baseUrl, probed.ids, { apiKey: options.apiKey, ollama: true });
+  } else if (profile.perModelDetails && gatewayWide.size === 0) {
+    details = await fetchPerModelInfo(probed.baseUrl, probed.ids, { apiKey: options.apiKey });
+  }
+  let modelsDev = /* @__PURE__ */ new Map();
+  if (profile.modelsDev) {
+    modelsDev = await fetchModelsDevInfoForBaseUrl(probed.baseUrl);
+  }
+  const models = options.knownModelFallback === false ? finalizeModelInfo([], [probed.infoById, gatewayWide, details]) : finalizeModelInfo(probed.ids, [probed.infoById, gatewayWide, details], { modelsDev, api: options.api });
+  const result = { ...probed, models };
+  if (options.developerRole) {
+    const probedRole = probed.ids.length > 0 ? await probeDeveloperRole(probed.baseUrl, options.apiKey, probed.ids[0]) : void 0;
+    result.supportsDeveloperRole = probedRole ?? false;
+    result.developerRoleSource = probedRole === void 0 ? "default" : "detected";
+  }
+  return result;
+}
+export {
+  API_FALLBACK_LIMITS,
+  FULL_PROFILE,
+  MAX_OUTPUT_TOKEN_CAP,
+  MODEL_INFO_DEFAULTS,
+  PROBE_CONCURRENCY,
+  PROBE_TIMEOUT_MS,
+  applyKnownModelFallback,
+  applyModelDefaults,
+  describeProbeInfo,
+  detectModels,
+  enrichLiteLLMModelGroupInfo,
+  enrichLiteLLMModelInfo,
+  enrichOllamaModelDetails,
+  enrichOpenAIModelDetails,
+  enrichPublicModelInfo,
+  fetchGatewayWideInfo,
+  fetchModelsDevInfoForBaseUrl,
+  fetchModelsDevModels,
+  fetchModelsDevProviders,
+  fetchPerModelInfo,
+  finalizeModelInfo,
+  normalizeModelIdCandidates,
+  normalizeModelLimits,
+  probeDeveloperRole,
+  probeInfoSummary,
+  probeModels,
+  registerKnownModelRules,
+  reloadKnownModelRules,
+  resolveModelInfo
+};