koneck 2.25.65 → 2.25.67

package/dist/ink-chat.js

@@ -2,13 +2,13 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import React, { useState, useEffect, useRef } from 'react';
 import { Box, Static, Text, render, useApp, useInput, useStdin } from 'ink';
 import { execa } from 'execa';
-import { createAgentSession, buildClient, resolveAgentConcurrency, toolsUnsupportedNotice, isLocalRuntime } from './engine.js';
+import { createAgentSession, buildClient, resolveAgentConcurrency, toolsUnsupportedNotice } from './engine.js';
 import { estimateCost, formatCost } from './pricing.js';
 import { generateSessionId, saveSession, listSessions, loadSession, relativeAge, renameSession, forkSession, archiveSession, findSession, } from './session.js';
 import { loadMemory } from './memory.js';
 import { loadKoneckConfig, saveKoneckConfig, setConfigKey, configKeyDescriptions, CONFIG_FILE, CONFIG_SCHEMA, stepValue, displayValue } from './config-store.js';
-import { PROVIDERS, resolveProvider, getApiKey, addUserProvider, userProvidersPath } from './providers.js';
-import { resolveEndpoint, normaliseEndpoint, withEndpoint, savedEndpoints, shortSource } from './endpoints.js';
+import { PROVIDERS, resolveProvider, getApiKey, addUserProvider, userProvidersPath, needsNoCredential, servesLocally } from './providers.js';
+import { resolveEndpoint, normaliseEndpoint, withEndpoint, savedEndpoints, shortSource, resolveModelChoice, withModel } from './endpoints.js';
 import { loadProjectConfig, loadGlobalConfig } from './config.js';
 import { listCheckpoints, revertCheckpoint, snapshotTree, filesTouchedBy } from './checkpoint.js';
 import { fileDiff, diffSummary } from './diff-view.js';
