@gamaze/hicortex 0.16.6 → 0.16.8

package/dist/llm.d.ts

@@ -1,6 +1,9 @@
 /**
  * Multi-provider LLM client for consolidation and distillation.
  *
+ * ONE model serves all phases (distill, reflect, classify, scoring) — #231.
+ * The 0.16.x per-tier split (distill, reflect, classify + base) is removed.
+ *
  * Resolution (resolveExplicitLlmConfig):
  *   1. Explicit config-file overrides (llmBaseUrl + llmApiKey + llmModel)
  *   2. Hicortex-specific env vars (HICORTEX_LLM_BASE_URL + HICORTEX_LLM_API_KEY + HICORTEX_LLM_MODEL)
@@ -17,43 +20,18 @@ export interface LlmConfig {
     baseUrl: string;
     apiKey: string;
     model: string;
-    reflectModel: string;
     provider: string;
-    /** Optional separate model for distillation (defaults to model if unset). */
-    distillModel?: string;
-    /** Optional separate endpoint for distillation (e.g. remote Ollama with larger/faster model). */
-    distillBaseUrl?: string;
-    distillApiKey?: string;
-    distillProvider?: string;
-    /** Max output tokens for all phases (distill/reflect/classify/scoring). Heavy phases fall back to 8192, scoring to 2048. */
+    /** Max output tokens for all phases (one model). Default 8192. */
     maxTokens?: number;
-    /** Toggle thinking on the openai-compat path for the heavy phases. Absent = no kwarg sent. */
+    /** Toggle thinking on the openai-compat path for all phases. Absent = no kwarg sent.
+     *  LOCAL-endpoint only (ollama / mlx-lm gateway); see HicortexConfig.enableThinking. */
     enableThinking?: boolean;
-    /** Context window for the ollama fast tier (completeOllama). Falls back to 2048. */
+    /** Context window for ollama (the one model, all phases). Default 8192. */
     numCtx?: number;
     /** Flush ollama memory every N ollama calls (0 = off). See HicortexConfig.ollamaFlushEvery. */
     ollamaFlushEvery?: number;
     /** Ms to wait after an ollama flush for the runner to release. */
     ollamaFlushWaitMs?: number;
-    /** Optional separate endpoint for reflect-tier LLM (e.g. remote Ollama with larger model). */
-    reflectBaseUrl?: string;
-    reflectApiKey?: string;
-    reflectProvider?: string;
-    /**
-     * Optional separate model for memory tag classification (defaults to the
-     * reflect tier when unset — zero behavior change for existing installs).
-     * Chosen after an A/B benchmark where a dedicated classifier model
-     * materially outperformed the reflect model on this task.
-     */
-    classifyModel?: string;
-    /**
-     * Optional separate endpoint for classification. When only classifyModel is
-     * set, the classify model runs on the reflect endpoint (or the base endpoint
-     * when no reflect endpoint is configured).
-     */
-    classifyBaseUrl?: string;
-    classifyApiKey?: string;
-    classifyProvider?: string;
 }
 /**
  * Resolve LLM configuration from explicit config-file overrides or
@@ -71,45 +49,26 @@ export declare function resolveExplicitLlmConfig(overrides?: {
     llmBaseUrl?: string;
     llmApiKey?: string;
     llmModel?: string;
-    reflectModel?: string;
 }): LlmConfig | null;
 /**
  * @deprecated Use resolveExplicitLlmConfig. This alias exists only to ease
  * the transition for any lingering call sites — remove after 0.10.0 ships.
  */
 export declare const resolveLlmConfigForCC: typeof resolveExplicitLlmConfig;
