koneck 2.98.0 → 2.100.0

package/dist/engine.js

@@ -17,7 +17,7 @@ import { handoffFrom, describeHandoff, worthSaying } from './handoff.js';
 import { readAll as readLedger, relevant as relevantFindings, withStaleness, describeFindings, deriveFindings, record as recordFindings, changedSince, currentSha } from './ledger.js';
 import { repoNameFor } from './session-bus.js';
 import { compressIfNeeded } from './compressor.js';
-import { contextLimitFor, looksLikeContextOverflow, parseContextLimit, fetchModelContextLimit, ollamaServingLimit, fixedRequestTokens, overheadIsCrowded, crowdedWindowAdvice, probeOllamaContext, detectWindowPlateau, truncationNotice, ollamaWindowFix, runsOnThisMachine, } from './context-limit.js';
+import { contextLimitFor, looksLikeContextOverflow, parseContextLimit, fetchModelContextLimit, ollamaServingLimit, fixedRequestTokens, overheadIsCrowded, crowdedWindowAdvice, probeServedContext, detectWindowPlateau, truncationNotice, windowFixFor, windowSettingIgnored, runsOnThisMachine, } from './context-limit.js';
 import { generateSessionId, saveSession } from './session.js';
 import { EMPTY_PLAN, parsePlan, planReminder, planAck, noPlanReminder } from './plan.js';
 import { spillIfOversized } from './spill.js';
@@ -1143,7 +1143,15 @@ export function emptyResponseAdvice(provider, model, count, toolsWorked, endpoin
  * session with skills loaded is larger again. Quoting a constant is asserting something not
  * known, and it is the number somebody uses to decide what to set the window to.
  */
-fixedTokens, platform) {
+fixedTokens, platform, 
+/**
+ * Which runtime was measured to be serving. Decides which fix is named.
+ *
+ * `served`, not `runtime`: there is already a boolean called that a few lines down, meaning
+ * "is this a thing that serves its own weights at all" — a different question with a confusingly
+ * similar name.
+ */
+served) {
     // The endpoint is named, not just the provider slot. Reported as "omni returned 3 empty
     // responses ... yet i am using ollama" — both true at once, because the endpoint saved under the
     // omni slot is an Ollama box. Naming the address answers the objection in the message itself.
@@ -1175,7 +1183,7 @@ fixedTokens, platform) {
         'truncates a longer prompt instead of refusing it — and KONECK\'s instructions and tool ' +
         `descriptions come to ${cost} before your conversation is counted, which is exactly ` +
         'how a turn comes back with nothing in it.\n\n' +
-        ollamaWindowFix({ ...(endpoint !== undefined ? { endpoint } : {}), remote,
+        windowFixFor(served ?? null, { ...(endpoint !== undefined ? { endpoint } : {}), remote,
             ...(platform !== undefined ? { platform } : {}) }) +
         '\n\nIf you know the real limit, `/config contextTokens <n>` makes KONECK compact before ' +
         'reaching it.';
@@ -1619,6 +1627,9 @@ detectedContext = { current: 0 }) {
                 // sends someone to restart the wrong one.
                 // Loopback means this machine; a LAN address is somebody else's. See runsOnThisMachine.
                 remote: !runsOnThisMachine(resolveProvider(config.provider, config.baseURL).baseURL),
+                // Measured, when it could be: it decides whether the steps name OLLAMA_CONTEXT_LENGTH, -c,
+                // a Context Length slider or --max-model-len.
+                runtime: config.servedRuntime ?? null,
             });
             if (sayOnce) {
                 // One block, in the order somebody reads it: what the window is and whose it is, then what
@@ -1973,6 +1984,7 @@ detectedContext = { current: 0 }) {
                                 // Whether the thing to reconfigure is this machine or another one. KONECK knows its
                                 // own platform and nothing about a remote box, so a remote answer names no commands.
                                 remote: !runsOnThisMachine(endpoint),
+                                runtime: config.servedRuntime ?? null,
                             });
                             config.onTruncation?.(plateau.window, said);
                             if (!silent)
