omnius 1.0.591 → 1.0.592

package/dist/library.js

@@ -0,0 +1,950 @@
+import { createRequire as __omnius_createRequire } from "node:module"; import { fileURLToPath as __omnius_fileURLToPath } from "node:url"; import { dirname as __omnius_dirname } from "node:path"; const require = __omnius_createRequire(import.meta.url); const __filename = __omnius_fileURLToPath(import.meta.url); const __dirname = __omnius_dirname(__filename);
+
+// packages/cli/src/discovery.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var DISCOVERY_SCHEMA_VERSION = "1.0.0";
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 200;
+function discoveryCandidates() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const configured = process.env["OMNIUS_DOCS_ROOT"]?.trim();
+  const candidates = [
+    configured ? configured.endsWith(".json") ? resolve(configured) : resolve(configured, "DISCOVERY.json") : "",
+    // Published package: dist/index.js or dist/library.js -> ../docs.
+    resolve(here, "..", "docs", "DISCOVERY.json"),
+    // Workspace source/dist layouts.
+    resolve(here, "..", "..", "..", "docs", "DISCOVERY.json"),
+    resolve(here, "..", "..", "..", "..", "docs", "DISCOVERY.json"),
+    resolve(process.cwd(), "docs", "DISCOVERY.json")
+  ];
+  return [...new Set(candidates.filter(Boolean))];
+}
+function findDiscoveryCatalogPath() {
+  for (const candidate of discoveryCandidates()) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function isDiscoveryEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const item = value;
+  return typeof item["id"] === "string" && typeof item["kind"] === "string" && typeof item["title"] === "string" && typeof item["summary"] === "string";
+}
+function loadDiscoveryCatalog() {
+  const path = findDiscoveryCatalogPath();
+  if (!path) {
+    throw new Error(
+      "Omnius discovery catalog is unavailable. Reinstall the package or set OMNIUS_DOCS_ROOT to the bundled docs directory."
+    );
+  }
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (typeof parsed.schema_version !== "string" || !Array.isArray(parsed.entries) || !parsed.entries.every(isDiscoveryEntry)) {
+    throw new Error(`Invalid Omnius discovery catalog: ${path}`);
+  }
+  return {
+    ...parsed,
+    schema_version: parsed.schema_version,
+    entries: [...parsed.entries].sort((a, b) => a.id.localeCompare(b.id))
+  };
+}
+function normalized(value) {
+  return value.normalize("NFKC").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function tokens(value) {
+  return [...new Set(normalized(value).split(/\s+/).filter(Boolean))];
+}
+function scoreEntry(entry, query) {
+  const q = normalized(query);
+  if (!q) return 1;
+  const queryTokens = tokens(q);
+  const id = normalized(entry.id);
+  const title = normalized(entry.title);
+  const aliases = (entry.aliases ?? []).map(normalized);
+  const keywords = (entry.keywords ?? []).map(normalized);
+  const summary = normalized(entry.summary);
+  const referenced = normalized(
+    [
+      ...(entry.interfaces ?? []).map((item) => `${item.type} ${item.target} ${item.description ?? ""}`),
+      ...(entry.references ?? []).map((item) => `${item.type} ${item.target} ${item.relation ?? ""}`)
+    ].join(" ")
+  );
+  let score = 0;
+  if (id === q) score += 1e3;
+  if (aliases.includes(q)) score += 800;
+  if (title === q) score += 700;
+  if (id.startsWith(q) || title.startsWith(q)) score += 300;
+  let matchedTokens = 0;
+  for (const token of queryTokens) {
+    let matched = false;
+    if (tokens(`${id} ${title}`).includes(token)) {
+      score += 40;
+      matched = true;
+    }
+    if (aliases.some((value) => tokens(value).includes(token))) {
+      score += 25;
+      matched = true;
+    }
+    if (keywords.some((value) => tokens(value).includes(token))) {
+      score += 25;
+      matched = true;
+    }
+    if (tokens(summary).includes(token)) {
+      score += 10;
+      matched = true;
+    }
+    if (tokens(referenced).includes(token)) {
+      score += 3;
+      matched = true;
+    }
+    if (matched) matchedTokens++;
+  }
+  if (queryTokens.length > 0 && matchedTokens === queryTokens.length) score += 50;
+  return score;
+}
+function discoverCapabilities(query = "", options = {}, catalog = loadDiscoveryCatalog()) {
+  const limit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(options.limit ?? DEFAULT_LIMIT)));
+  const offset = Math.max(0, Math.floor(options.offset ?? 0));
+  return rankCapabilities(query, options.kind, catalog).slice(offset, offset + limit);
+}
+function rankCapabilities(query = "", kind, catalog = loadDiscoveryCatalog()) {
+  return catalog.entries.filter((entry) => !kind || entry.kind === kind).map((entry) => ({ score: scoreEntry(entry, query), entry })).filter((result) => !query.trim() || result.score > 0).sort((a, b) => b.score - a.score || a.entry.id.localeCompare(b.entry.id));
+}
+function showCapability(id, catalog = loadDiscoveryCatalog()) {
+  const exact = catalog.entries.find((entry) => entry.id === id);
+  if (exact) return exact;
+  const wanted = normalized(id);
+  return catalog.entries.find(
+    (entry) => normalized(entry.id) === wanted || normalized(entry.title) === wanted || (entry.aliases ?? []).some((alias) => normalized(alias) === wanted)
+  );
+}
+function discoverySchemaVersion() {
+  return DISCOVERY_SCHEMA_VERSION;
+}
+function discoveryDocsRoot() {
+  const catalog = findDiscoveryCatalogPath();
+  return catalog ? dirname(catalog) : null;
+}
+
+// packages/cli/src/service-version.ts
+var OmniusVersionError = class extends Error {
+  code;
+  installedVersion;
+  minimumVersion;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "OmniusVersionError";
+    this.code = code;
+    this.installedVersion = details.installedVersion;
+    this.minimumVersion = details.minimumVersion;
+  }
+};
+var VERSION_GATED_EXECUTION_PATHS = /* @__PURE__ */ new Set([
+  "/v1/run",
+  "/v1/chat",
+  "/api/chat",
+  "/v1/chat/completions",
+  "/v1/generate",
+  "/api/generate"
+]);
+function isVersionGatedExecutionRequest(method, pathname) {
+  if (method !== "POST") return false;
+  return VERSION_GATED_EXECUTION_PATHS.has(pathname) || /^\/v1\/tools\/[^/]+\/call$/.test(pathname) || /^\/v1\/commands\/.+/.test(pathname);
+}
+function parseOmniusVersion(value) {
+  const match = value.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function compareIdentifier(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : null;
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : null;
+  if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber;
+  if (leftNumber !== null) return -1;
+  if (rightNumber !== null) return 1;
+  return left.localeCompare(right);
+}
+function compareOmniusVersions(left, right) {
+  const a = parseOmniusVersion(left);
+  const b = parseOmniusVersion(right);
+  if (!a || !b) {
+    throw new OmniusVersionError("invalid_version", `Invalid semantic version: ${!a ? left : right}`);
+  }
+  for (const field of ["major", "minor", "patch"]) {
+    if (a[field] !== b[field]) return a[field] - b[field];
+  }
+  if (a.prerelease.length === 0 && b.prerelease.length > 0) return 1;
+  if (a.prerelease.length > 0 && b.prerelease.length === 0) return -1;
+  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index++) {
+    const av = a.prerelease[index];
+    const bv = b.prerelease[index];
+    if (av === void 0) return -1;
+    if (bv === void 0) return 1;
+    const compared = compareIdentifier(av, bv);
+    if (compared !== 0) return compared;
+  }
+  return 0;
+}
+function assertServiceVersion(info, minimumVersion) {
+  const installed = info.package_version || info.version;
+  if (compareOmniusVersions(installed, minimumVersion) < 0) {
+    throw new OmniusVersionError(
+      "stale_runtime",
+      `Omnius ${installed} is older than required version ${minimumVersion}`,
+      { installedVersion: installed, minimumVersion }
+    );
+  }
+}
+async function getServiceVersion(baseUrl, options = {}) {
+  const url = new URL("/version", baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+  const response = await fetch(url, {
+    headers: options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : void 0,
+    signal: options.signal
+  });
+  if (!response.ok) {
+    throw new OmniusVersionError(
+      "invalid_response",
+      `Omnius version request failed with HTTP ${response.status}`
+    );
+  }
+  const value = await response.json();
+  const version = typeof value["package_version"] === "string" ? value["package_version"] : typeof value["version"] === "string" ? value["version"] : "";
+  if (!parseOmniusVersion(version)) {
+    throw new OmniusVersionError("invalid_response", "Omnius /version returned no valid package version");
+  }
+  return {
+    version: typeof value["version"] === "string" ? value["version"] : version,
+    package_version: version,
+    boot_version: typeof value["boot_version"] === "string" ? value["boot_version"] : void 0,
+    boot_package_hash: typeof value["boot_package_hash"] === "string" || value["boot_package_hash"] === null ? value["boot_package_hash"] : void 0,
+    api_version: typeof value["api_version"] === "string" ? value["api_version"] : void 0,
+    discovery_schema_version: typeof value["discovery_schema_version"] === "string" ? value["discovery_schema_version"] : void 0,
+    node: typeof value["node"] === "string" ? value["node"] : void 0,
+    platform: typeof value["platform"] === "string" ? value["platform"] : void 0
+  };
+}
+
+// packages/backend-vllm/dist/providerRegistry.js
+var CHAT_CAPABILITIES = [
+  "chat",
+  "streaming",
+  "models",
+  "tools",
+  "structured-output"
+];
+var OPENAI_CAPABILITIES = [
+  ...CHAT_CAPABILITIES,
+  "embeddings"
+];
+var noAuth = (required = false) => ({
+  strategy: "none",
+  required
+});
+var bearerAuth = (required, keyPrefix, staticHeaders) => ({
+  strategy: "bearer",
+  required,
+  ...keyPrefix ? { keyPrefix } : {},
+  ...staticHeaders ? { staticHeaders } : {}
+});
+var descriptor = (value) => Object.freeze({
+  ...value,
+  aliases: Object.freeze([...value.aliases]),
+  paths: Object.freeze({ ...value.paths }),
+  auth: Object.freeze({
+    ...value.auth,
+    ...value.auth.staticHeaders ? { staticHeaders: Object.freeze({ ...value.auth.staticHeaders }) } : {}
+  }),
+  capabilities: Object.freeze([...value.capabilities])
+});
+var registrations = [
+  {
+    descriptor: descriptor({
+      id: "anthropic",
+      aliases: ["claude"],
+      label: "Anthropic (Claude)",
+      protocol: "anthropic-messages",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/messages",
+        models: "/v1/models"
+      },
+      auth: {
+        strategy: "anthropic-api-key",
+        required: true,
+        keyPrefix: "sk-ant-",
+        staticHeaders: { "anthropic-version": "2023-06-01" }
+      },
+      capabilities: CHAT_CAPABILITIES,
+      defaultUrl: "https://api.anthropic.com/v1",
+      apiKeyUrl: "https://console.anthropic.com/settings/keys",
+      docsUrl: "https://docs.anthropic.com/en/api",
+      description: "Claude through Anthropic's native Messages API."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.anthropic.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "gemini",
+      aliases: ["google", "google-ai"],
+      label: "Google Gemini",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1beta/openai",
+      paths: {
+        chat: "/v1beta/openai/chat/completions",
+        models: "/v1beta/openai/models",
+        embeddings: "/v1beta/openai/embeddings"
+      },
+      auth: bearerAuth(true, void 0, {
+        "x-goog-api-client": "omnius/{version}"
+      }),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+      apiKeyUrl: "https://aistudio.google.com/app/apikey",
+      docsUrl: "https://ai.google.dev/gemini-api/docs/openai",
+      description: "Gemini through Google's official OpenAI-compatible API."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "generativelanguage.googleapis.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "openai",
+      aliases: [],
+      label: "OpenAI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "sk-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.openai.com/v1",
+      apiKeyUrl: "https://platform.openai.com/api-keys",
+      docsUrl: "https://platform.openai.com/docs/api-reference",
+      description: "OpenAI API models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.openai.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "openrouter",
+      aliases: [],
+      label: "OpenRouter",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/api/v1",
+      paths: {
+        chat: "/api/v1/chat/completions",
+        models: "/api/v1/models",
+        embeddings: "/api/v1/embeddings"
+      },
+      auth: bearerAuth(true, "sk-or-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://openrouter.ai/api/v1",
+      apiKeyUrl: "https://openrouter.ai/keys",
+      docsUrl: "https://openrouter.ai/docs",
+      description: "OpenAI-compatible routing across hosted models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "openrouter.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "groq",
+      aliases: [],
+      label: "Groq",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/openai/v1",
+      paths: {
+        chat: "/openai/v1/chat/completions",
+        models: "/openai/v1/models",
+        embeddings: "/openai/v1/embeddings"
+      },
+      auth: bearerAuth(true, "gsk_"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.groq.com/openai/v1",
+      apiKeyUrl: "https://console.groq.com/keys",
+      docsUrl: "https://console.groq.com/docs",
+      description: "Groq OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.groq.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "deepinfra",
+      aliases: [],
+      label: "DeepInfra",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1/openai",
+      paths: {
+        chat: "/v1/openai/chat/completions",
+        models: "/v1/openai/models",
+        embeddings: "/v1/openai/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.deepinfra.com/v1/openai",
+      apiKeyUrl: "https://deepinfra.com/dash/api_keys",
+      docsUrl: "https://deepinfra.com/docs/openai_api",
+      description: "DeepInfra OpenAI-compatible hosted models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.deepinfra.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "fireworks",
+      aliases: ["fireworks-ai"],
+      label: "Fireworks AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/inference/v1",
+      paths: {
+        chat: "/inference/v1/chat/completions",
+        models: "/inference/v1/models",
+        embeddings: "/inference/v1/embeddings"
+      },
+      auth: bearerAuth(true, "fw_"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.fireworks.ai/inference/v1",
+      apiKeyUrl: "https://fireworks.ai/account/api-keys",
+      docsUrl: "https://docs.fireworks.ai",
+      description: "Fireworks OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.fireworks.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "together",
+      aliases: ["together-ai"],
+      label: "Together AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.together.xyz/v1",
+      apiKeyUrl: "https://api.together.xyz/settings/api-keys",
+      docsUrl: "https://docs.together.ai",
+      description: "Together OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.together.xyz"
+  },
+  {
+    descriptor: descriptor({
+      id: "chutes",
+      aliases: ["chutes-ai"],
+      label: "Chutes AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "cpk_"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://llm.chutes.ai/v1",
+      apiKeyUrl: "https://chutes.ai/app/api",
+      docsUrl: "https://docs.chutes.ai",
+      description: "Chutes OpenAI-compatible model endpoint."
+    }),
+    match: (url) => ["llm.chutes.ai", "chutes.ai"].includes(url.hostname.toLowerCase())
+  },
+  {
+    descriptor: descriptor({
+      id: "mistral",
+      aliases: ["mistral-ai"],
+      label: "Mistral AI",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.mistral.ai/v1",
+      apiKeyUrl: "https://console.mistral.ai/api-keys",
+      docsUrl: "https://docs.mistral.ai",
+      description: "Mistral hosted model endpoint."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.mistral.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "cerebras",
+      aliases: [],
+      label: "Cerebras",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "csk-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.cerebras.ai/v1",
+      apiKeyUrl: "https://cloud.cerebras.ai/platform",
+      docsUrl: "https://inference-docs.cerebras.ai",
+      description: "Cerebras OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.cerebras.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "sambanova",
+      aliases: ["samba-nova"],
+      label: "SambaNova",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.sambanova.ai/v1",
+      apiKeyUrl: "https://cloud.sambanova.ai/apis",
+      docsUrl: "https://docs.sambanova.ai",
+      description: "SambaNova OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.sambanova.ai"
+  },
+  {
+    descriptor: descriptor({
+      id: "nvidia",
+      aliases: ["nvidia-nim", "nim"],
+      label: "NVIDIA NIM",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true, "nvapi-"),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://integrate.api.nvidia.com/v1",
+      apiKeyUrl: "https://build.nvidia.com",
+      docsUrl: "https://docs.api.nvidia.com/nim",
+      description: "NVIDIA-hosted NIM models."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "integrate.api.nvidia.com"
+  },
+  {
+    descriptor: descriptor({
+      id: "hyperbolic",
+      aliases: [],
+      label: "Hyperbolic",
+      protocol: "openai-chat",
+      local: false,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(true),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "https://api.hyperbolic.xyz/v1",
+      apiKeyUrl: "https://app.hyperbolic.xyz/settings",
+      docsUrl: "https://docs.hyperbolic.xyz",
+      description: "Hyperbolic OpenAI-compatible inference."
+    }),
+    match: (url) => url.hostname.toLowerCase() === "api.hyperbolic.xyz"
+  },
+  {
+    descriptor: descriptor({
+      id: "ollama",
+      aliases: [],
+      label: "Ollama (local)",
+      protocol: "ollama",
+      local: true,
+      apiPrefix: "",
+      paths: {
+        chat: "/v1/chat/completions",
+        nativeChat: "/api/chat",
+        models: "/api/tags",
+        embeddings: "/api/embed",
+        health: "/api/tags"
+      },
+      auth: noAuth(),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "http://127.0.0.1:11434",
+      docsUrl: "https://docs.ollama.com/api",
+      description: "Local Ollama runtime."
+    }),
+    match: (url) => url.port === "11434"
+  },
+  {
+    descriptor: descriptor({
+      id: "lmstudio",
+      aliases: ["lm-studio"],
+      label: "LM Studio (local)",
+      protocol: "openai-chat",
+      local: true,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings"
+      },
+      auth: bearerAuth(false),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "http://127.0.0.1:1234/v1",
+      docsUrl: "https://lmstudio.ai/docs",
+      description: "Local LM Studio OpenAI-compatible server."
+    }),
+    match: (url) => url.port === "1234"
+  },
+  {
+    descriptor: descriptor({
+      id: "vllm",
+      aliases: ["v-llm"],
+      label: "vLLM (local)",
+      protocol: "openai-chat",
+      local: true,
+      apiPrefix: "/v1",
+      paths: {
+        chat: "/v1/chat/completions",
+        models: "/v1/models",
+        embeddings: "/v1/embeddings",
+        health: "/health"
+      },
+      auth: bearerAuth(false),
+      capabilities: OPENAI_CAPABILITIES,
+      defaultUrl: "http://127.0.0.1:8000/v1",
+      docsUrl: "https://docs.vllm.ai",
+      description: "Self-hosted vLLM OpenAI-compatible endpoint."
+    }),
+    match: (url) => url.port === "8000"
+  }
+];
+var descriptors = registrations.map((entry) => entry.descriptor);
+var providerProtocols = /* @__PURE__ */ new Set([
+  "ollama",
+  "openai-chat",
+  "anthropic-messages"
+]);
+function validatedProtocol(value) {
+  if (value === void 0)
+    return void 0;
+  if (providerProtocols.has(value))
+    return value;
+  throw new UnknownProviderProtocolError(`Unknown inference protocol: ${String(value)}. Select ollama, openai-chat, or anthropic-messages.`);
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "";
+  return `/${path.replace(/^\/+|\/+$/g, "")}`;
+}
+function withoutTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function parseProviderUrl(raw) {
+  const value = raw.trim();
+  if (!value) {
+    throw new UnknownProviderProtocolError("Inference endpoint URL is empty; select a provider or supply an explicit protocol.");
+  }
+  try {
+    return new URL(value);
+  } catch {
+    throw new UnknownProviderProtocolError(`Invalid inference endpoint URL: ${value}`);
+  }
+}
+function descriptorForId(id) {
+  const normalized2 = id?.trim().toLowerCase();
+  if (!normalized2)
+    return void 0;
+  return descriptors.find((entry) => entry.id === normalized2 || entry.aliases.some((alias) => alias.toLowerCase() === normalized2));
+}
+function detectDescriptor(url) {
+  return registrations.find((entry) => entry.match(url))?.descriptor;
+}
+function serviceBaseForKnown(rawUrl, provider) {
+  const url = parseProviderUrl(rawUrl);
+  let path = normalizePath(url.pathname);
+  const suffixes = [
+    ...Object.values(provider.paths).filter((value) => typeof value === "string"),
+    provider.apiPrefix
+  ].filter(Boolean).sort((left, right) => right.length - left.length);
+  for (const suffix of suffixes) {
+    if (path.toLowerCase().endsWith(suffix.toLowerCase())) {
+      path = normalizePath(path.slice(0, -suffix.length));
+      break;
+    }
+  }
+  return withoutTrailingSlash(`${url.origin}${path}`);
+}
+function customDescriptor(protocol, rawUrl) {
+  const url = parseProviderUrl(rawUrl);
+  let endpointPath = normalizePath(url.pathname);
+  const resourceSuffixes = protocol === "anthropic-messages" ? ["/messages", "/models"] : protocol === "openai-chat" ? ["/chat/completions", "/completions", "/embeddings", "/models"] : ["/v1/chat/completions", "/api/chat", "/api/tags", "/api/embed"];
+  for (const suffix of resourceSuffixes) {
+    if (endpointPath.toLowerCase().endsWith(suffix)) {
+      endpointPath = normalizePath(endpointPath.slice(0, -suffix.length));
+      break;
+    }
+  }
+  if (!endpointPath) {
+    if (protocol === "openai-chat" || protocol === "anthropic-messages") {
+      endpointPath = "/v1";
+    }
+  }
+  const paths = protocol === "ollama" ? {
+    chat: `${endpointPath}/v1/chat/completions`,
+    nativeChat: `${endpointPath}/api/chat`,
+    models: `${endpointPath}/api/tags`,
+    embeddings: `${endpointPath}/api/embed`,
+    health: `${endpointPath}/api/tags`
+  } : protocol === "anthropic-messages" ? {
+    chat: `${endpointPath}/messages`,
+    models: `${endpointPath}/models`
+  } : {
+    chat: `${endpointPath}/chat/completions`,
+    models: `${endpointPath}/models`,
+    embeddings: `${endpointPath}/embeddings`
+  };
+  return descriptor({
+    id: "custom",
+    aliases: [],
+    label: protocol === "anthropic-messages" ? "Custom Anthropic Messages endpoint" : protocol === "ollama" ? "Custom Ollama endpoint" : "Custom OpenAI-compatible endpoint",
+    protocol,
+    local: ["localhost", "127.0.0.1", "0.0.0.0", "::1"].includes(url.hostname.toLowerCase()),
+    apiPrefix: endpointPath,
+    paths,
+    auth: protocol === "anthropic-messages" ? {
+      strategy: "anthropic-api-key",
+      required: false,
+      staticHeaders: { "anthropic-version": "2023-06-01" }
+    } : protocol === "ollama" ? noAuth() : bearerAuth(false),
+    capabilities: protocol === "anthropic-messages" ? CHAT_CAPABILITIES : OPENAI_CAPABILITIES,
+    defaultUrl: `${url.origin}${endpointPath}`,
+    description: `Custom endpoint with explicit ${protocol} protocol.`
+  });
+}
+function legacyProtocol(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "ollama":
+      return "ollama";
+    case "vllm":
+    case "openai":
+    case "openai-compatible":
+    case "openai-chat":
+      return "openai-chat";
+    case "anthropic":
+    case "claude":
+    case "anthropic-messages":
+      return "anthropic-messages";
+    default:
+      return void 0;
+  }
+}
+function urlsFor(serviceBaseUrl, provider) {
+  const result = {};
+  for (const [kind, path] of Object.entries(provider.paths)) {
+    if (typeof path === "string") {
+      result[kind] = `${serviceBaseUrl}${path}`;
+    }
+  }
+  return result;
+}
+var UnknownProviderProtocolError = class extends Error {
+  code = "OMNIUS_PROVIDER_PROTOCOL_REQUIRED";
+  constructor(message) {
+    super(message);
+    this.name = "UnknownProviderProtocolError";
+  }
+};
+function listProviderDescriptors() {
+  return [...descriptors].sort((left, right) => Number(right.local) - Number(left.local)).map((entry) => ({
+    ...entry,
+    aliases: [...entry.aliases],
+    paths: { ...entry.paths },
+    auth: {
+      ...entry.auth,
+      ...entry.auth.staticHeaders ? { staticHeaders: { ...entry.auth.staticHeaders } } : {}
+    },
+    capabilities: [...entry.capabilities]
+  }));
+}
+function detectProviderDescriptor(rawUrl) {
+  try {
+    return detectDescriptor(parseProviderUrl(rawUrl));
+  } catch {
+    return void 0;
+  }
+}
+function resolveProviderDescriptor(options) {
+  const explicitProtocol = validatedProtocol(options.protocol);
+  const requestedProviderId = options.providerId?.trim().toLowerCase();
+  const selected = descriptorForId(options.providerId);
+  if (requestedProviderId === "custom") {
+    if (!explicitProtocol || !options.baseUrl) {
+      throw new UnknownProviderProtocolError("Custom inference providers require both baseUrl and an explicit protocol.");
+    }
+    return customDescriptor(explicitProtocol, options.baseUrl);
+  }
+  if (requestedProviderId && !selected) {
+    throw new UnknownProviderProtocolError(`Unknown inference provider id: ${requestedProviderId}.`);
+  }
+  const detected = options.baseUrl ? detectProviderDescriptor(options.baseUrl) : void 0;
+  if (explicitProtocol && (selected ?? detected) && (selected ?? detected).protocol !== explicitProtocol) {
+    const known = selected ?? detected;
+    throw new UnknownProviderProtocolError(`Protocol ${explicitProtocol} conflicts with provider ${known.id} (${known.protocol}).`);
+  }
+  if (selected)
+    return selected;
+  if (detected)
+    return detected;
+  const protocol = explicitProtocol ?? legacyProtocol(options.legacyBackendType);
+  if (!protocol) {
+    throw new UnknownProviderProtocolError(`Cannot infer the inference protocol for ${options.baseUrl ?? "this endpoint"}. Set protocol to ollama, openai-chat, or anthropic-messages before probing or running inference.`);
+  }
+  if (!options.baseUrl) {
+    throw new UnknownProviderProtocolError(`An endpoint URL is required for the explicit ${protocol} protocol.`);
+  }
+  return customDescriptor(protocol, options.baseUrl);
+}
+function resolveProviderTransport(options) {
+  const selected = descriptorForId(options.providerId);
+  const customSelected = options.providerId?.trim().toLowerCase() === "custom";
+  const detected = options.baseUrl ? detectProviderDescriptor(options.baseUrl) : void 0;
+  const provider = resolveProviderDescriptor(options);
+  const rawUrl = options.baseUrl ?? provider.defaultUrl;
+  if (!rawUrl) {
+    throw new UnknownProviderProtocolError(`Provider ${provider.id} has no default endpoint; supply baseUrl explicitly.`);
+  }
+  const isCustom = provider.id === "custom";
+  const serviceBaseUrl = serviceBaseForKnown(rawUrl, provider);
+  const endpointBaseUrl = `${serviceBaseUrl}${provider.apiPrefix}`;
+  const source = selected ? "provider-id" : customSelected ? "explicit-protocol" : detected ? "known-url" : options.protocol ? "explicit-protocol" : "legacy-backend-type";
+  return {
+    descriptor: provider,
+    providerId: provider.id,
+    protocol: provider.protocol,
+    serviceBaseUrl,
+    endpointBaseUrl: withoutTrailingSlash(endpointBaseUrl),
+    urls: Object.freeze(urlsFor(serviceBaseUrl, provider)),
+    source: isCustom && source === "known-url" ? "explicit-protocol" : source
+  };
+}
+function buildProviderHeaders(provider, options = {}) {
+  const metadata = "descriptor" in provider ? provider.descriptor : provider;
+  const headers = {};
+  if (options.includeJsonContentType !== false) {
+    headers["Content-Type"] = "application/json";
+  }
+  for (const [name, template] of Object.entries(metadata.auth.staticHeaders ?? {})) {
+    headers[name] = template.replace("{version}", options.clientVersion?.trim() || "unknown");
+  }
+  const key = options.apiKey?.trim();
+  if (key) {
+    if (metadata.auth.strategy === "anthropic-api-key") {
+      headers["x-api-key"] = key;
+    } else if (metadata.auth.strategy === "bearer") {
+      headers["Authorization"] = `Bearer ${key}`;
+    }
+  }
+  return headers;
+}
+function providerUrl(provider, kind) {
+  const url = provider.urls[kind];
+  if (!url) {
+    throw new UnknownProviderProtocolError(`Provider ${provider.providerId} does not expose ${kind}.`);
+  }
+  return url;
+}
+
+// packages/backend-vllm/dist/normalizeUrl.js
+function normalizeBaseUrl(url) {
+  let value = url.trim().replace(/\/+$/, "");
+  value = value.replace(/\/chat\/completions$/, "");
+  value = value.replace(/\/completions$/, "");
+  value = value.replace(/\/embeddings$/, "");
+  value = value.replace(/\/models(?:\/.*)?$/, "");
+  value = value.replace(/\/+$/, "");
+  value = value.replace(/\/v1\/openai$/, "");
+  value = value.replace(/\/+$/, "");
+  value = value.replace(/\/v1$/, "");
+  return value.replace(/\/+$/, "");
+}
+function toProviderInfo(provider) {
+  const normalizedDefault = provider.defaultUrl ? normalizeBaseUrl(provider.defaultUrl) : "";
+  const absoluteModelsUrl = provider.defaultUrl && provider.paths.models ? `${new URL(provider.defaultUrl).origin}${provider.paths.models}` : "";
+  const modelsPath = normalizedDefault && absoluteModelsUrl.startsWith(normalizedDefault) ? absoluteModelsUrl.slice(normalizedDefault.length) || "/models" : provider.paths.models ?? `${provider.apiPrefix}/models`;
+  return {
+    id: provider.id,
+    label: provider.label,
+    local: provider.local,
+    authRequired: provider.auth.required,
+    ...provider.auth.keyPrefix ? { keyPrefix: provider.auth.keyPrefix } : {},
+    // Compatibility path relative to normalizeBaseUrl(defaultUrl). New code
+    // should use resolveProviderTransport().urls.models directly.
+    modelsPath,
+    ...provider.defaultUrl ? { defaultUrl: provider.defaultUrl } : {},
+    ...provider.apiKeyUrl ? { apiKeyUrl: provider.apiKeyUrl } : {},
+    ...provider.docsUrl ? { docsUrl: provider.docsUrl } : {},
+    description: provider.description,
+    protocol: provider.protocol,
+    apiPrefix: provider.apiPrefix,
+    aliases: provider.aliases
+  };
+}
+var PROVIDER_PRESETS = [
+  ...listProviderDescriptors().map(toProviderInfo),
+  {
+    id: "custom",
+    label: "Custom endpoint",
+    local: false,
+    authRequired: false,
+    modelsPath: "/v1/models",
+    description: "Custom endpoint; an explicit ollama, openai-chat, or anthropic-messages protocol is required."
+  }
+];
+export {
+  OmniusVersionError,
+  UnknownProviderProtocolError,
+  assertServiceVersion,
+  buildProviderHeaders,
+  compareOmniusVersions,
+  detectProviderDescriptor,
+  discoverCapabilities,
+  discoveryDocsRoot,
+  discoverySchemaVersion,
+  findDiscoveryCatalogPath,
+  getServiceVersion,
+  isVersionGatedExecutionRequest,
+  listProviderDescriptors,
+  loadDiscoveryCatalog,
+  parseOmniusVersion,
+  providerUrl,
+  rankCapabilities,
+  resolveProviderDescriptor,
+  resolveProviderTransport,
+  showCapability
+};