@poolzin/pool-bot 2026.3.22 → 2026.3.24

package/dist/agents/failover-error.js

@@ -1,5 +1,5 @@
-import { classifyFailoverReason } from "./pi-embedded-helpers.js";
-const TIMEOUT_HINT_RE = /timeout|timed out|deadline exceeded|context deadline exceeded/i;
+import { readErrorName } from "../infra/errors.js";
+import { classifyFailoverReason, isTimeoutErrorMessage, } from "./pi-embedded-helpers.js";
 const ABORT_TIMEOUT_RE = /request was aborted|request aborted/i;
 export class FailoverError extends Error {
     reason;
@@ -28,104 +28,200 @@ export function resolveFailoverStatus(reason) {
             return 402;
         case "rate_limit":
             return 429;
+        case "overloaded":
+            return 503;
         case "auth":
             return 401;
+        case "auth_permanent":
+            return 403;
         case "timeout":
             return 408;
         case "format":
             return 400;
         case "model_not_found":
             return 404;
+        case "session_expired":
+            return 410; // Gone - session no longer exists
         default:
             return undefined;
     }
 }
-function getStatusCode(err) {
-    if (!err || typeof err !== "object")
+function findErrorProperty(err, reader, seen = new Set()) {
+    const direct = reader(err);
+    if (direct !== undefined) {
+        return direct;
+    }
+    if (!err || typeof err !== "object") {
+        return undefined;
+    }
+    if (seen.has(err)) {
+        return undefined;
+    }
+    seen.add(err);
+    const candidate = err;
+    return (findErrorProperty(candidate.error, reader, seen) ??
+        findErrorProperty(candidate.cause, reader, seen));
+}
+function readDirectStatusCode(err) {
+    if (!err || typeof err !== "object") {
         return undefined;
+    }
     const candidate = err.status ??
         err.statusCode;
-    if (typeof candidate === "number")
+    if (typeof candidate === "number") {
         return candidate;
+    }
     if (typeof candidate === "string" && /^\d+$/.test(candidate)) {
         return Number(candidate);
     }
     return undefined;
 }
-function getErrorName(err) {
-    if (!err || typeof err !== "object")
-        return "";
-    return "name" in err ? String(err.name) : "";
+function getStatusCode(err) {
+    return findErrorProperty(err, readDirectStatusCode);
 }
-function getErrorCode(err) {
-    if (!err || typeof err !== "object")
+function readDirectErrorCode(err) {
+    if (!err || typeof err !== "object") {
         return undefined;
-    const candidate = err.code;
-    if (typeof candidate !== "string")
+    }
+    const directCode = err.code;
+    if (typeof directCode === "string") {
+        const trimmed = directCode.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    const status = err.status;
+    if (typeof status !== "string" || /^\d+$/.test(status)) {
         return undefined;
-    const trimmed = candidate.trim();
+    }
+    const trimmed = status.trim();
     return trimmed ? trimmed : undefined;
 }
-function getErrorMessage(err) {
-    if (err instanceof Error)
-        return err.message;
-    if (typeof err === "string")
-        return err;
+function getErrorCode(err) {
+    return findErrorProperty(err, readDirectErrorCode);
+}
+function readDirectErrorMessage(err) {
+    if (err instanceof Error) {
+        return err.message || undefined;
+    }
+    if (typeof err === "string") {
+        return err || undefined;
+    }
     if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint") {
         return String(err);
     }
-    if (typeof err === "symbol")
-        return err.description ?? "";
+    if (typeof err === "symbol") {
+        return err.description ?? undefined;
+    }
     if (err && typeof err === "object") {
         const message = err.message;
-        if (typeof message === "string")
-            return message;
+        if (typeof message === "string") {
+            return message || undefined;
+        }
+    }
+    return undefined;
+}
+function getErrorMessage(err) {
+    return findErrorProperty(err, readDirectErrorMessage) ?? "";
+}
+function getErrorCause(err) {
+    if (!err || typeof err !== "object" || !("cause" in err)) {
+        return undefined;
+    }
+    return err.cause;
+}
+/** Classify rate-limit / overloaded from symbolic error codes like RESOURCE_EXHAUSTED. */
+function classifyFailoverReasonFromSymbolicCode(raw) {
+    const normalized = raw?.trim().toUpperCase();
+    if (!normalized) {
+        return null;
+    }
+    switch (normalized) {
+        case "RESOURCE_EXHAUSTED":
+        case "RATE_LIMIT":
+        case "RATE_LIMITED":
+        case "RATE_LIMIT_EXCEEDED":
+        case "TOO_MANY_REQUESTS":
+        case "THROTTLED":
+        case "THROTTLING":
+        case "THROTTLINGEXCEPTION":
+        case "THROTTLING_EXCEPTION":
+            return "rate_limit";
+        case "OVERLOADED":
+        case "OVERLOADED_ERROR":
+            return "overloaded";
+        default:
+            return null;
     }
-    return "";
 }
 function hasTimeoutHint(err) {
-    if (!err)
+    if (!err) {
         return false;
-    if (getErrorName(err) === "TimeoutError")
+    }
+    if (readErrorName(err) === "TimeoutError") {
         return true;
+    }
     const message = getErrorMessage(err);
-    return Boolean(message && TIMEOUT_HINT_RE.test(message));
+    return Boolean(message && isTimeoutErrorMessage(message));
 }
 export function isTimeoutError(err) {
-    if (hasTimeoutHint(err))
+    if (hasTimeoutHint(err)) {
         return true;
-    if (!err || typeof err !== "object")
+    }
+    if (!err || typeof err !== "object") {
         return false;
-    if (getErrorName(err) !== "AbortError")
+    }
+    if (readErrorName(err) !== "AbortError") {
         return false;
+    }
     const message = getErrorMessage(err);
-    if (message && ABORT_TIMEOUT_RE.test(message))
+    if (message && ABORT_TIMEOUT_RE.test(message)) {
         return true;
+    }
     const cause = "cause" in err ? err.cause : undefined;
     const reason = "reason" in err ? err.reason : undefined;
     return hasTimeoutHint(cause) || hasTimeoutHint(reason);
 }
 export function resolveFailoverReasonFromError(err) {
-    if (isFailoverError(err))
+    if (isFailoverError(err)) {
         return err.reason;
-    const status = getStatusCode(err);
-    if (status === 402)
-        return "billing";
-    if (status === 429)
-        return "rate_limit";
-    if (status === 401 || status === 403)
-        return "auth";
-    if (status === 408)
-        return "timeout";
+    }
+    const message = getErrorMessage(err);
+    // Check symbolic error codes (e.g. RESOURCE_EXHAUSTED from Google APIs)
+    const symbolicCodeReason = classifyFailoverReasonFromSymbolicCode(getErrorCode(err));
+    if (symbolicCodeReason) {
+        return symbolicCodeReason;
+    }
     const code = (getErrorCode(err) ?? "").toUpperCase();
-    if (["ETIMEDOUT", "ESOCKETTIMEDOUT", "ECONNRESET", "ECONNABORTED"].includes(code)) {
+    if ([
+        "ETIMEDOUT",
+        "ESOCKETTIMEDOUT",
+        "ECONNRESET",
+        "ECONNABORTED",
+        "ECONNREFUSED",
+        "ENETUNREACH",
+        "EHOSTUNREACH",
+        "EHOSTDOWN",
+        "ENETRESET",
+        "EPIPE",
+        "EAI_AGAIN",
+    ].includes(code)) {
         return "timeout";
     }
-    if (isTimeoutError(err))
+    // Walk into error cause chain *before* timeout heuristics so that a specific
+    // cause (e.g. RESOURCE_EXHAUSTED wrapped in AbortError) overrides a parent
+    // message-based "timeout" guess from isTimeoutError.
+    const cause = getErrorCause(err);
+    if (cause && cause !== err) {
+        const causeReason = resolveFailoverReasonFromError(cause);
+        if (causeReason) {
+            return causeReason;
+        }
+    }
+    if (isTimeoutError(err)) {
         return "timeout";
-    const message = getErrorMessage(err);
-    if (!message)
+    }
+    if (!message) {
         return null;
+    }
     return classifyFailoverReason(message);
 }
 export function describeFailoverError(err) {
@@ -146,11 +242,13 @@ export function describeFailoverError(err) {
     };
 }
 export function coerceToFailoverError(err, context) {
-    if (isFailoverError(err))
+    if (isFailoverError(err)) {
         return err;
+    }
     const reason = resolveFailoverReasonFromError(err);
-    if (!reason)
+    if (!reason) {
         return null;
+    }
     const message = getErrorMessage(err) || String(err);
     const status = getStatusCode(err) ?? resolveFailoverStatus(reason);
     const code = getErrorCode(err);

package/dist/agents/fast-mode.js

@@ -0,0 +1,24 @@
+import { normalizeFastMode } from "../auto-reply/thinking.js";
+export function resolveFastModeParam(extraParams) {
+    return normalizeFastMode((extraParams?.fastMode ?? extraParams?.fast_mode));
+}
+function resolveConfiguredFastModeRaw(params) {
+    const modelKey = `${params.provider}/${params.model}`;
+    const modelConfig = params.cfg?.agents?.defaults?.models?.[modelKey];
+    return modelConfig?.params?.fastMode ?? modelConfig?.params?.fast_mode;
+}
+export function resolveConfiguredFastMode(params) {
+    return (normalizeFastMode(resolveConfiguredFastModeRaw(params)) ?? false);
+}
+export function resolveFastModeState(params) {
+    const sessionOverride = normalizeFastMode(params.sessionEntry?.fastMode);
+    if (sessionOverride !== undefined) {
+        return { enabled: sessionOverride, source: "session" };
+    }
+    const configuredRaw = resolveConfiguredFastModeRaw(params);
+    const configured = normalizeFastMode(configuredRaw);
+    if (configured !== undefined) {
+        return { enabled: configured, source: "config" };
+    }
+    return { enabled: false, source: "default" };
+}

package/dist/agents/live-model-errors.js

@@ -0,0 +1,23 @@
+export function isModelNotFoundErrorMessage(raw) {
+    const msg = raw.trim();
+    if (!msg) {
+        return false;
+    }
+    if (/\b404\b/.test(msg) && /not(?:[_\-\s])?found/i.test(msg)) {
+        return true;
+    }
+    if (/not_found_error/i.test(msg)) {
+        return true;
+    }
+    if (/model:\s*[a-z0-9._-]+/i.test(msg) && /not(?:[_\-\s])?found/i.test(msg)) {
+        return true;
+    }
+    return false;
+}
+export function isMiniMaxModelNotFoundErrorMessage(raw) {
+    const msg = raw.trim();
+    if (!msg) {
+        return false;
+    }
+    return /\b404\b.*\bpage not found\b/i.test(msg);
+}

package/dist/agents/model-auth-env-vars.js

@@ -0,0 +1,44 @@
+export const PROVIDER_ENV_API_KEY_CANDIDATES = {
+    "github-copilot": ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"],
+    anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
+    chutes: ["CHUTES_OAUTH_TOKEN", "CHUTES_API_KEY"],
+    zai: ["ZAI_API_KEY", "Z_AI_API_KEY"],
+    opencode: ["OPENCODE_API_KEY", "OPENCODE_ZEN_API_KEY"],
+    "opencode-go": ["OPENCODE_API_KEY", "OPENCODE_ZEN_API_KEY"],
+    "qwen-portal": ["QWEN_OAUTH_TOKEN", "QWEN_PORTAL_API_KEY"],
+    volcengine: ["VOLCANO_ENGINE_API_KEY"],
+    "volcengine-plan": ["VOLCANO_ENGINE_API_KEY"],
+    byteplus: ["BYTEPLUS_API_KEY"],
+    "byteplus-plan": ["BYTEPLUS_API_KEY"],
+    "minimax-portal": ["MINIMAX_OAUTH_TOKEN", "MINIMAX_API_KEY"],
+    "kimi-coding": ["KIMI_API_KEY", "KIMICODE_API_KEY"],
+    huggingface: ["HUGGINGFACE_HUB_TOKEN", "HF_TOKEN"],
+    openai: ["OPENAI_API_KEY"],
+    google: ["GEMINI_API_KEY"],
+    voyage: ["VOYAGE_API_KEY"],
+    groq: ["GROQ_API_KEY"],
+    deepgram: ["DEEPGRAM_API_KEY"],
+    cerebras: ["CEREBRAS_API_KEY"],
+    xai: ["XAI_API_KEY"],
+    openrouter: ["OPENROUTER_API_KEY"],
+    litellm: ["LITELLM_API_KEY"],
+    "vercel-ai-gateway": ["AI_GATEWAY_API_KEY"],
+    "cloudflare-ai-gateway": ["CLOUDFLARE_AI_GATEWAY_API_KEY"],
+    moonshot: ["MOONSHOT_API_KEY"],
+    minimax: ["MINIMAX_API_KEY"],
+    nvidia: ["NVIDIA_API_KEY"],
+    xiaomi: ["XIAOMI_API_KEY"],
+    synthetic: ["SYNTHETIC_API_KEY"],
+    venice: ["VENICE_API_KEY"],
+    mistral: ["MISTRAL_API_KEY"],
+    together: ["TOGETHER_API_KEY"],
+    qianfan: ["QIANFAN_API_KEY"],
+    modelstudio: ["MODELSTUDIO_API_KEY"],
+    ollama: ["OLLAMA_API_KEY"],
+    sglang: ["SGLANG_API_KEY"],
+    vllm: ["VLLM_API_KEY"],
+    kilocode: ["KILOCODE_API_KEY"],
+};
+export function listKnownProviderEnvApiKeyNames() {
+    return [...new Set(Object.values(PROVIDER_ENV_API_KEY_CANDIDATES).flat())];
+}

package/dist/agents/model-auth-markers.js

@@ -0,0 +1,69 @@
+import { listKnownProviderEnvApiKeyNames } from "./model-auth-env-vars.js";
+export const MINIMAX_OAUTH_MARKER = "minimax-oauth";
+export const QWEN_OAUTH_MARKER = "qwen-oauth";
+export const OLLAMA_LOCAL_AUTH_MARKER = "ollama-local";
+export const CUSTOM_LOCAL_AUTH_MARKER = "custom-local";
+export const NON_ENV_SECRETREF_MARKER = "secretref-managed"; // pragma: allowlist secret
+export const SECRETREF_ENV_HEADER_MARKER_PREFIX = "secretref-env:"; // pragma: allowlist secret
+const AWS_SDK_ENV_MARKERS = new Set([
+    "AWS_BEARER_TOKEN_BEDROCK",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_PROFILE",
+]);
+// Legacy marker names kept for backward compatibility with existing models.json files.
+const LEGACY_ENV_API_KEY_MARKERS = [
+    "GOOGLE_API_KEY",
+    "DEEPSEEK_API_KEY",
+    "PERPLEXITY_API_KEY",
+    "FIREWORKS_API_KEY",
+    "NOVITA_API_KEY",
+    "AZURE_OPENAI_API_KEY",
+    "AZURE_API_KEY",
+    "MINIMAX_CODE_PLAN_KEY",
+];
+const KNOWN_ENV_API_KEY_MARKERS = new Set([
+    ...listKnownProviderEnvApiKeyNames(),
+    ...LEGACY_ENV_API_KEY_MARKERS,
+    ...AWS_SDK_ENV_MARKERS,
+]);
+export function isAwsSdkAuthMarker(value) {
+    return AWS_SDK_ENV_MARKERS.has(value.trim());
+}
+export function isKnownEnvApiKeyMarker(value) {
+    const trimmed = value.trim();
+    return KNOWN_ENV_API_KEY_MARKERS.has(trimmed) && !isAwsSdkAuthMarker(trimmed);
+}
+export function resolveNonEnvSecretRefApiKeyMarker(_source) {
+    return NON_ENV_SECRETREF_MARKER;
+}
+export function resolveNonEnvSecretRefHeaderValueMarker(_source) {
+    return NON_ENV_SECRETREF_MARKER;
+}
+export function resolveEnvSecretRefHeaderValueMarker(envVarName) {
+    return `${SECRETREF_ENV_HEADER_MARKER_PREFIX}${envVarName.trim()}`;
+}
+export function isSecretRefHeaderValueMarker(value) {
+    const trimmed = value.trim();
+    return (trimmed === NON_ENV_SECRETREF_MARKER || trimmed.startsWith(SECRETREF_ENV_HEADER_MARKER_PREFIX));
+}
+export function isNonSecretApiKeyMarker(value, opts) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const isKnownMarker = trimmed === MINIMAX_OAUTH_MARKER ||
+        trimmed === QWEN_OAUTH_MARKER ||
+        trimmed === OLLAMA_LOCAL_AUTH_MARKER ||
+        trimmed === CUSTOM_LOCAL_AUTH_MARKER ||
+        trimmed === NON_ENV_SECRETREF_MARKER ||
+        isAwsSdkAuthMarker(trimmed);
+    if (isKnownMarker) {
+        return true;
+    }
+    if (opts?.includeEnvVarName === false) {
+        return false;
+    }
+    // Do not treat arbitrary ALL_CAPS values as markers; only recognize the
+    // known env-var markers we intentionally persist for compatibility.
+    return KNOWN_ENV_API_KEY_MARKERS.has(trimmed);
+}

package/dist/agents/models-config.providers.discovery.js

@@ -0,0 +1,180 @@
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { KILOCODE_BASE_URL } from "../providers/kilocode-shared.js";
+import { discoverHuggingfaceModels, HUGGINGFACE_BASE_URL, HUGGINGFACE_MODEL_CATALOG, buildHuggingfaceModelDefinition, } from "./huggingface-models.js";
+import { discoverKilocodeModels } from "./kilocode-models.js";
+import { enrichOllamaModelsWithContext, OLLAMA_DEFAULT_CONTEXT_WINDOW, OLLAMA_DEFAULT_COST, OLLAMA_DEFAULT_MAX_TOKENS, isReasoningModelHeuristic, resolveOllamaApiBase, } from "./ollama-models.js";
+import { discoverVeniceModels, VENICE_BASE_URL } from "./venice-models.js";
+import { discoverVercelAiGatewayModels, VERCEL_AI_GATEWAY_BASE_URL } from "./vercel-ai-gateway.js";
+export { resolveOllamaApiBase } from "./ollama-models.js";
+const log = createSubsystemLogger("agents/model-providers");
+const OLLAMA_SHOW_CONCURRENCY = 8;
+const OLLAMA_SHOW_MAX_MODELS = 200;
+const OPENAI_COMPAT_LOCAL_DEFAULT_CONTEXT_WINDOW = 128000;
+const OPENAI_COMPAT_LOCAL_DEFAULT_MAX_TOKENS = 8192;
+const OPENAI_COMPAT_LOCAL_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+const SGLANG_BASE_URL = "http://127.0.0.1:30000/v1";
+const VLLM_BASE_URL = "http://127.0.0.1:8000/v1";
+async function discoverOllamaModels(baseUrl, opts) {
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
+        return [];
+    }
+    try {
+        const apiBase = resolveOllamaApiBase(baseUrl);
+        const response = await fetch(`${apiBase}/api/tags`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            if (!opts?.quiet) {
+                log.warn(`Failed to discover Ollama models: ${response.status}`);
+            }
+            return [];
+        }
+        const data = (await response.json());
+        if (!data.models || data.models.length === 0) {
+            log.debug("No Ollama models found on local instance");
+            return [];
+        }
+        const modelsToInspect = data.models.slice(0, OLLAMA_SHOW_MAX_MODELS);
+        if (modelsToInspect.length < data.models.length && !opts?.quiet) {
+            log.warn(`Capping Ollama /api/show inspection to ${OLLAMA_SHOW_MAX_MODELS} models (received ${data.models.length})`);
+        }
+        const discovered = await enrichOllamaModelsWithContext(apiBase, modelsToInspect, {
+            concurrency: OLLAMA_SHOW_CONCURRENCY,
+        });
+        return discovered.map((model) => ({
+            id: model.name,
+            name: model.name,
+            reasoning: isReasoningModelHeuristic(model.name),
+            input: ["text"],
+            cost: OLLAMA_DEFAULT_COST,
+            contextWindow: model.contextWindow ?? OLLAMA_DEFAULT_CONTEXT_WINDOW,
+            maxTokens: OLLAMA_DEFAULT_MAX_TOKENS,
+        }));
+    }
+    catch (error) {
+        if (!opts?.quiet) {
+            log.warn(`Failed to discover Ollama models: ${String(error)}`);
+        }
+        return [];
+    }
+}
+async function discoverOpenAICompatibleLocalModels(params) {
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
+        return [];
+    }
+    const trimmedBaseUrl = params.baseUrl.trim().replace(/\/+$/, "");
+    const url = `${trimmedBaseUrl}/models`;
+    try {
+        const trimmedApiKey = params.apiKey?.trim();
+        const response = await fetch(url, {
+            headers: trimmedApiKey ? { Authorization: `Bearer ${trimmedApiKey}` } : undefined,
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            log.warn(`Failed to discover ${params.label} models: ${response.status}`);
+            return [];
+        }
+        const data = (await response.json());
+        const models = data.data ?? [];
+        if (models.length === 0) {
+            log.warn(`No ${params.label} models found on local instance`);
+            return [];
+        }
+        return models
+            .map((model) => ({ id: typeof model.id === "string" ? model.id.trim() : "" }))
+            .filter((model) => Boolean(model.id))
+            .map((model) => {
+            const modelId = model.id;
+            return {
+                id: modelId,
+                name: modelId,
+                reasoning: isReasoningModelHeuristic(modelId),
+                input: ["text"],
+                cost: OPENAI_COMPAT_LOCAL_DEFAULT_COST,
+                contextWindow: params.contextWindow ?? OPENAI_COMPAT_LOCAL_DEFAULT_CONTEXT_WINDOW,
+                maxTokens: params.maxTokens ?? OPENAI_COMPAT_LOCAL_DEFAULT_MAX_TOKENS,
+            };
+        });
+    }
+    catch (error) {
+        log.warn(`Failed to discover ${params.label} models: ${String(error)}`);
+        return [];
+    }
+}
+export async function buildVeniceProvider() {
+    const models = await discoverVeniceModels();
+    return {
+        baseUrl: VENICE_BASE_URL,
+        api: "openai-completions",
+        models,
+    };
+}
+export async function buildOllamaProvider(configuredBaseUrl, opts) {
+    const models = await discoverOllamaModels(configuredBaseUrl, opts);
+    return {
+        baseUrl: resolveOllamaApiBase(configuredBaseUrl),
+        api: "ollama",
+        models,
+    };
+}
+export async function buildHuggingfaceProvider(discoveryApiKey) {
+    const resolvedSecret = discoveryApiKey?.trim() ?? "";
+    const models = resolvedSecret !== ""
+        ? await discoverHuggingfaceModels(resolvedSecret)
+        : HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+    return {
+        baseUrl: HUGGINGFACE_BASE_URL,
+        api: "openai-completions",
+        models,
+    };
+}
+export async function buildVercelAiGatewayProvider() {
+    return {
+        baseUrl: VERCEL_AI_GATEWAY_BASE_URL,
+        api: "anthropic-messages",
+        models: await discoverVercelAiGatewayModels(),
+    };
+}
+export async function buildVllmProvider(params) {
+    const baseUrl = (params?.baseUrl?.trim() || VLLM_BASE_URL).replace(/\/+$/, "");
+    const models = await discoverOpenAICompatibleLocalModels({
+        baseUrl,
+        apiKey: params?.apiKey,
+        label: "vLLM",
+    });
+    return {
+        baseUrl,
+        api: "openai-completions",
+        models,
+    };
+}
+export async function buildSglangProvider(params) {
+    const baseUrl = (params?.baseUrl?.trim() || SGLANG_BASE_URL).replace(/\/+$/, "");
+    const models = await discoverOpenAICompatibleLocalModels({
+        baseUrl,
+        apiKey: params?.apiKey,
+        label: "SGLang",
+    });
+    return {
+        baseUrl,
+        api: "openai-completions",
+        models,
+    };
+}
+/**
+ * Build the Kilocode provider with dynamic model discovery from the gateway
+ * API. Falls back to the static catalog on failure.
+ */
+export async function buildKilocodeProviderWithDiscovery() {
+    const models = await discoverKilocodeModels();
+    return {
+        baseUrl: KILOCODE_BASE_URL,
+        api: "openai-completions",
+        models,
+    };
+}