koneck 2.95.0 → 2.96.0

package/dist/engine.js

@@ -7,7 +7,7 @@ import { execa } from 'execa';
 import { TOOL_DEFINITIONS, dispatchTool, describeShell, unknownToolError, resolveToolAlias, aliasNotice, isToolFailure, } from './tools.js';
 import { tui } from './tui.js';
 import { hasWorkspaceOwnedGitRepo, gitScope, createWorktree, mergeWorktree, preservedWorktreeNotice } from './worktree.js';
-import { resolveProvider, getApiKey, keyProvenance, servesLocally, servesOwnWeights, needsNoCredential, isPrivateHost } from './providers.js';
+import { resolveProvider, getApiKey, keyProvenance, servesLocally, servesOwnWeights, needsNoCredential } from './providers.js';
 import { wireEffort, looksLikeEffortUnsupported, acceptedEfforts, nearestAccepted } from './pace.js';
 import { triggerFor, pickNext, describeSwitch, askSwitch, keyOf as failoverKey } from './failover.js';
 import { findChurn, describeChurn, WINDOW as CHURN_WINDOW } from './cycle.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, } from './context-limit.js';
+import { contextLimitFor, looksLikeContextOverflow, parseContextLimit, fetchModelContextLimit, ollamaServingLimit, fixedRequestTokens, overheadIsCrowded, crowdedWindowAdvice, probeOllamaContext, detectWindowPlateau, truncationNotice, ollamaWindowFix, 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';
@@ -26,6 +26,7 @@ import { resolveSandbox, describeSandbox } from './sandbox.js';
 import { loadImages, buildUserContent, imageMime, looksLikeVisionUnsupported, visionUnsupportedNotice, } from './images.js';
 import { parseTextToolCalls, paramTypesFrom, looksLikeTextToolCall, stripTemplateTokens, splitEmittable, parseCommandStyleCalls, toolShapesFrom } from './tool-call-text.js';
 import { isIdentityQuestion, identityAnswer } from './identity.js';
+import { deniedCapabilities, capabilityCorrection, capabilityNotice } from './capability-claims.js';
 import { leanTools, leanModeNotice, findToolsSchema, matchDeferred, deferredToolNotice, FIND_TOOLS } from './lean-mode.js';
 import { findTailRepetition, trimTailRepetition, repetitionNotice, CHECK_EVERY } from './repetition.js';
 import { loadMemory } from './memory.js';
@@ -1100,7 +1101,17 @@ export function toolDetailFor(name, argsJson) {
  * before a conversation starts, so on the default there is almost no room to work in, and the
  * symptom is exactly this: nothing comes back.
  */
-export function emptyResponseAdvice(provider, model, count, toolsWorked, endpoint) {
+export function emptyResponseAdvice(provider, model, count, toolsWorked, endpoint, 
+/*
+ * What this run's instructions and tool descriptions actually cost.
+ *
+ * This was the string "about 3.8k", with a comment four lines above it saying 3,600 — two
+ * different figures for the same thing in the same file, neither of them measured. The real
+ * number moves with the tools a run has: lean mode drops some, an MCP server adds more, and a
+ * 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) {
     // 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.
@@ -1123,13 +1134,19 @@ export function emptyResponseAdvice(provider, model, count, toolsWorked, endpoin
      */
     const runtime = servesOwnWeights(provider);
     const ownNetwork = endpoint ? servesLocally(provider, endpoint) : provider.toLowerCase() === 'ollama';
+    const remote = endpoint ? !runsOnThisMachine(endpoint) : false;
+    const cost = fixedTokens && fixedTokens > 0
+        ? `${fixedTokens.toLocaleString()} tokens of that — measured for this run, with the tools it `
+            + `actually has —`
+        : 'most of that';
     const ollamaFix = 'Ollama serves a default of 4,096 tokens whatever the model was trained for, and silently ' +
         'truncates a longer prompt instead of refusing it — and KONECK\'s instructions and tool ' +
-        'descriptions come to about 3.8k of that before your conversation is counted, which is exactly ' +
-        'how a turn comes back with nothing in it. Set OLLAMA_CONTEXT_LENGTH=32768 where Ollama runs' +
-        (endpoint ? ` — the machine serving ${endpoint}` : '') +
-        ', or use a Modelfile with PARAMETER num_ctx 32768, and restart it. If you know the real ' +
-        'limit, `/config contextTokens <n>` makes KONECK compact before reaching it.';
+        `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,
+            ...(platform !== undefined ? { platform } : {}) }) +
+        '\n\nIf you know the real limit, `/config contextTokens <n>` makes KONECK compact before ' +
+        'reaching it.';
     if (runtime) {
         return observed + '\nThe likeliest cause is the context window rather than the model. ' + ollamaFix;
     }
@@ -1485,12 +1502,16 @@ detectedContext = { current: 0 }) {
     let textToolsNoticed = false;
     /** Said once: a model that writes calls as shell commands will keep doing it. */
     let commandStyleNoticed = false;
+    /** One correction per user message: a model that repeats a false denial will not be argued out. */
+    let capabilityCorrected = false;
     // The tool list, cut to fit when the window cannot hold it.
     //
     // Nine of the twenty-three tools are git subcommands, about 550 tokens between them, and every
     // one is a line of shell that execute_command already runs. Reported as a session that planned
     // three steps, called `plan`, and then returned three empty turns: there was nothing left of the
     // window to answer in.
+    /** What this run costs before the conversation is counted. Set just below, read at the plateau. */
+    let fixedCost = 0;
     // What every request costs before the user has typed anything — the instructions plus the tool
     // descriptions. On a large window this is 12% of it and there is nothing to discuss. On a small
     // one it was 93%, which is why a model looped, wrote tool calls as prose, and answered questions
@@ -1518,6 +1539,14 @@ detectedContext = { current: 0 }) {
                 fixed = fixedRequestTokens(systemChars, JSON.stringify(openaiTools));
             }
         }
+        /*
+         * Recorded after lean mode has had its go, so it is the floor that actually applies.
+         *
+         * A window discovered mid-stream is compared against this. Before lean mode it would overstate
+         * the floor, and telling somebody their window cannot hold a prompt that has since been
+         * trimmed to fit would be the wrong answer confidently given.
+         */
+        fixedCost = fixed;
         // Said only if it still does not fit after that, because otherwise it is solved rather than
         // worth a warning.
         if (overheadIsCrowded(fixed, effectiveLimit())) {
@@ -1527,9 +1556,8 @@ detectedContext = { current: 0 }) {
                 // OLLAMA_CONTEXT_LENGTH is read by the server, so for an endpoint on another machine it
                 // has to be set there. The advice said "in Ollama's environment", which for a remote box
                 // sends someone to restart the wrong one.
-                remote: !isPrivateHost(resolveProvider(config.provider, config.baseURL).baseURL)
-                    ? false
-                    : !/localhost|127\.0\.0\.1|::1/.test(resolveProvider(config.provider, config.baseURL).baseURL),
+                // Loopback means this machine; a LAN address is somebody else's. See runsOnThisMachine.
+                remote: !runsOnThisMachine(resolveProvider(config.provider, config.baseURL).baseURL),
             });
             config.onCrowdedWindow?.(fixed, effectiveLimit(), advice);
             if (!silent)
@@ -1861,9 +1889,17 @@ detectedContext = { current: 0 }) {
                             truncationSeen = true;
                             contextLimit = plateau.window;
                             config.contextTokens = plateau.window; // so compaction plans around the real figure
-                            config.onTruncation?.(plateau.window, truncationNotice(plateau.window));
+                            const endpoint = resolveProvider(config.provider, config.baseURL).baseURL;
+                            const said = truncationNotice(plateau.window, {
+                                floor: fixedCost,
+                                endpoint,
+                                // 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),
+                            });
+                            config.onTruncation?.(plateau.window, said);
                             if (!silent)
-                                tui.printWarning(truncationNotice(plateau.window));
+                                tui.printWarning(said);
                         }
                     }
                 }
@@ -2341,6 +2377,36 @@ detectedContext = { current: 0 }) {
                 }
             }
         }
+        /*
+         * A reply that denies a capability this run has.
+         *
+         * "I cannot visit websites or perform login actions" — with the browser tool enabled, whose
+         * description says it opens a url, fills form fields and clicks. The user's answer to that was
+         * "but there's a built in browser right here", and they were right.
+         *
+         * Checked only after every recovery above has failed to find a call, because a model that wrote
+         * a call as prose has not denied anything. And only for tools actually passed this turn: lean
+         * mode defers tools and a machine may have no browser, and in those cases the denial is true.
+         *
+         * Once per user message. The correction goes to the model and the turn is taken again, because
+         * being told the agent cannot help when it can is the worst outcome available — but a model that
+         * says it a second time is not going to be argued into it, and the reader is better served by
+         * the note than by a third attempt.
+         */
+        if (toolCalls.length === 0 && assistantContent && !capabilityCorrected) {
+            const denied = deniedCapabilities(assistantContent, openaiTools.map(t => t.function.name));
+            if (denied.length > 0) {
+                capabilityCorrected = true;
+                const notice = capabilityNotice(denied, config.model);
+                config.onFalseDenial?.(denied.map(d => d.what), notice);
+                if (!silent)
+                    tui.printWarning(notice);
+                messages.push({ role: 'assistant', content: assistantContent });
+                messages.push({ role: 'system', content: capabilityCorrection(denied) });
+                assistantContent = '';
+                continue;
+            }
+        }
         // Only print buffered content if it wasn't already live-streamed
         if (!silent && assistantContent.trim() && !tui.hadStreamOutput())
             tui.printAssistant(assistantContent);
@@ -2449,7 +2515,9 @@ detectedContext = { current: 0 }) {
                     // tools — and it said the model was not usable, about a model that had just called
                     // `plan` successfully one turn earlier. Neither helped, and both pointed away from the
                     // likely cause.
-                    throw new Error(emptyResponseAdvice(config.provider, config.model, emptyTurns, toolsProvenToWork, resolveProvider(config.provider, config.baseURL).baseURL));
+                    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));
                 }
             }
             else {