@kenkaiiii/gg-core 5.23.3 → 5.25.0

package/dist/index.js

@@ -1,12 +1,15 @@
 import {
   AuthStorage,
   DEFAULT_MAX_VIDEO_BYTES,
+  LOCAL_AUTH_KEY_PREFIX,
   MODELS,
   MOONSHOT_OAUTH_KEY,
   NotLoggedInError,
   XIAOMI_CREDITS_KEY,
+  clearRuntimeModels,
   closeLogger,
   generatePKCE,
+  getAllModels,
   getAuthStorageKey,
   getAuthStorageKeys,
   getClaudeCliUserAgent,
@@ -38,9 +41,10 @@ import {
   refreshKimiToken,
   refreshOpenAIToken,
   registerLogCleanup,
+  registerRuntimeModels,
   usesOpenAICodexTransport,
   withFileLock
-} from "./chunk-7OICWYUV.js";
+} from "./chunk-6OH2XAFL.js";
 import {
   getAppPaths
 } from "./chunk-QNR6SNB2.js";
@@ -71,6 +75,7 @@ var ANTHROPIC_ADAPTIVE_THINKING_LEVELS = [
   "max"
 ];
 var MOONSHOT_K3_THINKING_LEVELS = ["low", "high", "max"];
+var LOCAL_THINKING_LEVELS = ["low", "medium", "high", "max"];
 function isOpenAIGptModel(provider, model) {
   return provider === "openai" && model.startsWith("gpt-");
 }
