@kenkaiiii/gg-core 5.24.0 → 5.26.0

package/dist/index.cjs

@@ -31,19 +31,30 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AuthStorage: () => AuthStorage,
+  DEFAULT_LOCAL_ENDPOINTS: () => DEFAULT_LOCAL_ENDPOINTS,
   DEFAULT_MAX_VIDEO_BYTES: () => DEFAULT_MAX_VIDEO_BYTES,
+  FALLBACK_CONTEXT_WINDOW: () => FALLBACK_CONTEXT_WINDOW,
+  LOCAL_API_KEY_PLACEHOLDER: () => LOCAL_API_KEY_PLACEHOLDER,
+  LOCAL_AUTH_KEY_PREFIX: () => LOCAL_AUTH_KEY_PREFIX,
   MODELS: () => MODELS,
   MOONSHOT_OAUTH_KEY: () => MOONSHOT_OAUTH_KEY,
   NotLoggedInError: () => NotLoggedInError,
   SubscriptionUsageError: () => SubscriptionUsageError,
   TelegramBot: () => TelegramBot,
   XIAOMI_CREDITS_KEY: () => XIAOMI_CREDITS_KEY,
+  clearLocalDiscoveryCache: () => clearLocalDiscoveryCache,
+  clearRuntimeModels: () => clearRuntimeModels,
   closeLogger: () => closeLogger,
   createAutoUpdater: () => createAutoUpdater,
   decodeOggOpus: () => decodeOggOpus,
+  discoverLocalModels: () => discoverLocalModels,
   downmixToMono: () => downmixToMono,
+  endpointRoot: () => endpointRoot,
   fetchSubscriptionUsage: () => fetchSubscriptionUsage,
+  findProbedModel: () => findProbedModel,
+  formatLocalModelId: () => formatLocalModelId,
   generatePKCE: () => generatePKCE,
+  getAllModels: () => getAllModels,
   getAppPaths: () => getAppPaths,
   getAuthStorageKey: () => getAuthStorageKey,
   getAuthStorageKeys: () => getAuthStorageKeys,
