koneck 2.25.60 → 2.25.61

package/dist/ink-chat.js

@@ -8,6 +8,8 @@ import { generateSessionId, saveSession, listSessions, loadSession, relativeAge,
 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 } from './endpoints.js';
+import { loadProjectConfig, loadGlobalConfig } from './config.js';
 import { listCheckpoints, revertCheckpoint, snapshotTree, filesTouchedBy } from './checkpoint.js';
 import { fileDiff, diffSummary } from './diff-view.js';
 import { listWorkspaceEntries, filterEntries, activeReference } from './workspace-files.js';
@@ -498,6 +500,7 @@ const COMMANDS = [
     { cmd: '/help', desc: 'Show help' },
     { cmd: '/models', desc: 'Browse and switch models for the connected provider' },
     { cmd: '/connect', desc: 'Connect a provider, or declare a new one with a URL' },
+    { cmd: '/endpoint', desc: "Show or change this provider's URL, e.g. a remote Ollama" },
     { cmd: '/key', desc: 'Enter an API key for the current provider' },
     { cmd: '/model', desc: 'Show or set the model by name' },
     { cmd: '/provider', desc: 'Show or switch provider' },
@@ -706,7 +709,7 @@ export function pickerLabelWidth(labels, descs, width) {
  */
 const COMMANDS_THAT_MUST_WAIT = new Set([
     '/clear', '/reset', '/new', // would wipe the history the turn is using
-    '/model', '/provider', '/connect', '/key', // rebuild the session
+    '/model', '/provider', '/connect', '/key', '/endpoint', '/baseurl', // rebuild the session
     '/resume', '/fork', // replace it
     '/revert', // undo files the turn may still be writing
     '/init', '/setup',
@@ -730,6 +733,9 @@ Slash commands:
   /connect [provider]   Connect a provider (picker when no name given)
   /connect <name> <url> Declare a provider KONECK does not ship with, e.g.
                         /connect openrouter https://openrouter.ai/api/v1
+  /endpoint             Show the endpoint in force and where it came from
+  /endpoint <url>       Point this provider somewhere else, e.g.
+                        /endpoint http://192.168.1.50:11434/v1
   /key                  Enter an API key for the current provider
   /status               Provider, model, mode, tokens, cost, CWD
   /clear /reset /new    Clear conversation history
@@ -1186,6 +1192,28 @@ function App({ config: initialConfig }) {
             setConfigMaxWidth(typeof c.maxWidth === 'number' && c.maxWidth >= 40 ? c.maxWidth : undefined);
         });
     }, []);
+    /**
+     * The config layers other than the store, kept so an endpoint can be resolved and, more to the
+     * point, explained. "It still sticks to the already set ollama" is a question about which file
+     * won, and the answer is not available from the store alone.
+     */
+    const [outerLayers, setOuterLayers] = useState({ project: {}, global: {} });
+    useEffect(() => {
+        void Promise.all([loadProjectConfig(cfg.cwd), loadGlobalConfig()])
+            .then(([project, global]) => setOuterLayers({ project, global }))
+            .catch(() => { });
+    }, [cfg.cwd]);
+    /** Nearest first, which is the order resolveEndpoint reads them in. */
+    const endpointLayers = (store = stored) => [outerLayers.project, store, outerLayers.global];
+    /** The endpoint in force for a provider, with where it came from. */
+    function endpointFor(provider, store) {
+        const def = PROVIDERS[provider.trim().toLowerCase()];
+        return resolveEndpoint(provider, endpointLayers(store), {
+            fallback: def?.baseURL ?? '',
+            baseURLEnv: def?.baseURLEnv,
+            fallbackIsUserDeclared: def?.userDefined === true,
+        });
+    }
     useEffect(() => {
         const onResize = () => {
             setTermCols(process.stdout.columns || 80);
@@ -1529,7 +1557,58 @@ function App({ config: initialConfig }) {
      * Persisting alone would leave the running session on the old value until restart, which is the
      * behaviour that made the old `/config` feel inert even when it had worked.
      */
+    /**
+     * What a setting is worth right now, wherever the value came from.
+     *
+     * The store is only one of three files. Reading a row from it alone showed "(not set)" beside a
+     * session that was plainly configured, and — with endpoints saved per provider — would show
+     * nothing at all for an endpoint that is in force.
+     */
+    function liveSetting(key) {
+        switch (key) {
+            case 'provider': return cfg.provider;
+            case 'model': return cfg.model;
+            case 'baseURL': return endpointFor(cfg.provider).url;
+            case 'effort': return effort;
+            case 'requireApproval': return cfg.requireApproval;
+            case 'maxTurns': return cfg.maxTurns;
+            case 'agentConcurrency': return cfg.agentConcurrency;
+            case 'maxWidth': return configMaxWidth;
+            case 'budget': return cfg.budget;
+            default: return stored[key];
+        }
+    }
+    /** 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];
+        return value === undefined || value === null ? '' : String(value);
+    }
     async function applySetting(field, value) {
+        // 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') {
+            let url;
+            if (typeof value === 'string' && value.trim() !== '') {
+                const checked = normaliseEndpoint(value);
+                if (!checked.url) {
+                    addSystem(checked.problem ?? `"${value}" is not a URL.`);
+                    return;
+                }
+                url = checked.url;
+                if (checked.note)
+                    addSystem(checked.note);
+            }
+            const saved = withEndpoint(await loadKoneckConfig(), cfg.provider, url);
+            await saveKoneckConfig(saved);
+            setStored(saved);
+            const now = endpointFor(cfg.provider, saved);
+            const merged = { ...cfg, baseURL: now.url };
+            setCfg(merged);
+            await resetSession(merged);
+            addSystem(`**${cfg.provider}** → ${now.url}  (${now.source})`);
+            return;
+        }
         const next = { ...stored, [field.key]: value };
         if (value === undefined)
             delete next[field.key];
@@ -1542,9 +1621,21 @@ function App({ config: initialConfig }) {
             case 'maxWidth':
                 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.
+                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,
+                    baseURL: endpointFor(name, next).url,
+                };
+                setCfg(merged);
+                await resetSession(merged);
+                break;
+            }
             case 'model':
-            case 'provider':
-            case 'baseURL':
             case 'maxTurns':
             case 'requireApproval':
             case 'agentConcurrency':
@@ -1745,7 +1836,11 @@ function App({ config: initialConfig }) {
         }
         if (kind === 'provider') {
             const def = PROVIDERS[item.value];
-            const resolved = resolveProvider(item.value);
+            // The endpoint saved for the provider being switched to, not its built-in address. Passing
+            // it into resolveProvider also settles the credential question honestly: a remote Ollama is
+            // not loopback and does need a key, whatever the provider is called.
+            const endpoint = endpointFor(item.value);
+            const resolved = resolveProvider(item.value, endpoint.url);
             const next = {
                 ...cfg, provider: item.value,
                 model: def?.defaultModel ?? cfg.model,
@@ -1763,7 +1858,11 @@ function App({ config: initialConfig }) {
             }
             if (usable) {
                 await resetSession(next);
-                addSystem(`Provider → ${item.value}  ·  model → ${next.model}  (session reset)`);
+                const savedCfg = { ...(await loadKoneckConfig()), provider: item.value, model: next.model };
+                await saveKoneckConfig(savedCfg);
+                setStored(savedCfg);
+                addSystem(`Provider → ${item.value}  ·  model → ${next.model}\n` +
+                    `Endpoint  ${resolved.baseURL}  (${endpoint.source})  ·  session reset`);
                 return;
             }
             setCfg(next);
@@ -1853,10 +1952,74 @@ function App({ config: initialConfig }) {
                     addSystem(`Current provider: ${cfg.provider}\nAvailable: ${Object.keys(PROVIDERS).join(', ')}\nUsage: /provider <name>`);
                     return;
                 }
-                const def = PROVIDERS[arg.toLowerCase()];
-                const newCfg = { ...cfg, provider: arg.toLowerCase(), model: def?.defaultModel ?? cfg.model, baseURL: def?.baseURL };
+                const name = arg.trim().toLowerCase();
+                const def = PROVIDERS[name];
+                if (!def) {
+                    // Switching to a name that does not resolve used to reset the session anyway, leaving it
+                    // pointed at nothing and failing on the next message instead of on the command.
+                    addSystem(`Unknown provider "${arg}". Known: ${Object.keys(PROVIDERS).join(', ')}\n` +
+                        `Declare one:  /connect ${name} https://endpoint/v1`);
+                    return;
+                }
+                // The endpoint is the provider's own, not a literal default: whatever was saved for it,
+                // or its environment variable, still applies. Naming a provider used to overwrite the
+                // 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 };
                 await resetSession(newCfg);
-                addSystem(`Provider → ${arg}  model → ${newCfg.model}  (session reset)`);
+                // 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 };
+                await saveKoneckConfig(savedCfg);
+                setStored(savedCfg);
+                addSystem(`Provider → ${name}  model → ${newCfg.model}\n` +
+                    `Endpoint  ${endpoint.url}  (${endpoint.source})\n` +
+                    `Session reset. /endpoint <url> changes the address.`);
+                return;
+            }
+            case '/url':
+            case '/baseurl':
+            case '/endpoint': {
+                const provider = cfg.provider;
+                const current = endpointFor(provider);
+                if (!arg.trim()) {
+                    // No argument is the diagnostic. The complaint that produced this command was about a
+                    // change that appeared not to take, and the only useful reply names the file that won.
+                    const all = savedEndpoints(endpointLayers());
+                    const others = Object.entries(all).filter(([name]) => name !== provider.toLowerCase());
+                    addSystem(`**${provider}** → ${current.url}\n` +
+                        `Source: ${current.source}\n\n` +
+                        (others.length
+                            ? 'Also saved:\n' + others.map(([n, u]) => `  ${n.padEnd(12)} ${u}`).join('\n') + '\n\n'
+                            : '') +
+                        `Change it:  /endpoint http://192.168.1.50:11434/v1\n` +
+                        `Undo it:    /endpoint default`);
+                    return;
+                }
+                const wanted = arg.trim();
+                if (/^(default|reset|clear|unset)$/i.test(wanted)) {
+                    const saved = withEndpoint(await loadKoneckConfig(), provider, undefined);
+                    await saveKoneckConfig(saved);
+                    setStored(saved);
+                    const back = endpointFor(provider, saved);
+                    await resetSession({ ...cfg, baseURL: back.url });
+                    addSystem(`**${provider}** → ${back.url}  (${back.source})\nSession reset.`);
+                    return;
+                }
+                const { url, problem, note } = normaliseEndpoint(wanted);
+                if (!url) {
+                    addSystem(`${problem}\nUsage: /endpoint http://host:port/v1`);
+                    return;
+                }
+                // Saved against the provider, not as a global address: setting Ollama's URL used to move
+                // OmniRoute's too, and one of the two was then wrong whichever way round it was left.
+                const saved = withEndpoint(await loadKoneckConfig(), provider, url);
+                await saveKoneckConfig(saved);
+                setStored(saved);
+                await resetSession({ ...cfg, baseURL: url });
+                addSystem(`**${provider}** → ${url}\n` +
+                    `Saved for ${provider} in ${CONFIG_FILE}; session reset.` +
+                    (note ? `\n${note}` : ''));
                 return;
             }
             case '/mode':
@@ -2757,7 +2920,10 @@ function App({ config: initialConfig }) {
                         void applySetting(field, stepValue(field, stored[field.key], 1));
                     }
                     else {
-                        setEditing({ key: String(field.key), value: '' });
+                        // Opened on the current value rather than on an empty box. Editing a URL by retyping
+                        // all of it is not editing, and an empty box next to a value that is plainly set
+                        // reads as "this cannot be changed".
+                        setEditing({ key: String(field.key), value: settingText(field) });
                     }
                     return;
                 }
@@ -3268,23 +3434,23 @@ function App({ config: initialConfig }) {
                     // What is actually in force, not just what this file happens to hold. provider and
                     // baseURL commonly come from ~/.koneckrc, and showing those as "(not set)" made a
                     // configured session look unconfigured.
-                    const live = {
-                        provider: cfg.provider, model: cfg.model, baseURL: cfg.baseURL,
-                        effort, requireApproval: cfg.requireApproval, maxTurns: cfg.maxTurns,
-                        agentConcurrency: cfg.agentConcurrency, maxWidth: configMaxWidth, budget: cfg.budget,
-                    };
+                    const endpoint = endpointFor(cfg.provider);
                     const labelW = Math.max(...CONFIG_SCHEMA.map(f => f.label.length));
                     for (const [i, f] of CONFIG_SCHEMA.entries()) {
                         const selected = i === settingRow;
                         const beingTyped = editing?.key === String(f.key);
-                        const here = stored[f.key] !== undefined;
-                        const value = here ? stored[f.key] : live[f.key];
+                        // 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 value = here ? stored[f.key] : liveSetting(String(f.key));
                         const raw = f.key === 'maxTurns' && (value === 0 || value === undefined)
                             ? 'no limit'
                             : displayValue(value);
                         const shown = beingTyped
                             ? `${editing.value}_`
-                            : raw + (here || value === undefined ? '' : ' (inherited)');
+                            : isEndpoint ? `${raw}  (${endpoint.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 ? '>' : ' ';