@@ -90,6 +95,12 @@ function isAnthropicAdaptiveModel(provider, model) {
   return provider === "anthropic" && /opus-5|opus-4-8|opus-4-7|opus-4-6|sonnet-5|fable-5|mythos-5/.test(model);
 }
 function getSupportedThinkingLevels(provider, model) {
+  if (provider === "local") {
+    const info = getModel(model);
+    if (!info?.supportsThinking) return [];
+    const maxIndex2 = LOCAL_THINKING_LEVELS.indexOf(info.maxThinkingLevel);
+    return maxIndex2 === -1 ? LOCAL_THINKING_LEVELS.slice(0, 3) : LOCAL_THINKING_LEVELS.slice(0, maxIndex2 + 1);
+  }
   const maxLevel = getMaxThinkingLevel(model);
   if (isAnthropicAdaptiveModel(provider, model)) {
     const levels2 = isAnthropicXhighModel(provider, model) ? ANTHROPIC_XHIGH_THINKING_LEVELS : ANTHROPIC_ADAPTIVE_THINKING_LEVELS;
@@ -119,7 +130,11 @@ function isThinkingLevelSupported(provider, model, level) {
 }
 function getNextThinkingLevel(provider, model, current) {
   const supportedLevels = getSupportedThinkingLevels(provider, model);
-  const shouldCycleLevels = isOpenAIGptModel(provider, model) || isAnthropicAdaptiveModel(provider, model) || isSakanaModel(provider) || isXaiModel(provider) || isMoonshotK3Model(provider, model);
+  const shouldCycleLevels = isOpenAIGptModel(provider, model) || isAnthropicAdaptiveModel(provider, model) || isSakanaModel(provider) || isXaiModel(provider) || isMoonshotK3Model(provider, model) || // Local servers take a real effort level, not just on/off: Ollama accepts
+  // low/medium/high on `reasoning_effort` (verified against 0.32) and the
+  // other OpenAI-compatible servers use the same three. A model that can't
+  // reason at all already has no supported levels, so it never gets here.
+  provider === "local";
   if (!shouldCycleLevels) {
     return current ? void 0 : supportedLevels[0];
   }
@@ -129,6 +144,253 @@ function getNextThinkingLevel(provider, model, current) {
   return supportedLevels[index + 1];
 }
 
+// src/local-models.ts
+var DEFAULT_LOCAL_ENDPOINTS = [
+  { id: "ollama", label: "Ollama", baseUrl: "http://127.0.0.1:11434/v1", kind: "ollama" },
+  { id: "lmstudio", label: "LM Studio", baseUrl: "http://127.0.0.1:1234/v1", kind: "lmstudio" },
+  { id: "llamacpp", label: "llama.cpp", baseUrl: "http://127.0.0.1:8080/v1", kind: "llamacpp" },
+  { id: "vllm", label: "vLLM", baseUrl: "http://127.0.0.1:8000/v1", kind: "vllm" }
+];
+var FALLBACK_CONTEXT_WINDOW = 8192;
+var LOCAL_API_KEY_PLACEHOLDER = "local";
+var DEFAULT_PROBE_TIMEOUT_MS = 1200;
+var ENRICH_CONCURRENCY = 6;
+var CACHE_TTL_MS = 3e4;
+var NON_CHAT_ID_PATTERN = /(?:^|[-_/])(?:embed|embedding|rerank|reranker|bge|nomic-embed)/i;
+var LOCAL_ID_PREFIX = "local/";
+function formatLocalModelId(endpointId, rawId) {
+  return `${LOCAL_ID_PREFIX}${endpointId}/${rawId}`;
+}
+function parseLocalModelId(id) {
+  if (!id.startsWith(LOCAL_ID_PREFIX)) return void 0;
+  const rest = id.slice(LOCAL_ID_PREFIX.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0 || slash === rest.length - 1) return void 0;
+  return { endpointId: rest.slice(0, slash), rawId: rest.slice(slash + 1) };
+}
+function isLocalModelId(id) {
+  return parseLocalModelId(id) !== void 0;
+}
+function localAuthStorageKey(endpointId) {
+  return `local:${endpointId}`;
+}
+function endpointRoot(baseUrl) {
+  return baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+function authHeaders(endpoint) {
+  return {
+    Authorization: `Bearer ${endpoint.apiKey ?? LOCAL_API_KEY_PLACEHOLDER}`,
+    Accept: "application/json"
+  };
+}
+async function fetchJson(url, endpoint, options) {
+  try {
+    const res = await fetchJsonOrThrow(url, endpoint, options);
+    return res;
+  } catch {
+    return void 0;
+  }
+}
+async function fetchJsonOrThrow(url, endpoint, { timeoutMs, signal, method = "GET", body }) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onAbort = () => controller.abort();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const res = await fetch(url, {
+      method,
+      signal: controller.signal,
+      headers: body ? { ...authHeaders(endpoint), "Content-Type": "application/json" } : authHeaders(endpoint),
+      ...body ? { body: JSON.stringify(body) } : {}
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+function unreachableReason(endpoint, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/abort/i.test(message)) return `No response from ${endpoint.baseUrl} (timed out)`;
+  if (/HTTP 401|HTTP 403/.test(message)) {
+    return `${endpoint.baseUrl} rejected the API key (HTTP ${message.includes("401") ? 401 : 403})`;
+  }
+  if (/HTTP \d+/.test(message)) return `${endpoint.baseUrl} returned ${message}`;
+  return `Not running at ${endpoint.baseUrl}`;
+}
+async function probeEndpoint(endpoint, { timeoutMs = DEFAULT_PROBE_TIMEOUT_MS, signal } = {}) {
+  const listUrl = `${endpoint.baseUrl.replace(/\/+$/, "")}/models`;
+  let list;
+  try {
+    list = await fetchJsonOrThrow(listUrl, endpoint, { timeoutMs, signal });
+  } catch (err) {
+    return { endpoint, reachable: false, reason: unreachableReason(endpoint, err), models: [] };
+  }
+  const entries = (list.data ?? []).filter(
+    (entry) => typeof entry.id === "string" && entry.id.length > 0 && !NON_CHAT_ID_PATTERN.test(entry.id)
+  );
+  const models = await enrich(endpoint, entries, { timeoutMs, signal });
+  log("INFO", "local-models", `Probed ${endpoint.label}`, {
+    baseUrl: endpoint.baseUrl,
+    models: String(models.length)
+  });
+  return { endpoint, reachable: true, models };
+}
+async function enrich(endpoint, entries, options) {
+  if (endpoint.kind === "lmstudio") return enrichLmStudio(endpoint, entries, options);
+  if (endpoint.kind === "ollama") return enrichOllama(endpoint, entries, options);
+  if (endpoint.kind === "llamacpp") return enrichLlamaCpp(endpoint, entries, options);
+  return entries.map((entry) => genericModel(endpoint, entry));
+}
+function genericModel(endpoint, entry) {
+  const declared = typeof entry.max_model_len === "number" ? entry.max_model_len : void 0;
+  return {
+    rawId: entry.id,
+    endpointId: endpoint.id,
+    contextWindow: declared ?? FALLBACK_CONTEXT_WINDOW,
+    contextWindowKnown: declared !== void 0,
+    supportsTools: true,
+    supportsImages: false,
+    supportsThinking: false
+  };
+}
+async function enrichOllama(endpoint, entries, options) {
+  const showUrl = `${endpointRoot(endpoint.baseUrl)}/api/show`;
+  const enriched = await mapLimited(entries, ENRICH_CONCURRENCY, async (entry) => {
+    const show = await fetchJson(showUrl, endpoint, {
+      ...options,
+      method: "POST",
+      body: { model: entry.id }
+    });
+    if (!show) return genericModel(endpoint, entry);
+    const caps = show.capabilities ?? [];
+    if (caps.includes("embedding") && !caps.includes("completion")) return void 0;
+    const ctx = ollamaContextLength(show.model_info);
+    return {
+      rawId: entry.id,
+      endpointId: endpoint.id,
+      contextWindow: ctx ?? FALLBACK_CONTEXT_WINDOW,
+      contextWindowKnown: ctx !== void 0,
+      // Ollama reports capabilities honestly, so trust it here rather than
+      // using the optimistic generic default.
+      supportsTools: caps.includes("tools"),
+      supportsImages: caps.includes("vision"),
+      supportsThinking: caps.includes("thinking")
+    };
+  });
+  return enriched.filter((model) => model !== void 0);
+}
+function ollamaContextLength(info) {
+  if (!info) return void 0;
+  for (const [key, value] of Object.entries(info)) {
+    if (key.endsWith(".context_length") && typeof value === "number" && value > 0) return value;
+  }
+  return void 0;
+}
+async function enrichLmStudio(endpoint, entries, options) {
+  const detail = await fetchJson(
+    `${endpointRoot(endpoint.baseUrl)}/api/v0/models`,
+    endpoint,
+    options
+  );
+  if (!detail?.data) return entries.map((entry) => genericModel(endpoint, entry));
+  const byId = new Map(detail.data.filter((m) => m.id).map((m) => [m.id, m]));
+  const models = [];
+  for (const entry of entries) {
+    const info = byId.get(entry.id);
+    if (info && info.type !== "llm" && info.type !== "vlm") continue;
+    const ctx = info?.max_context_length;
+    models.push({
+      rawId: entry.id,
+      endpointId: endpoint.id,
+      contextWindow: typeof ctx === "number" && ctx > 0 ? ctx : FALLBACK_CONTEXT_WINDOW,
+      contextWindowKnown: typeof ctx === "number" && ctx > 0,
+      // LM Studio doesn't report tool support; it gates per-model at request time.
+      supportsTools: true,
+      supportsImages: info?.type === "vlm",
+      supportsThinking: false,
+      loaded: info?.state === "loaded"
+    });
+  }
+  return models;
+}
+async function enrichLlamaCpp(endpoint, entries, options) {
+  const props = await fetchJson(
+    `${endpointRoot(endpoint.baseUrl)}/props`,
+    endpoint,
+    options
+  );
+  const nCtx = props?.default_generation_settings?.n_ctx;
+  const known = typeof nCtx === "number" && nCtx > 0;
+  return entries.map((entry) => ({
+    ...genericModel(endpoint, entry),
+    contextWindow: known ? nCtx : FALLBACK_CONTEXT_WINDOW,
+    contextWindowKnown: known
+  }));
+}
+async function mapLimited(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await fn(items[index]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function maxThinkingLevelFor(endpoint) {
+  return endpoint.kind === "ollama" ? "max" : "high";
+}
+function toModelInfo(model, endpoint) {
+  return {
+    id: formatLocalModelId(model.endpointId, model.rawId),
+    name: `${model.rawId} (${endpoint.label})`,
+    provider: "local",
+    contextWindow: model.contextWindow,
+    // Leave real headroom for the prompt on small local windows.
+    maxOutputTokens: Math.max(512, Math.min(4096, Math.floor(model.contextWindow / 4))),
+    supportsThinking: model.supportsThinking,
+    supportsImages: model.supportsImages,
+    supportsVideo: false,
+    costTier: "low",
+    maxThinkingLevel: maxThinkingLevelFor(endpoint),
+    authStorageKeys: [localAuthStorageKey(model.endpointId)]
+  };
+}
+var cache;
+function cacheKey(endpoints) {
+  return endpoints.map((e) => `${e.id}@${e.baseUrl}`).join("|");
+}
+async function discoverLocalModels(endpoints = DEFAULT_LOCAL_ENDPOINTS, options = {}) {
+  const key = cacheKey(endpoints);
+  if (!options.force && cache && cache.key === key && Date.now() - cache.at < CACHE_TTL_MS) {
+    return cache.result;
+  }
+  const probes = await Promise.all(endpoints.map((endpoint) => probeEndpoint(endpoint, options)));
+  const models = probes.flatMap(
+    (probe) => probe.models.map((model) => toModelInfo(model, probe.endpoint))
+  );
+  const result = { probes, models };
+  cache = { key, at: Date.now(), result };
+  return result;
+}
+function clearLocalDiscoveryCache() {
+  cache = void 0;
+}
+function findProbedModel(probes, modelId) {
+  const parsed = parseLocalModelId(modelId);
+  if (!parsed) return void 0;
+  for (const probe of probes) {
+    if (probe.endpoint.id !== parsed.endpointId) continue;
+    const model = probe.models.find((m) => m.rawId === parsed.rawId);
+    if (model) return { model, endpoint: probe.endpoint };
+  }
+  return void 0;
+}
+
 // src/provider-usage.ts
 var SubscriptionUsageError = class extends Error {
   constructor(message, status, retryAfterMs2) {
@@ -845,19 +1107,30 @@ function createAutoUpdater(config) {
 }
 export {
   AuthStorage,
+  DEFAULT_LOCAL_ENDPOINTS,
   DEFAULT_MAX_VIDEO_BYTES,
+  FALLBACK_CONTEXT_WINDOW,
+  LOCAL_API_KEY_PLACEHOLDER,
+  LOCAL_AUTH_KEY_PREFIX,
   MODELS,
   MOONSHOT_OAUTH_KEY,
   NotLoggedInError,
   SubscriptionUsageError,
   TelegramBot,
   XIAOMI_CREDITS_KEY,
+  clearLocalDiscoveryCache,
+  clearRuntimeModels,
   closeLogger,
   createAutoUpdater,
   decodeOggOpus,
+  discoverLocalModels,
   downmixToMono,
+  endpointRoot,
   fetchSubscriptionUsage,
+  findProbedModel,
+  formatLocalModelId,
   generatePKCE,
+  getAllModels,
   getAppPaths,
   getAuthStorageKey,
   getAuthStorageKeys,
@@ -877,25 +1150,31 @@ export {
   getToolResultCharLimit,
   getVideoByteLimit,
   isKimiCodingEndpoint,
+  isLocalModelId,
   isLoggerOpen,
   isModelLoaded,
   isThinkingLevelSupported,
   kimiCodeBaseUrl,
   kimiCodingHeaders,
+  localAuthStorageKey,
   log,
   loginAnthropic,
   loginGemini,
   loginKimi,
   loginOpenAI,
   openLog,
+  parseLocalModelId,
+  probeEndpoint,
   readStoredBaseUrlSync,
   refreshAnthropicToken,
   refreshGeminiToken,
   refreshKimiToken,
   refreshOpenAIToken,
   registerLogCleanup,
+  registerRuntimeModels,
   resample,
   setProgressCallback,
+  toModelInfo,
   transcribeVoice,
   usesOpenAICodexTransport,
   withFileLock