@@ -63,25 +74,31 @@ __export(index_exports, {
   getToolResultCharLimit: () => getToolResultCharLimit,
   getVideoByteLimit: () => getVideoByteLimit,
   isKimiCodingEndpoint: () => isKimiCodingEndpoint,
+  isLocalModelId: () => isLocalModelId,
   isLoggerOpen: () => isLoggerOpen,
   isModelLoaded: () => isModelLoaded,
   isThinkingLevelSupported: () => isThinkingLevelSupported,
   kimiCodeBaseUrl: () => kimiCodeBaseUrl,
   kimiCodingHeaders: () => kimiCodingHeaders,
+  localAuthStorageKey: () => localAuthStorageKey,
   log: () => log,
   loginAnthropic: () => loginAnthropic,
   loginGemini: () => loginGemini,
   loginKimi: () => loginKimi,
   loginOpenAI: () => loginOpenAI,
   openLog: () => openLog,
+  parseLocalModelId: () => parseLocalModelId,
+  probeEndpoint: () => probeEndpoint,
   readStoredBaseUrlSync: () => readStoredBaseUrlSync,
   refreshAnthropicToken: () => refreshAnthropicToken,
   refreshGeminiToken: () => refreshGeminiToken,
   refreshKimiToken: () => refreshKimiToken,
   refreshOpenAIToken: () => refreshOpenAIToken,
   registerLogCleanup: () => registerLogCleanup,
+  registerRuntimeModels: () => registerRuntimeModels,
   resample: () => resample,
   setProgressCallback: () => setProgressCallback,
+  toModelInfo: () => toModelInfo,
   transcribeVoice: () => transcribeVoice,
   usesOpenAICodexTransport: () => usesOpenAICodexTransport,
   withFileLock: () => withFileLock
@@ -1272,6 +1289,8 @@ function isAlive(pid) {
 // src/auth-storage.ts
 var MOONSHOT_OAUTH_KEY = "moonshot-oauth";
 var XIAOMI_CREDITS_KEY = "xiaomi-credits";
+var LOCAL_AUTH_KEY_PREFIX = "local:";
+var LOCAL_CREDENTIAL_LIFETIME_MS = 100 * 365 * 24 * 60 * 60 * 1e3;
 function activeBaseUrlEntry(data, provider) {
   if (provider === "moonshot") {
     const oauth = data[MOONSHOT_OAUTH_KEY];
@@ -1307,7 +1326,9 @@ var STATIC_API_KEY_PROVIDERS = /* @__PURE__ */ new Set([
   "deepseek",
   "openrouter",
   "sakana",
-  "xai"
+  "xai",
+  // Local endpoints: a fixed (usually placeholder) key, never refreshable.
+  "local"
 ]);
 var AuthStorage = class {
   data = {};
@@ -1356,8 +1377,33 @@ var AuthStorage = class {
     if (provider === "xiaomi") {
       return Boolean(this.data["xiaomi"] || this.data[XIAOMI_CREDITS_KEY]);
     }
+    if (provider === "local") {
+      return Object.keys(this.data).some((key) => key.startsWith(LOCAL_AUTH_KEY_PREFIX));
+    }
     return Boolean(this.data[provider]);
   }
+  /** Endpoint ids that currently have a `local:<id>` credential stored. */
+  async listLocalEndpointIds() {
+    await this.ensureLoaded();
+    return Object.keys(this.data).filter((key) => key.startsWith(LOCAL_AUTH_KEY_PREFIX)).map((key) => key.slice(LOCAL_AUTH_KEY_PREFIX.length));
+  }
+  /**
+   * Write (or refresh) the credential for one local endpoint. The `baseUrl` is
+   * what `effectiveBaseUrl` later picks up, and `accessToken` is the endpoint's
+   * key — a placeholder for the servers that ignore it.
+   */
+  async setLocalEndpoint(endpointId, baseUrl, apiKey) {
+    await this.setCredentials(`${LOCAL_AUTH_KEY_PREFIX}${endpointId}`, {
+      accessToken: apiKey && apiKey.length > 0 ? apiKey : "local",
+      refreshToken: "",
+      expiresAt: Date.now() + LOCAL_CREDENTIAL_LIFETIME_MS,
+      baseUrl
+    });
+  }
+  /** Remove one local endpoint's credential. No-op when it isn't stored. */
+  async removeLocalEndpoint(endpointId) {
+    await this.clearCredentials(`${LOCAL_AUTH_KEY_PREFIX}${endpointId}`);
+  }
   /**
    * True if the active credential for `provider` is a static API key with no
    * refresh mechanism. For `moonshot` this is only true when the Kimi OAuth
@@ -2047,14 +2093,30 @@ var MODELS = [
     maxThinkingLevel: "high"
   }
 ];
+var runtimeModels = /* @__PURE__ */ new Map();
+function registerRuntimeModels(models) {
+  for (const model of models) runtimeModels.set(model.id, model);
+}
+function clearRuntimeModels(predicate) {
+  if (!predicate) {
+    runtimeModels.clear();
+    return;
+  }
+  for (const [id, model] of runtimeModels) {
+    if (predicate(model)) runtimeModels.delete(id);
+  }
+}
+function getAllModels() {
+  return [...MODELS, ...runtimeModels.values()];
+}
 function getModel(id) {
-  return MODELS.find((m) => m.id === id);
+  return MODELS.find((m) => m.id === id) ?? runtimeModels.get(id);
 }
 function getModelsForProvider(provider) {
-  return MODELS.filter((m) => m.provider === provider);
+  return getAllModels().filter((m) => m.provider === provider);
 }
 function getAuthStorageKeys(provider, modelId) {
-  const model = MODELS.find((m) => m.id === modelId && m.provider === provider);
+  const model = getAllModels().find((m) => m.id === modelId && m.provider === provider);
   return model?.authStorageKeys ?? [provider];
 }
 function getAuthStorageKey(provider, modelId) {
@@ -2077,8 +2139,23 @@ function getDefaultModel(provider) {
   if (provider === "openrouter") return MODELS.find((m) => m.id === "qwen/qwen3.6-plus");
   if (provider === "sakana") return MODELS.find((m) => m.id === "fugu");
   if (provider === "xai") return MODELS.find((m) => m.id === "grok-4.5");
+  if (provider === "local") {
+    return getModelsForProvider("local")[0] ?? PLACEHOLDER_LOCAL_MODEL;
+  }
   return MODELS.find((m) => m.id === "claude-sonnet-5");
 }
+var PLACEHOLDER_LOCAL_MODEL = {
+  id: "local/none/none",
+  name: "No local model discovered",
+  provider: "local",
+  contextWindow: 8192,
+  maxOutputTokens: 2048,
+  supportsThinking: false,
+  supportsImages: false,
+  supportsVideo: false,
+  costTier: "low",
+  maxThinkingLevel: "high"
+};
 function usesOpenAICodexTransport(options) {
   return options?.provider === "openai" && Boolean(options.accountId);
 }
@@ -2142,6 +2219,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-");
 }
@@ -2161,6 +2239,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;
@@ -2190,7 +2274,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];
   }
@@ -2200,6 +2288,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_MS2 = 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_MS2) {
+    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) {
@@ -2917,19 +3252,30 @@ function createAutoUpdater(config) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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,
@@ -2949,25 +3295,31 @@ function createAutoUpdater(config) {
   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