-export type { ModelTierOverride } from "./types.js";
-/**
- * Normalize a nested `models: { <tier>: {model,baseUrl,apiKey,provider} }` block
- * onto the flat `llm*` / `distill*` / `reflect*` / `classify*` keys the resolver
- * already consumes. Nested overrides WIN over any flat key of the same name; every
- * non-mapped key (llmBackend, licenseKey, distillFallback, contextClients, …)
- * is preserved via spread. Pure: returns the SAME reference when there is no
- * `models` key, so this is a provable no-op for every existing install.
- *
- * Robust to a malformed config.json: a config that parses to a scalar, array,
- * or null is returned untouched (matching the pre-0.13.1 optional-chaining
- * tolerance — this function must never throw at server/nightly boot).
- *
- * Fail-explicit (warn + skip, never throw): an invalid `models` value, an
- * unknown tier name, a non-object tier value, a non-string field value, a tier
- * apiKey/provider set without a baseUrl (they are baseUrl-gated downstream), and
- * a dead score apiKey/provider under an ollama base.
- */
-export declare function applyModelsBlock(saved: Record<string, unknown> | null): Record<string, unknown> | null;
 /**
- * Validate + copy the heavy-phase tuning keys (#220: maxTokens + enableThinking)
- * from the saved disk config onto a runtime LlmConfig. Called by BOTH LlmConfig
- * construction sites — the daemon in mcp-server.ts (runs distill) AND
- * resolveSavedLlmConfig below (the nightly runs reflect + classify) — so every
- * process that runs a heavy phase honors the keys, and a future site calling
- * this inherits them by construction.
- *
- * Both keys are optional; absent = call-site defaults (8192 / thinking kwarg
- * omitted). Wrong-typed values warn and are dropped (readPositiveConfig /
- * readStrictBoolean) — notably a JSON slip `"enableThinking": "false"` (string)
- * is rejected rather than coerced to truthy thinking-on, which would silently
- * invert the fix this key exists to apply.
+ * Validate + copy the tuning keys (#220: maxTokens + enableThinking + numCtx +
+ * ollama flush) from the saved disk config onto a runtime LlmConfig. Called by
+ * BOTH LlmConfig construction sites — the daemon in mcp-server.ts (runs
+ * distill) AND resolveSavedLlmConfig below (the nightly runs reflect +
+ * classify) — so every process honors the keys, and a future site calling this
+ * inherits them by construction.
+ *
+ * All keys are optional; absent = call-site defaults (maxTokens 8192, numCtx
+ * 8192, thinking kwarg omitted, flush off). Wrong-typed values warn and are
+ * dropped (readPositiveConfig / readStrictBoolean / readNonNegativeConfig) —
+ * notably a JSON slip `"enableThinking": "false"` (string) is rejected rather
+ * than coerced to truthy thinking-on, which would silently invert the fix this
+ * key exists to apply.
  */
 export declare function applyTierTuningOverlay(llmConfig: LlmConfig, savedConfig: Record<string, unknown> | null | undefined): void;
 /**
@@ -117,9 +76,8 @@ export declare function applyTierTuningOverlay(llmConfig: LlmConfig, savedConfig
  *
  * This is the SINGLE config path used by pipeline runs (nightly consolidation
  * and `hicortex relink`): named backends (claude-cli, ollama) first, then the
- * explicit-config/env fallthrough via resolveExplicitLlmConfig, then the
- * reflect endpoint overlay. Extracted verbatim from nightly.ts — behavior
- * is identical to the pre-0.11 inline block.
+ * explicit-config/env fallthrough via resolveExplicitLlmConfig. One model
+ * serves all phases (#231) — there is no per-tier overlay here.
  *
  * Returns `reason: "claude_binary_missing"` when claude-cli is configured but
  * the binary can't be found, so callers can log a context-specific message.
@@ -132,30 +90,6 @@ export declare function resolveSavedLlmConfig(savedConfig: Record<string, unknow
     config: LlmConfig | null;
     reason?: "claude_binary_missing";
 };
-/**
- * Endpoint + model that memory tag classification will ACTUALLY use, for
- * pre-flight probing. Pure function — the single source of truth shared by
- * the nightly's contentDomainsReady gate and `hicortex classify-domains`.
- *
- * Mirrors LlmClient.completeClassify's routing:
- *   - classify tier configured (classifyModel and/or classifyBaseUrl) →
- *     classifyBaseUrl ?? reflectBaseUrl, classifyModel ?? reflectModel
- *   - classify tier absent → the reflect tier (reflectBaseUrl/reflectModel),
- *     exactly what completeReflect uses
- *
- * Returns null when no probe applies: only a SEPARATE Ollama endpoint can go
- * unreachable mid-run (API providers are cloud-reachable; the base endpoint
- * is not pre-flighted anywhere, matching distill/reflect behavior).
- *
- * `tier` tells callers which configuration produced the target — "reflect"
- * means the classification probe is identical to the reflect-stage probe and
- * its result can be reused.
- */
-export declare function resolveClassifyProbeTarget(config: LlmConfig): {
-    tier: "classify" | "reflect";
-    baseUrl: string;
-    model: string;
-} | null;
 /**
  * Find the claude CLI binary. Returns the full path or null.
  */
@@ -170,46 +104,6 @@ export declare function claudeCliConfig(claudePath: string): LlmConfig;
  * Returns the model name if available, null otherwise.
  */
 export declare function probeOllama(baseUrl?: string): Promise<string | null>;