@@ -810,6 +810,8 @@ function App({ config: initialConfig, clearFrame }) {
     const incompleteRef = useRef(null);
     /** The model already reported as unable to call tools, so the notice is not repeated. */
     const toolsWarnedRef = useRef(null);
+    /** The crowded-window notice is about the setup, so it is said once per session. */
+    const crowdedWarnedRef = useRef(false);
     /**
      * The id to save under, mirrored in a ref.
      *
@@ -1031,16 +1033,25 @@ function App({ config: initialConfig, clearFrame }) {
             toolsWarnedRef.current = model;
             addSystem(toolsUnsupportedNotice(model));
         },
+        onCrowdedWindow: (_fixed, _limit, advice) => {
+            // Once per session: it is a property of the setup, not of the turn.
+            if (crowdedWarnedRef.current)
+                return;
+            crowdedWarnedRef.current = true;
+            addSystem(advice);
+        },
         onLooping: (copies) => {
             // The loop itself is the symptom. On a local model the cause is almost always the window:
             // Ollama serves 4096 tokens unless told otherwise, whatever the model was trained for, and
             // a conversation that no longer fits is exactly what makes a model start repeating.
-            const local = isLocalRuntime(cfg.provider);
+            // Judged by the endpoint, not the provider's name: a LAN Ollama reached through a slot
+            // called "omni" is still Ollama, and asking about the name missed exactly that setup.
+            const local = servesLocally(cfg.provider, endpointFor(cfg.provider).url);
             addSystem(`${cfg.model} repeated the same text ${copies} times, so the reply was cut short.` +
                 (local
-                    ? `\n\nThis is usually the context window rather than the model. Ollama serves 4096 ` +
-                        `tokens by default however large the model is — set ` +
-                        `\`OLLAMA_CONTEXT_LENGTH=32768\` and restart it, then \`/context\` to confirm.`
+                    ? `\n\nThis is usually the context window rather than the model. Ollama serves 4,096 ` +
+                        `tokens by default however large the model is — set \`OLLAMA_CONTEXT_LENGTH=32768\` ` +
+                        `where Ollama runs, restart it, then \`/context\` to confirm.`
                     : ''));
         },
         onThinking: (text, totalChars) => {
@@ -1250,6 +1261,23 @@ function App({ config: initialConfig, clearFrame }) {
     }, [cfg.cwd]);
     /** Nearest first, which is the order resolveEndpoint reads them in. */
     const endpointLayers = (store = stored) => [outerLayers.project, store, outerLayers.global];
+    /**
+     * The model in force for a provider, with where the choice came from.
+     *
+     * A model belongs to a provider: qwen3-coder:30b means nothing to Anthropic. Reported as
+     * "koneck keeps reverting the model to codellama" — which is the Ollama definition's built-in
+     * default, reached because nothing else was ever saved against ollama.
+     */
+    function modelFor(provider, store) {
+        const def = PROVIDERS[provider.trim().toLowerCase()];
+        return resolveModelChoice(provider, endpointLayers(store), def?.defaultModel ?? 'auto');
+    }
+    /** Remembers a model against the provider it belongs to. */
+    async function rememberModel(provider, model) {
+        const saved = withModel(await loadKoneckConfig(), provider, model);
+        await saveKoneckConfig(saved);
+        setStored(saved);
+    }
     /** The endpoint in force for a provider, with where it came from. */
     function endpointFor(provider, store) {
         const def = PROVIDERS[provider.trim().toLowerCase()];
@@ -1654,10 +1682,25 @@ function App({ config: initialConfig, clearFrame }) {
     /** The text an edit box opens on: what the row is showing. */
     function settingText(field) {
         const key = String(field.key);
-        const value = key === 'baseURL' || stored[key] === undefined ? liveSetting(key) : stored[key];
+        const value = key === 'baseURL' || key === 'model' || stored[key] === undefined
+            ? liveSetting(key) : stored[key];
         return value === undefined || value === null ? '' : String(value);
     }
     async function applySetting(field, value) {
+        // The model row is one provider's model, so it is saved against the provider in force. In the
+        // single shared slot, choosing a model for Ollama also chose it for Anthropic.
+        if (field.key === 'model') {
+            const name = typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+            const saved = withModel(await loadKoneckConfig(), cfg.provider, name);
+            await saveKoneckConfig(saved);
+            setStored(saved);
+            const now = modelFor(cfg.provider, saved);
+            const merged = { ...cfg, model: now.model };
+            setCfg(merged);
+            await resetSession(merged);
+            addSystem(`**${cfg.provider}** → ${now.model}  (${now.source})`);
+            return;
+        }
         // The endpoint row is not a plain setting: it is one provider's address, so it is saved
         // against the provider in force rather than into a single slot every provider shares.
         if (field.key === 'baseURL') {
@@ -1695,20 +1738,19 @@ function App({ config: initialConfig, clearFrame }) {
                 setConfigMaxWidth(typeof value === 'number' && value >= 40 ? value : undefined);
                 break;
             case 'provider': {
-                // Changing the provider here has to move the endpoint with it, or the new provider is
-                // addressed at the old one's URL — the same fault /provider had.
+                // Changing the provider here has to move the endpoint and the model with it, or the new
+                // provider is addressed at the old one's URL and asked for the old one's model — the same
+                // fault /provider had, in a second place.
                 const name = typeof value === 'string' && value.trim() !== '' ? value.trim() : cfg.provider;
-                const def = PROVIDERS[name.toLowerCase()];
                 const merged = {
                     ...cfg, provider: name,
-                    model: def?.defaultModel ?? cfg.model,
+                    model: resolveModelChoice(name, endpointLayers(next), PROVIDERS[name.toLowerCase()]?.defaultModel ?? 'auto').model,
                     baseURL: endpointFor(name, next).url,
                 };
                 setCfg(merged);
                 await resetSession(merged);
                 break;
             }
-            case 'model':
             case 'maxTurns':
             case 'requireApproval':
             case 'agentConcurrency':
@@ -1799,12 +1841,16 @@ function App({ config: initialConfig, clearFrame }) {
     async function fetchModels() {
         const infos = await loadModelCatalog();
         const statuses = readModelStatus();
+        const selfHosted = needsNoCredential(resolveProvider(cfg.provider, endpointFor(cfg.provider).url));
         return [...infos]
             .sort((a, b) => a.id.localeCompare(b.id))
             .map(m => {
             const st = statuses[`${cfg.provider}:${m.id}`];
             const parts = [
-                m.free ? 'free' : 'paid',
+                // "paid" is a claim about somebody's billing, and a model on your own hardware has no
+                // billing. The catalogue's free flag describes a gateway's tiers; it means nothing for
+                // a runtime you are running, and calling qwen3-coder on a LAN box "paid" is just wrong.
+                selfHosted ? 'local' : m.free ? 'free' : 'paid',
                 ...(m.contextLength ? [`${humanTokens(m.contextLength)} ctx`] : []),
                 ...(m.toolCalling === false ? ['no tools'] : []),
                 ...(st && st.state !== 'ok' ? [stateLabel(st.state)] : st ? ['ready'] : []),
@@ -1904,7 +1950,10 @@ function App({ config: initialConfig, clearFrame }) {
         if (kind === 'model') {
             const next = { ...cfg, model: item.value };
             await resetSession(next);
-            addSystem(`Model → ${item.value}  (session reset)`);
+            // Saved against the provider. Choosing a model used to change the running session and
+            // nothing else, so it lasted until the next provider switch or the next start.
+            await rememberModel(cfg.provider, item.value);
+            addSystem(`Model → ${item.value}  ·  remembered for ${cfg.provider}  (session reset)`);
             return;
         }
         if (kind === 'provider') {
@@ -1914,9 +1963,12 @@ function App({ config: initialConfig, clearFrame }) {
             // not loopback and does need a key, whatever the provider is called.
             const endpoint = endpointFor(item.value);
             const resolved = resolveProvider(item.value, endpoint.url);
+            // Whichever model was last used with this provider, not its built-in default. The old line
+            // reached for PROVIDERS[name].defaultModel — `codellama` for Ollama — and wrote it to disk.
+            const chosen = modelFor(item.value);
             const next = {
                 ...cfg, provider: item.value,
-                model: def?.defaultModel ?? cfg.model,
+                model: chosen.model,
                 baseURL: resolved.baseURL,
                 apiKey: undefined, // a key for the previous provider must not carry over
             };
@@ -1931,10 +1983,13 @@ function App({ config: initialConfig, clearFrame }) {
             }
             if (usable) {
                 await resetSession(next);
-                const savedCfg = { ...(await loadKoneckConfig()), provider: item.value, model: next.model };
+                // The provider is persisted; the model is not, because it is already stored against the
+                // provider it belongs to. Writing it into the shared `model` key is what made a switch to
+                // ollama leave `codellama` on disk for everything else to inherit.
+                const savedCfg = { ...(await loadKoneckConfig()), provider: item.value };
                 await saveKoneckConfig(savedCfg);
                 setStored(savedCfg);
-                addSystem(`Provider → ${item.value}  ·  model → ${next.model}\n` +
+                addSystem(`Provider → ${item.value}  ·  model → ${next.model}  (${chosen.source})\n` +
                     `Endpoint  ${resolved.baseURL}  (${endpoint.source})  ·  session reset`);
                 return;
             }
@@ -2012,12 +2067,17 @@ function App({ config: initialConfig, clearFrame }) {
             }
             case '/model': {
                 if (!arg) {
-                    addSystem(`Current model: ${cfg.model}\nUsage: /model <name>`);
+                    const now = modelFor(cfg.provider);
+                    addSystem(`Current model: ${cfg.model}  (${now.source})\n` +
+                        `Usage: /model <name>   — remembered for ${cfg.provider}`);
                     return;
                 }
                 const newCfg = { ...cfg, model: arg };
                 await resetSession(newCfg);
-                addSystem(`Model → ${arg}  (session reset)`);
+                // Persisted against the provider. It used to change the running session only, so the
+                // next start or the next provider switch put the old model back.
+                await rememberModel(cfg.provider, arg);
+                addSystem(`Model → ${arg}  ·  remembered for ${cfg.provider}  (session reset)`);
                 return;
             }
             case '/provider': {
@@ -2039,15 +2099,19 @@ function App({ config: initialConfig, clearFrame }) {
                 // address with PROVIDERS[name].baseURL, which is how a configured Ollama kept coming back
                 // as localhost.
                 const endpoint = endpointFor(name);
-                const newCfg = { ...cfg, provider: name, model: def.defaultModel ?? cfg.model, baseURL: endpoint.url };
+                // Whichever model was last used with this provider. Forcing def.defaultModel here — and
+                // then writing it to disk — is what "keeps reverting the model to codellama" was.
+                const chosen = modelFor(name);
+                const newCfg = { ...cfg, provider: name, model: chosen.model, baseURL: endpoint.url };
                 await resetSession(newCfg);
-                // Persisted, or the switch is undone by the next start and the old provider wins again.
-                const savedCfg = { ...(await loadKoneckConfig()), provider: name, model: newCfg.model };
+                // The provider is persisted, or the switch is undone by the next start. The model is not:
+                // it already lives against the provider it belongs to.
+                const savedCfg = { ...(await loadKoneckConfig()), provider: name };
                 await saveKoneckConfig(savedCfg);
                 setStored(savedCfg);
-                addSystem(`Provider → ${name}  model → ${newCfg.model}\n` +
+                addSystem(`Provider → ${name}  model → ${chosen.model}  (${chosen.source})\n` +
                     `Endpoint  ${endpoint.url}  (${endpoint.source})\n` +
-                    `Session reset. /endpoint <url> changes the address.`);
+                    `Session reset. /endpoint <url> changes the address, /model <name> the model.`);
                 return;
             }
             case '/redraw': {
@@ -3550,7 +3614,8 @@ function App({ config: initialConfig, clearFrame }) {
                         // An endpoint always has a source worth naming, so it never reads as unset or as
                         // merely inherited: the question it answers is which file won.
                         const isEndpoint = f.key === 'baseURL';
-                        const here = !isEndpoint && stored[f.key] !== undefined;
+                        const isModel = f.key === 'model';
+                        const here = !isEndpoint && !isModel && stored[f.key] !== undefined;
                         const value = here ? stored[f.key] : liveSetting(String(f.key));
                         const raw = f.key === 'maxTurns' && (value === 0 || value === undefined)
                             ? 'no limit'
@@ -3558,7 +3623,8 @@ function App({ config: initialConfig, clearFrame }) {
                         const shown = beingTyped
                             ? `${editing.value}_`
                             : isEndpoint ? `${raw}  (${shortSource(endpoint.source)})`
-                                : raw + (here || value === undefined ? '' : ' (inherited)');
+                                : isModel ? `${raw}  (${shortSource(modelFor(cfg.provider).source)})`
+                                    : raw + (here || value === undefined ? '' : ' (inherited)');
                         // The marker is what makes the selection legible without colour, which a panel line
                         // drawn as one string cannot carry per-segment.
                         const mark = selected ? '>' : ' ';
@@ -3643,7 +3709,8 @@ function App({ config: initialConfig, clearFrame }) {
                         const st = statuses[`${cfg.provider}:${cfg.model}`];
                         lines.push(`**In use**  ${cfg.model}`);
                         if (current) {
-                            lines.push(`  ${current.free ? 'free' : 'paid'}` +
+                            const hosted = needsNoCredential(resolveProvider(cfg.provider, endpointFor(cfg.provider).url));
+                            lines.push(`  ${hosted ? 'local' : current.free ? 'free' : 'paid'}` +
                                 (current.contextLength ? ` · ${humanTokens(current.contextLength)} context` : '') +
                                 (current.maxOutput ? ` · ${humanTokens(current.maxOutput)} max out` : '') +
                                 (current.toolCalling === false ? ' · no tool calling' : ''));