chore: bump version to 2.80.27 and update core features

src/lmstudio/lifecycleManager.ts

@@ -1,6 +1,7 @@
 import type { ILMStudioClient } from './client';
 import type { IActivityTracker } from './activityTracker';
 import type { EngineKind } from '../utils';
+import type { ISystemSpecsProvider, IModelMemoryEstimator } from '../system/specs';
 import { logError, logInfo } from '../utils';
 
 export type LifecycleState = 'idle' | 'loading' | 'loaded' | 'streaming' | 'unloading';
@@ -19,6 +20,15 @@ export interface LifecycleManagerDeps {
     switchDebounceMs?: number;
     /** Initial engine. Default 'lmstudio'. */
     initialEngine?: EngineKind;
+    /**
+     * Optional pre-load memory budget check. When both are provided, a warn-only
+     * advisory is emitted via `notifyError` (and a structured log line) before
+     * attempting to load a model that the heuristic predicts will not fit.
+     * The load is **not** blocked — the user may have a quantization the
+     * estimator does not recognize.
+     */
+    systemSpecs?: ISystemSpecsProvider;
+    memoryEstimator?: IModelMemoryEstimator;
 }
 
 export class ModelLifecycleManager {
@@ -207,6 +217,38 @@ export class ModelLifecycleManager {
         }
     }
 
+    /**
+     * Warn-only RAM budget check. If the heuristic estimator says the model is
+     * unlikely to fit, surface a non-blocking advisory and log it. The load
+     * still proceeds — the heuristic can be wrong (unrecognized quantization,
+     * sparse / MoE models) and the user may have explicit intent.
+     */
+    private checkMemoryBudget(modelKey: string): void {
+        const specsProvider = this.deps.systemSpecs;
+        const estimator = this.deps.memoryEstimator;
+        if (!specsProvider || !estimator) return;
+        try {
+            const specs = specsProvider.get();
+            const requiredGB = estimator.estimate(modelKey);
+            if (requiredGB > specs.safeModelBudgetGB) {
+                const msg =
+                    `Model "${modelKey}" estimated at ~${requiredGB.toFixed(1)}GB ` +
+                    `exceeds your safe RAM budget of ${specs.safeModelBudgetGB}GB. ` +
+                    `If load fails, try a smaller quantization (q4 / q5).`;
+                logInfo('LM Studio pre-load memory advisory.', {
+                    model: modelKey,
+                    requiredGB: Number(requiredGB.toFixed(2)),
+                    budgetGB: specs.safeModelBudgetGB,
+                    totalRamGB: Number(specs.totalRamGB.toFixed(2)),
+                });
+                this.deps.notifyError?.(msg);
+            }
+        } catch (e: any) {
+            // Diagnostic-only; never block a load on advisory failures.
+            logError('Memory budget check failed.', { error: e?.message ?? String(e) });
+        }
+    }
+
     private async doSwitch(modelKey: string): Promise<void> {
         if (this.disposed) return;
         if (this.engine !== 'lmstudio') return;
@@ -225,6 +267,8 @@ export class ModelLifecycleManager {
             this.currentModel = null;
         }
 
+        this.checkMemoryBudget(modelKey);
+
         this.state = 'loading';
         this.currentModel = modelKey;
         const ac = new AbortController();