@@ -2487,7 +2499,7 @@ detectedContext = { current: 0 }) {
                 const endpoint = resolveProvider(config.provider, config.baseURL).baseURL;
                 const noRoom = fixedCost > 0 && overheadIsCrowded(fixedCost, effectiveLimit());
                 if (noRoom) {
-                    const notice = deniedBecauseNoRoom(denied, config.model, fixedCost, effectiveLimit(), ollamaWindowFix({ endpoint, remote: !runsOnThisMachine(endpoint) }));
+                    const notice = deniedBecauseNoRoom(denied, config.model, fixedCost, effectiveLimit(), windowFixFor(config.servedRuntime ?? null, { endpoint, remote: !runsOnThisMachine(endpoint) }));
                     config.onFalseDenial?.(denied.map(d => d.what), notice);
                     if (!silent)
                         tui.printWarning(notice);
@@ -2649,7 +2661,7 @@ detectedContext = { current: 0 }) {
                     // likely cause.
                     throw new Error(emptyResponseAdvice(config.provider, config.model, emptyTurns, toolsProvenToWork, resolveProvider(config.provider, config.baseURL).baseURL, 
                     // The floor this run actually has, rather than a constant in a string.
-                    fixedCost));
+                    fixedCost, undefined, config.servedRuntime));
                 }
             }
             else {
@@ -3328,7 +3340,21 @@ initialPlan) {
     // provider slot called "omni" is still served by Ollama, and while this asked about the name
     // that setup got neither the smaller window nor a word of warning.
     const locallyServed = servesLocally(config.provider, resolveProvider(config.provider, config.baseURL).baseURL);
-    if (!config.contextTokens && locallyServed) {
+    /*
+     * The configured window is asked about too, not only an absent one.
+     *
+     * This ran `if (!config.contextTokens)`, so setting the window in KONECK *skipped the
+     * measurement*. Which turns the setting into a trap on exactly the machine that needs it most:
+     * somebody told to raise Ollama's window reads "Context window — the model's context window, when
+     * you know it better than KONECK does", sets 32768 there, and KONECK then believes it and builds
+     * prompts up to 24k. Ollama is still serving 4,096 and still truncates silently, so the result is
+     * worse than before — empty turns, and a model insisting it has no browser.
+     *
+     * A number typed here cannot make a server accept more than it will. So it can lower the limit —
+     * that is a legitimate thing to want, and compaction happens earlier — but never raise it past
+     * what the server reports.
+     */
+    if (locallyServed) {
         // Asked, not assumed. KONECK took Ollama's 4,096 default as fact for anything served locally,
         // so a server running with a larger window was being compacted and trimmed for a limit that
         // did not exist. The objection was fair: nothing should be limited that does not have to be.
@@ -3337,11 +3363,39 @@ initialPlan) {
         // is built — and bounded, so an endpoint that does not answer costs a second rather than a
         // timeout. It is a call to a machine on your own network.
         const endpoint = resolveProvider(config.provider, config.baseURL).baseURL;
-        const probed = await probeOllamaContext(endpoint, config.model);
-        if (probed) {
-            config = { ...config, contextTokens: probed.limit };
+        /*
+         * Every local runtime KONECK recognises, not only Ollama.
+         *
+         * Eleven count as serving their own weights and exactly one of them was ever measured, so
+         * llama.cpp on `-c 2048` or LM Studio with a small slider got no window at all — the plateau
+         * detector eventually notices, but only after three turns, and everything before that fails the
+         * same silent way. The provider name is a hint about which endpoint to try first and nothing
+         * more: a declared provider called "omni" pointing at an Ollama box is Ollama.
+         */
+        const probed = await probeServedContext(endpoint, config.model, { hint: config.provider });
+        const asked = config.contextTokens ?? 0;
+        if (probed && asked > 0 && probed.limit >= asked) {
+            // A deliberate, smaller budget. Kept: nothing about it can fail, and earlier compaction is a
+            // reasonable thing to choose.
+            config.onWindowDetected?.(asked, 'your setting, within the server\'s ' + probed.limit);
+        }
+        else if (probed && asked > 0) {
+            config = { ...config, servedRuntime: probed.runtime };
+            // Asked for more than the server will give. The server's figure is the one that gets
+            // enforced, so it wins — and the difference is said out loud, because a setting that is
+            // quietly ignored is how somebody concludes the setting does not work.
+            config = { ...config, contextTokens: probed.limit, servedRuntime: probed.runtime };
+            config.onWindowConflict?.(asked, probed.limit, windowSettingIgnored(asked, probed.limit));
             config.onWindowDetected?.(probed.limit, probed.source);
         }
+        else if (probed) {
+            config = { ...config, contextTokens: probed.limit, servedRuntime: probed.runtime };
+            config.onWindowDetected?.(probed.limit, probed.source);
+        }
+        else if (asked > 0) {
+            // Nothing to compare against: the model is not loaded, so /api/ps has nothing to say about
+            // it. The setting stands, which is what it is for.
+        }
         else if (/localhost|127\.0\.0\.1|::1/.test(endpoint) && process.env['OLLAMA_CONTEXT_LENGTH']) {
             // Only for an endpoint on this machine. OLLAMA_CONTEXT_LENGTH is read by the Ollama server,
             // so this process's copy of it describes a server running here and says nothing whatever