-/**
- * Pre-flight health check for a specific Ollama endpoint + model.
- * Returns { ok, reason } so callers can log a clear abort message.
- *
- *   - `ok: true` — endpoint reachable AND the requested model appears in
- *     `/api/tags`. Safe to proceed with a batch distillation run.
- *   - `ok: false, reason: "unreachable"` — network failure or non-2xx.
- *   - `ok: false, reason: "model_missing"` — endpoint is up but the
- *     model isn't listed (the exact case that caused data loss when
- *     a remote Ollama box didn't have the distill model loaded).
- *
- * Matches on exact name OR name prefix ("qwen3.5:35b" matches "qwen3.5:35b-a3b").
- */
-export declare function probeOllamaModel(baseUrl: string, modelName: string): Promise<{
-    ok: true;
-} | {
-    ok: false;
-    reason: "unreachable" | "model_missing";
-}>;
-/**
- * Resolve the distillation endpoint before a /distill request.
- *
- * @param config  LlmConfig (mutated in "local" mode when fallback is used)
- * @param mode
- *   "strict" (default) — when a separate distillBaseUrl is configured and its
- *     Ollama probe fails, return "abort" immediately WITHOUT mutating config.
- *     The session is not distilled now; the nightly watermark is not advanced,
- *     so the session is re-shipped on the next run (harness stores retain raw
- *     for 30–90 days — the retry IS the queue). Prefer this to producing
- *     low-quality memories from a weak fallback model.
- *   "local" — legacy 0.9.0 behaviour: fall back to the base endpoint (local
- *     Ollama or API provider) when the remote is down. Mutates config IN PLACE
- *     to repoint distill* at the fallback.
- *
- * Returns:
- *   "ok"       — remote distill endpoint healthy, or no separate endpoint set
- *   "fellback" — ("local" mode only) remote down; distill redirected to base
- *   "abort"    — remote down and fallback not allowed (strict) or both down (local)
- */
-export declare function resolveDistillFallback(config: LlmConfig, mode?: "strict" | "local"): Promise<"ok" | "fellback" | "abort">;
 export declare class RateLimitError extends Error {
     retryAfterMs: number;
     constructor(retryAfterMs: number);
@@ -225,36 +119,28 @@ export declare class LlmClient {
     get isRateLimited(): boolean;
     private handleRateLimit;
     /**
-     * Fast-tier completion (importance scoring, simple tasks).
+     * Fast-tier completion (importance scoring, simple tasks). One model serves
+     * all phases (#231); numCtx + enableThinking are read from config directly
+     * inside completeOnce's per-provider dispatch, not threaded here. The periodic
+     * ollama flush stays (provider-gated) — it is a scoring-call-count cadence and
+     * scoring is the highest-frequency call, so this is where the flush belongs.
      */
     completeFast(prompt: string, maxTokens?: number): Promise<string>;
     /**
-     * Reflect-tier completion (nightly reflection, needs reasoning).
-     * Routes to reflectBaseUrl/reflectProvider if configured (e.g. remote Ollama with larger model).
+     * Reflect-tier completion (nightly reflection). One model serves all phases
+     * (#231) — this is a thin wrapper kept for call-site readability.
      */
     completeReflect(prompt: string, maxTokens?: number): Promise<string>;
     /**
-     * Distillation-tier completion (session knowledge extraction).
-     * Routes to distillBaseUrl/distillProvider if configured (e.g. remote Ollama with faster model).
+     * Distillation-tier completion (session knowledge extraction). One model
+     * serves all phases (#231) — thin wrapper kept for call-site readability.
      */
     completeDistill(prompt: string, maxTokens?: number): Promise<string>;
     /**
-     * Classification-tier completion (memory tag classification).
-     *
-     * Routing (same "optional dedicated model+baseUrl with fallback" pattern as
-     * completeDistill; Ollama calls inherit think:false via completeOllama):
-     *   - Neither classifyModel nor classifyBaseUrl set → delegate to
-     *     completeReflect (exactly the pre-classify-tier behavior).
-     *   - classifyBaseUrl set → that endpoint, model classifyModel ?? reflectModel.
-     *   - Only classifyModel set → the classify model on the reflect endpoint
-     *     when one is configured, else on the base endpoint.
+     * Classification-tier completion (memory tag classification). One model
+     * serves all phases (#231) — thin wrapper kept for call-site readability.
      */
     completeClassify(prompt: string, maxTokens?: number): Promise<string>;
-    /**
-     * Complete with overridden baseUrl/apiKey/provider (used for reflect tier with separate endpoint).
-     * Creates a temporary LlmClient to avoid mutating shared config under concurrent calls.
-     */
-    private completeWithOverride;
     private complete;
     private completeOnce;
     /**
@@ -264,6 +150,7 @@ export declare class LlmClient {
     private completeClaude;
     /**
      * Ollama: use /api/generate with think:false (important for qwen3.5 models).
+     * num_ctx is read from config (one value, all phases — #231; default 8192).
      */
     private completeOllama;
     /**
@@ -271,7 +158,9 @@ export declare class LlmClient {
      * runner exits + releases its per-request RSS growth, then wait for the release
      * before the next call reloads fresh. The runner takes >90 s to exit after
      * keep_alive:0 (measured), so the wait is generous (ollamaFlushWaitMs, default
-     * 180 s). Best-effort — a flush failure just means no release this cycle.
+     * 180 s). Logs the flush so the wait is distinguishable from a hang. If the
+     * unload request fails (ollama down), the wait is skipped — no dead time for a
+     * release that can't have happened. See #229 review.
      */
     private flushOllama;
     /**
@@ -281,6 +170,7 @@ export declare class LlmClient {
     private completeAnthropic;
     /**
      * OpenAI-compatible /v1/chat/completions (works for OpenAI, OpenRouter, etc).
+     * enableThinking is read from config here (one value, all phases — #231).
      */
     private completeOpenAiCompat;
 }