@remnic/core 9.69.39 → 9.69.40

package/dist/intent.d.ts

@@ -1,4 +1,4 @@
-import { aB as MemoryIntent, R as RecallPlanMode } from './types-Cyr32ABj.js';
+import { aB as MemoryIntent, R as RecallPlanMode } from './types-nJV23pa3.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/lcm/engine.d.ts

@@ -2,7 +2,7 @@ import { LcmStructuredRecallMatch, LcmMessage } from './archive.js';
 import { SummarizeFn } from '../context-summary.js';
 import { LcmRecallWithTraceResult } from './recall.js';
 import { LcmObserveMessage } from './queue.js';
-import { P as PluginConfig } from '../types-Cyr32ABj.js';
+import { P as PluginConfig } from '../types-nJV23pa3.js';
 import 'better-sqlite3';
 import '../message-parts/index.js';
 import '../token-estimate.js';

package/dist/lcm/index.d.ts

@@ -8,7 +8,7 @@ export { ensureLcmStateDir, openLcmDatabase } from './schema.js';
 export { SummarizeFn } from '../context-summary.js';
 import './queue.js';
 import '../message-parts/index.js';
-import '../types-Cyr32ABj.js';
+import '../types-nJV23pa3.js';
 import '../bounded-jsonl-state.js';
 import '../operator-doctor-types.js';
 import '../external-wiki-config.js';

package/dist/lcm/index.js

@@ -1,4 +1,7 @@
 import "../chunk-VDC6RZI4.js";
+import {
+  registerLcmTools
+} from "../chunk-UWK5OXUJ.js";
 import {
   LcmEngine,
   extractLcmConfig
@@ -18,9 +21,6 @@ import {
 import {
   LcmSummarizer
 } from "../chunk-KOLJJN5G.js";
-import {
-  registerLcmTools
-} from "../chunk-UWK5OXUJ.js";
 import {
   LcmArchive,
   estimateTokens

package/dist/lcm/tools.d.ts

@@ -7,7 +7,7 @@ import '../context-summary.js';
 import './recall.js';
 import './dag.js';
 import './queue.js';
-import '../types-Cyr32ABj.js';
+import '../types-nJV23pa3.js';
 import '../bounded-jsonl-state.js';
 import '../operator-doctor-types.js';
 import '../external-wiki-config.js';

package/dist/lifecycle.d.ts

@@ -1,4 +1,4 @@
-import { W as LifecycleState, u as MemoryCategory, M as MemoryFile, m as MemoryFrontmatter } from './types-Cyr32ABj.js';
+import { X as LifecycleState, u as MemoryCategory, M as MemoryFile, m as MemoryFrontmatter } from './types-nJV23pa3.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/live-connectors-runner.d.ts

@@ -1,5 +1,5 @@
 import { L as LiveConnector, C as ConnectorConfig, a as ConnectorDocument } from './framework-CNDn2164.js';
-import { L as LiveConnectorsConfig } from './types-Cyr32ABj.js';
+import { L as LiveConnectorsConfig } from './types-nJV23pa3.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/local-llm-BsJGulur.d.ts

@@ -0,0 +1,247 @@
+import { P as PluginConfig } from './types-nJV23pa3.js';
+import { ModelRegistry } from './model-registry.js';
+
+interface LocalLlmChatCompletionOptions {
+    temperature?: number;
+    maxTokens?: number;
+    responseFormat?: {
+        type: string;
+    };
+    timeoutMs?: number;
+    operation?: string;
+    forceDisableThinking?: boolean;
+    disableThinking?: boolean;
+    priority?: LocalLlmRequestPriority;
+    signal?: AbortSignal;
+    redactProviderErrors?: boolean;
+    /** Per-request model; defaults to config.localLlmModel. */
+    model?: string;
+    /**
+     * Optional out-box for the terminal failure cause (issue #2891): on a
+     * failed request the client records the last provider error here so
+     * callers can classify it (e.g. HTTP 429 → rate-limited) in memory
+     * instead of seeing only null. Never logged.
+     */
+    failureDiag?: {
+        lastError?: unknown;
+    };
+}
+interface LocalLlmChatCompletionResult {
+    content: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+declare function isAbortError(err: unknown): boolean;
+declare function waitForRetryBackoff(backoffMs: number, signal?: AbortSignal): Promise<boolean>;
+declare function normalizeBackendTripReason(reason: string): string;
+declare function extractNonRecoverableBackendReason(reason: string): string | null;
+declare function extractNonRecoverableBackendReasonFromErrorText(errorText: string): string | null;
+/**
+ * Flatten a fetch rejection into one line, including the `cause` undici hides
+ * the real reason behind (`fetch failed` alone says nothing).
+ */
+declare function describeFetchFailure(err: unknown): string;
+/**
+ * What to record when every availability probe failed.
+ *
+ * A probe that TIMED OUT is not evidence the backend is down: the budget is a
+ * fixed 2s and a busy event loop can burn it before the socket is scheduled,
+ * so the backend looks dead while it answers other callers in single-digit ms.
+ * Caching that verdict took extraction offline for a whole health-check
+ * interval at a time (issue #2210), so a timeout leaves availability UNKNOWN —
+ * this call fails, the next one re-probes instead of reading a stale false.
+ *
+ * A backend that ANSWERED and said no is a real verdict and stays cached, or
+ * the daemon re-probes a known-bad endpoint on every request.
+ */
+declare function resolveUnavailableVerdict(args: {
+    baseUrl: string;
+    sawAbortedProbe: boolean;
+    wasAvailable: boolean | null;
+}): {
+    cacheVerdict: boolean;
+    warning: string | null;
+};
+interface ProbeFetchResult {
+    ok: boolean;
+    data: unknown;
+    status: number | null;
+    /** The probe hit its own budget rather than getting an answer. */
+    aborted?: boolean;
+}
+/**
+ * One health-probe request.
+ *
+ * Every failure is logged with its cause: a transport error and a 404 both
+ * returned `ok: false` with nothing recorded, so an unreachable backend was
+ * indistinguishable from a wrong path and an availability failure had no
+ * diagnosable reason at all (§22, issue #2210).
+ */
+declare function probeFetch(url: string, options: {
+    timeoutMs: number;
+    headers: Record<string, string>;
+    signal?: AbortSignal;
+}): Promise<ProbeFetchResult>;
+/**
+ * Collapses concurrent probe sequences onto one in-flight run.
+ *
+ * A timed-out availability probe deliberately caches nothing (issue #2210),
+ * which removed the false verdict that used to absorb concurrent callers:
+ * every queued request would then run its own full probe sequence, on a host
+ * already slow enough to blow the probe budget.
+ *
+ * Cancellation is refcounted rather than shared: one caller walking away must
+ * not abort a sequence the others are still waiting on, so the underlying task
+ * is aborted only once every waiter has gone.
+ */
+declare class SingleFlightProbe {
+    private pending;
+    run(task: (signal: AbortSignal) => Promise<boolean>, signal?: AbortSignal): Promise<boolean>;
+}
+
+/**
+ * Local LLM client for OpenAI-compatible endpoints (LM Studio, Ollama, MLX, etc.)
+ *
+ * Based on openclaw-tactician's provider detection patterns for consistency.
+ * Provides privacy-preserving, cost-effective LLM operations with
+ * graceful fallback to cloud providers when local LLM is unavailable.
+ */
+type LocalLlmType = "lmstudio" | "ollama" | "mlx" | "vllm" | "llamacpp" | "generic";
+interface LocalModelInfo {
+    id: string;
+    contextWindow?: number;
+    maxTokens?: number;
+}
+type LocalLlmRequestPriority = "recall-critical" | "background";
+declare class LocalLlmClient {
+    private config;
+    private isAvailable;
+    private lastHealthCheck;
+    private readonly availabilityProbe;
+    private detectedType;
+    private cachedModelInfo;
+    private cachedLmsContext;
+    private lastLmsCheck;
+    private consecutive400s;
+    private cooldownUntilMs;
+    private modelRegistry?;
+    private _disableThinking;
+    private readonly requestQueues;
+    private readonly queueProcessing;
+    private queueDrainScheduled;
+    private static readonly HEALTH_CHECK_INTERVAL_MS;
+    private static readonly LMS_CACHE_INTERVAL_MS;
+    private readonly chatTransport;
+    constructor(config: PluginConfig, modelRegistry?: ModelRegistry);
+    /**
+     * Request thinking/reasoning suppression on the next chat completion.
+     *
+     * When `true`, the client will inject
+     * `chat_template_kwargs: { enable_thinking: false }` into the request
+     * body — **but only when the detected backend is known to support it**
+     * (LM Studio, vLLM; see `THINKING_COMPATIBLE_BACKENDS`).  Strict
+     * OpenAI-compat backends reject unknown fields with 400; on those the
+     * client fails open (thinking runs normally).  This is the safe
+     * default for Remnic extraction-style operations: measurable latency
+     * win on thinking-capable backends, zero risk on others. Consolidation
+     * operations keep thinking enabled unless explicitly added to
+     * `THINKING_SUPPRESSED_OPERATIONS`. Issues #548 and #979.
+     */
+    set disableThinking(value: boolean);
+    private resolveHomeDir;
+    private buildRequestHeaders;
+    /**
+     * Set the ModelRegistry for caching detected capabilities
+     */
+    setModelRegistry(registry: ModelRegistry): void;
+    /**
+     * Get the detected server type (null if not detected)
+     */
+    getDetectedType(): LocalLlmType | null;
+    private getBackendKey;
+    private getGlobalBackendState;
+    private getTrippedBackendState;
+    private markBackendUnavailable;
+    /**
+     * Fetch with timeout for health checks. Body lives in the sibling helper so
+     * this file stays under its size ceiling (issue #1995).
+     */
+    private fetchWithTimeout;
+    private probeLmStudioNativeModels;
+    /**
+     * Check if local LLM is available
+     * Uses 127.0.0.1 instead of localhost to avoid DNS issues (consistent with tactician)
+     */
+    checkAvailability(signal?: AbortSignal): Promise<boolean>;
+    private probeAvailability;
+    /**
+     * Try to get context window from LM Studio settings.json as fallback.
+     * This reads the defaultContextLength setting which is what LM Studio uses
+     * when loading models without explicit context configuration.
+     */
+    private getContextFromLmStudioSettings;
+    /**
+     * Try to get context window from LMS CLI (LM Studio specific).
+     * Uses --json flag for reliable parsing.
+     * Returns null if LMS CLI is not available or model not found.
+     */
+    private getContextFromLmsCli;
+    /**
+     * Get full model info from LMS CLI including context length and max context length.
+     * Returns null if LMS CLI is unavailable or model not found.
+     */
+    private getLmsModelInfo;
+    /**
+     * Get context window for the configured model, using cache if available.
+     * This method caches the result to avoid repeated LMS CLI calls.
+     * Order: ModelRegistry (persistent) -> memory cache -> LMS CLI -> settings.json
+     */
+    getCachedContextWindow(modelId: string): number | null;
+    /**
+     * Clear the LMS context cache. Call this when the model changes.
+     */
+    clearContextCache(): void;
+    private remainingCooldownMs;
+    private scheduleQueueDrain;
+    /** True when a background-priority request occupies or awaits this client's local lane (issue #2011). */
+    isBackgroundLaneContended(): boolean;
+    private dequeueQueuedRequest;
+    private failOpenQueuedRequestsForCooldown;
+    private startAvailableQueuedRequests;
+    private runQueuedRequest;
+    private runChatCompletionRequest;
+    /**
+     * Query the local LLM server for loaded model information.
+     * Returns null if unavailable or if the model is not found.
+     */
+    getLoadedModelInfo(): Promise<LocalModelInfo | null>;
+    /**
+     * Check if the configured model is available and get its actual context window.
+     * Warns if there's a mismatch between expected and actual context.
+     */
+    validateModelConfig(expectedContextWindow?: number): Promise<{
+        available: boolean;
+        actualContextWindow?: number;
+        warnings: string[];
+    }>;
+    /**
+     * Make a chat completion request to local LLM
+     */
+    chatCompletion(messages: Array<{
+        role: string;
+        content: string;
+    }>, options?: LocalLlmChatCompletionOptions): Promise<LocalLlmChatCompletionResult | null>;
+    /**
+     * Estimate tokens when local LLM does not return usage stats.
+     */
+    private estimateTokens;
+    /**
+     * Try local LLM first, fallback to cloud provider if configured
+     */
+    withFallback<T>(localOperation: () => Promise<T | null>, fallbackOperation: () => Promise<T>, operationName: string): Promise<T>;
+}
+
+export { LocalLlmClient as L, type ProbeFetchResult as P, SingleFlightProbe as S, type LocalLlmChatCompletionOptions as a, type LocalLlmChatCompletionResult as b, extractNonRecoverableBackendReasonFromErrorText as c, describeFetchFailure as d, extractNonRecoverableBackendReason as e, type LocalLlmRequestPriority as f, type LocalLlmType as g, type LocalModelInfo as h, isAbortError as i, normalizeBackendTripReason as n, probeFetch as p, resolveUnavailableVerdict as r, waitForRetryBackoff as w };

package/dist/local-llm-config.d.ts

@@ -13,14 +13,17 @@ interface LocalLlmConfig {
     /** If false, do not send Authorization header even when localLlmApiKey is set. */
     localLlmAuthHeader: boolean;
     localLlmFallback: boolean;
+    taskLlmFallback?: boolean;
     /** Optional home directory override for local LLM helpers (LM Studio settings, CLI PATH). */
     localLlmHomeDir?: string;
     /** Optional absolute path to LMS CLI binary (preferred over auto-detection). */
     localLmsCliPath?: string;
     /** Optional bin directory prepended to PATH for LMS CLI execution. */
     localLmsBinDir?: string;
-    /** Hard timeout for local LLM and gateway fallback requests (ms). */
+    /** Hard timeout for local LLM requests (ms). Legacy alias for the task-chain timeout when `taskLlmTimeoutMs` is absent. */
     localLlmTimeoutMs: number;
+    /** Timeout for the gateway/task LLM chain (ms). */
+    taskLlmTimeoutMs?: number;
     /** Max context window for local LLM (override auto-detection). Set lower if your LLM server defaults to smaller contexts. */
     localLlmMaxContext?: number;
 }

package/dist/local-llm-config.js

@@ -1,9 +1,11 @@
 import {
   parseLocalLlmConfig
-} from "./chunk-6H2G7RFT.js";
-import "./chunk-YFTNZMGR.js";
+} from "./chunk-VNQRRUNS.js";
+import "./chunk-SK7D34OL.js";
+import "./chunk-27NO2KVB.js";
 import "./chunk-C5C7IJ4Q.js";
 import "./chunk-PQVCH2AE.js";
+import "./chunk-6KH5NLQS.js";
 import "./chunk-P2QRMMVQ.js";
 import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";

package/dist/local-llm-helpers.d.ts

@@ -1,69 +1,18 @@
-declare function isAbortError(err: unknown): boolean;
-declare function waitForRetryBackoff(backoffMs: number, signal?: AbortSignal): Promise<boolean>;
-declare function normalizeBackendTripReason(reason: string): string;
-declare function extractNonRecoverableBackendReason(reason: string): string | null;
-declare function extractNonRecoverableBackendReasonFromErrorText(errorText: string): string | null;
-/**
- * Flatten a fetch rejection into one line, including the `cause` undici hides
- * the real reason behind (`fetch failed` alone says nothing).
- */
-declare function describeFetchFailure(err: unknown): string;
-/**
- * What to record when every availability probe failed.
- *
- * A probe that TIMED OUT is not evidence the backend is down: the budget is a
- * fixed 2s and a busy event loop can burn it before the socket is scheduled,
- * so the backend looks dead while it answers other callers in single-digit ms.
- * Caching that verdict took extraction offline for a whole health-check
- * interval at a time (issue #2210), so a timeout leaves availability UNKNOWN —
- * this call fails, the next one re-probes instead of reading a stale false.
- *
- * A backend that ANSWERED and said no is a real verdict and stays cached, or
- * the daemon re-probes a known-bad endpoint on every request.
- */
-declare function resolveUnavailableVerdict(args: {
-    baseUrl: string;
-    sawAbortedProbe: boolean;
-    wasAvailable: boolean | null;
-}): {
-    cacheVerdict: boolean;
-    warning: string | null;
-};
-interface ProbeFetchResult {
-    ok: boolean;
-    data: unknown;
-    status: number | null;
-    /** The probe hit its own budget rather than getting an answer. */
-    aborted?: boolean;
-}
-/**
- * One health-probe request.
- *
- * Every failure is logged with its cause: a transport error and a 404 both
- * returned `ok: false` with nothing recorded, so an unreachable backend was
- * indistinguishable from a wrong path and an availability failure had no
- * diagnosable reason at all (§22, issue #2210).
- */
-declare function probeFetch(url: string, options: {
-    timeoutMs: number;
-    headers: Record<string, string>;
-    signal?: AbortSignal;
-}): Promise<ProbeFetchResult>;
-/**
- * Collapses concurrent probe sequences onto one in-flight run.
- *
- * A timed-out availability probe deliberately caches nothing (issue #2210),
- * which removed the false verdict that used to absorb concurrent callers:
- * every queued request would then run its own full probe sequence, on a host
- * already slow enough to blow the probe budget.
- *
- * Cancellation is refcounted rather than shared: one caller walking away must
- * not abort a sequence the others are still waiting on, so the underlying task
- * is aborted only once every waiter has gone.
- */
-declare class SingleFlightProbe {
-    private pending;
-    run(task: (signal: AbortSignal) => Promise<boolean>, signal?: AbortSignal): Promise<boolean>;
-}
-
-export { type ProbeFetchResult, SingleFlightProbe, describeFetchFailure, extractNonRecoverableBackendReason, extractNonRecoverableBackendReasonFromErrorText, isAbortError, normalizeBackendTripReason, probeFetch, resolveUnavailableVerdict, waitForRetryBackoff };
+export { a as LocalLlmChatCompletionOptions, b as LocalLlmChatCompletionResult, P as ProbeFetchResult, S as SingleFlightProbe, d as describeFetchFailure, e as extractNonRecoverableBackendReason, c as extractNonRecoverableBackendReasonFromErrorText, i as isAbortError, n as normalizeBackendTripReason, p as probeFetch, r as resolveUnavailableVerdict, w as waitForRetryBackoff } from './local-llm-BsJGulur.js';
+import './types-nJV23pa3.js';
+import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './operator-doctor-types.js';
+import './external-wiki-config.js';
+import './recall-state-view.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
+import './background-generation-config.js';
+import './deep-recall-config.js';
+import './causal-trajectory.js';
+import './objective-state.js';
+import './active-context-config.js';
+import './local-llm-config.js';
+import './semantic-merge-config.js';
+import './types-continuity.js';
+import './model-registry.js';

package/dist/local-llm-helpers.js

@@ -8,7 +8,7 @@ import {
   probeFetch,
   resolveUnavailableVerdict,
   waitForRetryBackoff
-} from "./chunk-WKDFJXW5.js";
+} from "./chunk-QM2SPLKQ.js";
 import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/local-llm.d.ts

@@ -1,5 +1,6 @@
-import { P as PluginConfig } from './types-Cyr32ABj.js';
-import { ModelRegistry } from './model-registry.js';
+import './types-nJV23pa3.js';
+import './model-registry.js';
+export { L as LocalLlmClient, f as LocalLlmRequestPriority, g as LocalLlmType, h as LocalModelInfo } from './local-llm-BsJGulur.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
@@ -15,171 +16,3 @@ import './active-context-config.js';
 import './local-llm-config.js';
 import './semantic-merge-config.js';
 import './types-continuity.js';
-
-/**
- * Local LLM client for OpenAI-compatible endpoints (LM Studio, Ollama, MLX, etc.)
- *
- * Based on openclaw-tactician's provider detection patterns for consistency.
- * Provides privacy-preserving, cost-effective LLM operations with
- * graceful fallback to cloud providers when local LLM is unavailable.
- */
-type LocalLlmType = "lmstudio" | "ollama" | "mlx" | "vllm" | "llamacpp" | "generic";
-interface LocalModelInfo {
-    id: string;
-    contextWindow?: number;
-    maxTokens?: number;
-}
-type LocalLlmRequestPriority = "recall-critical" | "background";
-interface LocalLlmChatCompletionOptions {
-    temperature?: number;
-    maxTokens?: number;
-    responseFormat?: {
-        type: string;
-    };
-    timeoutMs?: number;
-    operation?: string;
-    forceDisableThinking?: boolean;
-    disableThinking?: boolean;
-    priority?: LocalLlmRequestPriority;
-    signal?: AbortSignal;
-    redactProviderErrors?: boolean;
-    /** Per-request model; defaults to config.localLlmModel. */
-    model?: string;
-}
-interface LocalLlmChatCompletionResult {
-    content: string;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-}
-declare class LocalLlmClient {
-    private config;
-    private isAvailable;
-    private lastHealthCheck;
-    private readonly availabilityProbe;
-    private detectedType;
-    private cachedModelInfo;
-    private cachedLmsContext;
-    private lastLmsCheck;
-    private consecutive400s;
-    private cooldownUntilMs;
-    private modelRegistry?;
-    private _disableThinking;
-    private readonly requestQueues;
-    private readonly queueProcessing;
-    private queueDrainScheduled;
-    private static readonly HEALTH_CHECK_INTERVAL_MS;
-    private static readonly LMS_CACHE_INTERVAL_MS;
-    private readonly chatTransport;
-    constructor(config: PluginConfig, modelRegistry?: ModelRegistry);
-    /**
-     * Request thinking/reasoning suppression on the next chat completion.
-     *
-     * When `true`, the client will inject
-     * `chat_template_kwargs: { enable_thinking: false }` into the request
-     * body — **but only when the detected backend is known to support it**
-     * (LM Studio, vLLM; see `THINKING_COMPATIBLE_BACKENDS`).  Strict
-     * OpenAI-compat backends reject unknown fields with 400; on those the
-     * client fails open (thinking runs normally).  This is the safe
-     * default for Remnic extraction-style operations: measurable latency
-     * win on thinking-capable backends, zero risk on others. Consolidation
-     * operations keep thinking enabled unless explicitly added to
-     * `THINKING_SUPPRESSED_OPERATIONS`. Issues #548 and #979.
-     */
-    set disableThinking(value: boolean);
-    private resolveHomeDir;
-    private buildRequestHeaders;
-    /**
-     * Set the ModelRegistry for caching detected capabilities
-     */
-    setModelRegistry(registry: ModelRegistry): void;
-    /**
-     * Get the detected server type (null if not detected)
-     */
-    getDetectedType(): LocalLlmType | null;
-    private getBackendKey;
-    private getGlobalBackendState;
-    private getTrippedBackendState;
-    private markBackendUnavailable;
-    /**
-     * Fetch with timeout for health checks. Body lives in the sibling helper so
-     * this file stays under its size ceiling (issue #1995).
-     */
-    private fetchWithTimeout;
-    private probeLmStudioNativeModels;
-    /**
-     * Check if local LLM is available
-     * Uses 127.0.0.1 instead of localhost to avoid DNS issues (consistent with tactician)
-     */
-    checkAvailability(signal?: AbortSignal): Promise<boolean>;
-    private probeAvailability;
-    /**
-     * Try to get context window from LM Studio settings.json as fallback.
-     * This reads the defaultContextLength setting which is what LM Studio uses
-     * when loading models without explicit context configuration.
-     */
-    private getContextFromLmStudioSettings;
-    /**
-     * Try to get context window from LMS CLI (LM Studio specific).
-     * Uses --json flag for reliable parsing.
-     * Returns null if LMS CLI is not available or model not found.
-     */
-    private getContextFromLmsCli;
-    /**
-     * Get full model info from LMS CLI including context length and max context length.
-     * Returns null if LMS CLI is unavailable or model not found.
-     */
-    private getLmsModelInfo;
-    /**
-     * Get context window for the configured model, using cache if available.
-     * This method caches the result to avoid repeated LMS CLI calls.
-     * Order: ModelRegistry (persistent) -> memory cache -> LMS CLI -> settings.json
-     */
-    getCachedContextWindow(modelId: string): number | null;
-    /**
-     * Clear the LMS context cache. Call this when the model changes.
-     */
-    clearContextCache(): void;
-    private remainingCooldownMs;
-    private scheduleQueueDrain;
-    /** True when a background-priority request occupies or awaits this client's local lane (issue #2011). */
-    isBackgroundLaneContended(): boolean;
-    private dequeueQueuedRequest;
-    private failOpenQueuedRequestsForCooldown;
-    private startAvailableQueuedRequests;
-    private runQueuedRequest;
-    private runChatCompletionRequest;
-    /**
-     * Query the local LLM server for loaded model information.
-     * Returns null if unavailable or if the model is not found.
-     */
-    getLoadedModelInfo(): Promise<LocalModelInfo | null>;
-    /**
-     * Check if the configured model is available and get its actual context window.
-     * Warns if there's a mismatch between expected and actual context.
-     */
-    validateModelConfig(expectedContextWindow?: number): Promise<{
-        available: boolean;
-        actualContextWindow?: number;
-        warnings: string[];
-    }>;
-    /**
-     * Make a chat completion request to local LLM
-     */
-    chatCompletion(messages: Array<{
-        role: string;
-        content: string;
-    }>, options?: LocalLlmChatCompletionOptions): Promise<LocalLlmChatCompletionResult | null>;
-    /**
-     * Estimate tokens when local LLM does not return usage stats.
-     */
-    private estimateTokens;
-    /**
-     * Try local LLM first, fallback to cloud provider if configured
-     */
-    withFallback<T>(localOperation: () => Promise<T | null>, fallbackOperation: () => Promise<T>, operationName: string): Promise<T>;
-}
-
-export { LocalLlmClient, type LocalLlmRequestPriority, type LocalLlmType, type LocalModelInfo };

package/dist/local-llm.js

@@ -1,7 +1,7 @@
 import {
   LocalLlmClient
-} from "./chunk-MVAQ2WM3.js";
-import "./chunk-WKDFJXW5.js";
+} from "./chunk-G2XZFGYN.js";
+import "./chunk-QM2SPLKQ.js";
 import "./chunk-JUXOTY6J.js";
 import "./chunk-TOTT6S2V.js";
 import "./chunk-JUOZ62Y7.js";

package/dist/local-model-endpoint.d.ts

@@ -1,4 +1,4 @@
-import { P as PluginConfig } from './types-Cyr32ABj.js';
+import { P as PluginConfig } from './types-nJV23pa3.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/location/index.d.ts

@@ -1,6 +1,6 @@
-import { bm as LocationSegment, bn as LocationPlace, bo as LocationConfig, M as MemoryFile, b0 as WearableConversation, P as PluginConfig, bp as LocationProvider, bq as LocationObservation } from '../types-Cyr32ABj.js';
-export { br as LocationObservationPage, bs as LocationProviderCheck, bt as LocationSourceConfig, bu as LocationTaggingConfig } from '../types-Cyr32ABj.js';
-import { S as StorageManager } from '../storage-wvX01lht.js';
+import { bm as LocationSegment, bn as LocationPlace, bo as LocationConfig, M as MemoryFile, b0 as WearableConversation, P as PluginConfig, bp as LocationProvider, bq as LocationObservation } from '../types-nJV23pa3.js';
+export { br as LocationObservationPage, bs as LocationProviderCheck, bt as LocationSourceConfig, bu as LocationTaggingConfig } from '../types-nJV23pa3.js';
+import { S as StorageManager } from '../storage-BprAGBG0.js';
 import '../message-parts/index.js';
 import '../bounded-jsonl-state.js';
 import '../operator-doctor-types.js';