@aragon-agent/cli 0.6.12 → 0.6.14

package/dist/agent/controller.js

@@ -1,6 +1,8 @@
+import { createModelSettingsDraft, saveModelSettings, reloadModelSettings, } from './model-profile-settings.js';
 import { randomUUID } from 'node:crypto';
 import { Agent, initProviders, ModelRegistry, } from '@aragon-agent/core';
 import { clampCompactionConfig, clampFastConfig, clampRetryConfig, clampTeamConfig, clampTodoConfig, isAdapterProvider, toRetryPolicy, } from '../config/schema.js';
+import { resolveModelProfileState } from '../config/model-profile-resolution.js';
 import { makeGetApiKey } from '../config/load.js';
 import { updatePersistedConfig } from '../config/store.js';
 import { createBuiltinTools } from '../tools/index.js';
@@ -49,6 +51,10 @@ export class AgentController {
     agent;
     providerRegistry;
     modelRegistry;
+    modelMetadataEnabled = false;
+    modelMetadataGeneration = 0;
+    modelMetadataAbort = new AbortController();
+    disposed = false;
     tools;
     skills;
     skillsEnabled;
@@ -194,6 +200,9 @@ export class AgentController {
     // no timer while it has no subscribers, so the extra object is a few scalars
     // and a `Set`.
     // -----------------------------------------------------------------------
+    settingsRevision = 0;
+    modelSettingsBlocked = false;
+    preparedSystemPrompt;
     contextMeter;
     // -----------------------------------------------------------------------
     // Background services (background-service-supervision §3.3 / §3.6)
@@ -297,7 +306,7 @@ export class AgentController {
         // ONCE (C-2). `FastWiring` re-runs the same pure function in its own
         // constructor; the two agree by construction because they read the same
         // config through the same resolver.
-        const fastTier = resolveFastTier(config, (id) => this.hasApiKey(id));
+        const fastTier = resolveFastTier(config, (id, role) => this.hasApiKey(id, role));
         const fastRegistered = fastTier.ok;
         // --- Team mode ---------------------------------------------------------
         this.teamRegistered = config.team.enabled;
@@ -321,11 +330,12 @@ export class AgentController {
                             ...(this.config.baseUrl ? { baseUrl: this.config.baseUrl } : {}),
                         },
                         thinkingLevel: this.config.thinkingLevel,
+                        role: 'main',
                     },
                 providerRegistry: this.providerRegistry,
                 getCwd: () => this.cwd,
                 getMode: () => this.effectiveMode,
-                getApiKey: (id) => this.resolveKey(id),
+                getApiKey: (id, role) => this.resolveKey(id, role),
                 // `skill_find` only, and the lead's always-on bodies. See the long
                 // note in `subagent.ts` for why `skill` itself is withheld (D-16).
                 ...(this.skillsEnabled
@@ -523,15 +533,8 @@ export class AgentController {
             getMessages: () => this.agent.state.messages,
             getSystemPrompt: () => this.agent.state.systemPrompt,
             getModelInfo: () => this.getModelInfo(),
-            // ONE PREDICATE FOR "IS THE DENOMINATOR REAL". `isPricedModel` is
-            // `modelRegistry.getModel(...) !== undefined`, and `getModelInfoFor` falls
-            // back to `buildRuntimeModel` - a 128k placeholder AND a zero cost table -
-            // for exactly the models it answers `false` for. The two are the same
-            // question about the same static table, not a coincidence.
-            isWindowKnown: () => this.isPricedModel({
-                providerId: this.config.provider,
-                modelId: this.config.model,
-            }),
+            // Context discovery does not imply that the model's price is known.
+            isWindowKnown: () => this.getModelInfo().contextWindowSource !== 'fallback',
             // LIVE, so a settings-screen edit moves the denominator without a relaunch.
             getWindowOverride: () => this.config.contextWindow,
         });
@@ -545,8 +548,8 @@ export class AgentController {
         this.compaction = config.compaction.enabled
             ? new CompactionWiring({
                 getConfig: () => this.config,
-                hasKey: (id) => this.hasApiKey(id),
-                getApiKey: (id) => this.resolveKey(id),
+                hasKey: (id, role) => this.hasApiKey(id, role),
+                getApiKey: (id, role) => this.resolveKey(id, role),
                 getModelInfoFor: (ref) => this.getModelInfoFor(ref),
                 isPricedModel: (ref) => this.isPricedModel(ref),
                 getMessages: () => this.agent.state.messages,
@@ -623,8 +626,8 @@ export class AgentController {
         this.fast = fastRegistered
             ? new FastWiring({
                 getConfig: () => this.config,
-                hasKey: (id) => this.hasApiKey(id),
-                getApiKey: (id) => this.resolveKey(id),
+                hasKey: (id, role) => this.hasApiKey(id, role),
+                getApiKey: (id, role) => this.resolveKey(id, role),
                 isPricedModel: (ref) => this.isPricedModel(ref),
                 subscribe: (listener) => this.agent.subscribe(listener),
                 complete: (providerId, request) => this.providerRegistry.complete(providerId, request),
@@ -673,8 +676,8 @@ export class AgentController {
         if (problem)
             deps.notify?.('warn', problem);
     }
-    resolveKey(providerId) {
-        return makeGetApiKey(this.config)(providerId);
+    resolveKey(providerId, role = 'main') {
+        return makeGetApiKey(this.config, role)(providerId);
     }
     /**
      * The tool names registered right now — LAZY, and the laziness is required.
@@ -705,27 +708,30 @@ export class AgentController {
     // suddenly denies having any skills). Structure, not call ordering, is what
     // rules that out — so if you add a third caller, route it through here.
     // -----------------------------------------------------------------------
-    composeSystemPrompt() {
+    composeSystemPrompt(config = this.config) {
+        const tier = resolveFastTier(config, (id, role) => !!makeGetApiKey(config, role)(id));
+        const fastAvailable = config === this.config ? this.fast?.available() === true
+            : this.fast?.isRegistered() && config.fast.enabled && tier.ok;
         return buildSystemPrompt({
             cwd: this.cwd,
             tools: this.tools,
             skillsBlock: this.skillsEnabled ? this.skills.catalogBlock() + this.skills.alwaysBlock() : '',
             agentMode: this.effectiveMode,
             planInteractive: this.planInteractive,
-            planMaxAskRounds: this.config.planModeMaxAskRounds,
+            planMaxAskRounds: config.planModeMaxAskRounds,
             // BOTH flags, and both are required (§4.5). `teamRegistered` false means
             // there is no `task` tool to advertise; `teamEnabled` false means the user
             // turned it off for this session. Advertising in either case would
             // describe a capability the model does not have.
             teamBlock: this.teamRegistered && this.teamEnabled
                 ? buildTeamBlock({
-                    maxSubagents: this.config.team.maxSubagents,
-                    maxConcurrent: this.config.team.maxConcurrent,
+                    maxSubagents: config.team.maxSubagents,
+                    maxConcurrent: config.team.maxConcurrent,
                     // One cross-reference sentence, present only when the capability
                     // is (§3.8). `this.fast` is null during the FIRST compose (the
                     // wiring needs the Agent), which is why the constructor composes
                     // again once it exists.
-                    fastDelegation: this.fast?.delegationAvailable() === true,
+                    fastDelegation: !!fastAvailable && config.fast.delegate,
                 })
                 : '',
             // BOTH FLAGS, exactly as team mode uses both, and for the identical
@@ -735,18 +741,18 @@ export class AgentController {
             // model does not have.
             todoBlock: this.todoRegistered && this.todoEnabled
                 ? buildTodoBlock({
-                    panelVisible: this.todoPanelCapable && this.config.todo.panel,
+                    panelVisible: this.todoPanelCapable && config.todo.panel,
                 })
                 : '',
             // The SAME two flags one more time, plus the live resolution — all three
             // live inside `FastWiring.available()` (§3.3). `buildFastBlock` itself
             // returns `''` when neither capability is on, so a user who turned both
             // off pays nothing for the tier being technically live.
-            fastBlock: this.fast && this.fast.available()
+            fastBlock: fastAvailable
                 ? buildFastBlock({
-                    model: this.fast.fastRef()?.modelId ?? '',
-                    delegate: this.config.fast.delegate,
-                    review: this.config.fast.review,
+                    model: tier.ok ? tier.ref.modelId : '',
+                    delegate: config.fast.delegate,
+                    review: config.fast.review,
                 })
                 : '',
             // ONE FLAG, unlike team/todo's two: there is no live on/off switch for
@@ -762,7 +768,7 @@ export class AgentController {
         });
     }
     rebuildSystemPrompt() {
-        this.agent.setSystemPrompt(this.composeSystemPrompt());
+        this.agent.setSystemPrompt(this.preparedSystemPrompt ?? this.composeSystemPrompt());
     }
     /** Re-render the prompt from the current skill set and tell the UI. */
     refreshSkills() {
@@ -781,8 +787,10 @@ export class AgentController {
      * Read-only CLI-layer helper for the Header/Welcome key-status dot (P1-1);
      * does not touch `@aragon-agent/core`.
      */
-    hasApiKey(provider) {
-        const key = this.resolveKey(provider ?? this.config.provider);
+    hasApiKey(provider, role = 'main') {
+        const activeProvider = role === 'fast'
+            ? this.config.fast.provider || this.config.provider : this.config.provider;
+        const key = this.resolveKey(provider ?? activeProvider, role);
         return !!key && key.trim().length > 0;
     }
     /**
@@ -791,6 +799,7 @@ export class AgentController {
      * re-memoizes the palette (P1-1). Does not touch `@aragon-agent/core`.
      */
     setTheme(name) {
+        this.settingsRevision += 1;
         this.config = { ...this.config, theme: name };
     }
     /**
@@ -811,6 +820,9 @@ export class AgentController {
     // Pre-flight (R2): validate BEFORE entering the loop.
     // -----------------------------------------------------------------------
     preflight() {
+        if (this.modelSettingsBlocked)
+            return { ok: false, kind: 'config',
+                message: 'Settings were saved but not fully applied. Restart before sending requests.' };
         const provider = this.config.provider;
         if (!isAdapterProvider(provider)) {
             return {
@@ -845,6 +857,11 @@ export class AgentController {
      */
     async prompt(text, options = {}) {
         // Capture BEFORE stopping: synchronous abort listeners may cancel this request.
+        if (this.modelSettingsBlocked) {
+            return { status: 'not-started', reason: 'failed' };
+        }
+        if (this.modelMetadataEnabled)
+            void this.refreshModelMetadata();
         const request = ++this.startupSequence;
         try {
             if (this.agent.state.isRunning) {
@@ -1054,7 +1071,14 @@ export class AgentController {
         const id = user ? `${this.steeringPrefix}:${++this.steeringSequence}` : undefined;
         if (id !== undefined)
             this.pendingUserSteering.add(id);
-        this.agent.steer(text, id);
+        try {
+            this.agent.steer(text, id);
+        }
+        catch (error) {
+            if (id !== undefined)
+                this.pendingUserSteering.delete(id);
+            throw error;
+        }
         return id;
     }
     followUp(text) {
@@ -1192,6 +1216,7 @@ export class AgentController {
      * honestly by checking `isTeamRegistered()` first.
      */
     setTeamEnabled(enabled) {
+        this.settingsRevision += 1;
         this.teamEnabled = enabled;
         this.rebuildSystemPrompt();
     }
@@ -1205,6 +1230,7 @@ export class AgentController {
      */
     setTeamConfig(patch) {
         const team = clampTeamConfig({ ...this.config.team, ...patch });
+        this.settingsRevision += 1;
         this.config = { ...this.config, team };
         this.rebuildSystemPrompt();
         return team;
@@ -1230,6 +1256,9 @@ export class AgentController {
     }
     /** Abort every child and clear timers. Idempotent; safe to call twice. */
     dispose() {
+        this.disposed = true;
+        this.modelMetadataGeneration += 1;
+        this.modelMetadataAbort.abort();
         this.teamRuntime?.dispose();
         this.fast?.dispose();
         this.compaction?.dispose();
@@ -1266,6 +1295,7 @@ export class AgentController {
      * reports that honestly by checking `isTodoRegistered()` first.
      */
     setTodoEnabled(enabled) {
+        this.settingsRevision += 1;
         this.todoEnabled = enabled;
         this.rebuildSystemPrompt();
     }
@@ -1288,6 +1318,7 @@ export class AgentController {
      */
     setTodoConfig(patch) {
         const todo = clampTodoConfig({ ...this.config.todo, ...patch });
+        this.settingsRevision += 1;
         this.config = { ...this.config, todo };
         this.rebuildSystemPrompt();
         return todo;
@@ -1343,6 +1374,7 @@ export class AgentController {
      */
     setRetryConfig(patch) {
         const retry = clampRetryConfig({ ...this.config.retry, ...patch });
+        this.settingsRevision += 1;
         this.config = { ...this.config, retry };
         this.providerRegistry.setRetryPolicy(toRetryPolicy(retry));
         return retry;
@@ -1350,8 +1382,80 @@ export class AgentController {
     // -----------------------------------------------------------------------
     // Mutators
     // -----------------------------------------------------------------------
+    /** True while any request can still use a model or credential snapshot. */
+    isModelSettingsBusy() {
+        return this.isRunning() || this.isTeamBusy() || this.getCompactionSnapshot().inFlight
+            || this.getFastStatus().snapshot.inFlight;
+    }
+    /** Monotonic revision protects an editor from all intervening settings changes. */
+    getSettingsRevision() { return this.settingsRevision; }
+    /** Read-only draft creation; no startup migration or credential copying. */
+    createModelSettingsDraft() {
+        return createModelSettingsDraft(this.config, this.settingsRevision);
+    }
+    /** Save an explicit draft as a single disk/live transaction. */
+    saveModelSettings(draft) {
+        return saveModelSettings({ draft, controller: this });
+    }
+    /** Legacy commands share the same lossless conversion and atomic save path. */
+    saveModelSettingsPatch(patch) {
+        const draft = this.createModelSettingsDraft();
+        draft.profiles = undefined;
+        draft.patch = patch;
+        return this.saveModelSettings(draft);
+    }
+    /** Refresh both role connections and credentials while retaining conversation state. */
+    reloadModelSettings() { return reloadModelSettings(this); }
+    /** Prebuild all potentially failing model/prompt work before committing the file. */
+    prepareModelSettingsSnapshot(config) {
+        return { config, model: { providerId: config.provider, modelId: config.model,
+                ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}) },
+            systemPrompt: this.composeSystemPrompt(config) };
+    }
+    /** Apply prepared state synchronously, without rebuilding the controller or its history. */
+    applyModelSettingsSnapshot(snapshot) {
+        this.preparedSystemPrompt = snapshot.systemPrompt;
+        try {
+            this.config = snapshot.config;
+            this.settingsRevision += 1;
+            this.agent.setModel(snapshot.model);
+            this.agent.setThinkingLevel(snapshot.config.thinkingLevel);
+            this.agent.setMaxTokens(snapshot.config.maxTokens);
+            // Credentials may change even when endpoint/model do not. Invalidate
+            // before publishing a window, including when the new profile has no key.
+            if (this.modelMetadataEnabled) {
+                this.resetModelMetadataRequest();
+                this.modelRegistry.clearCache();
+            }
+            this.fast?.onConfigChanged(false, snapshot.config.fast.enabled);
+            this.compaction?.onConfigChanged(snapshot.config.compaction.enabled);
+            this.contextMeter.onWindowChanged();
+            this.rebuildSystemPrompt();
+        }
+        finally {
+            this.preparedSystemPrompt = undefined;
+        }
+        if (this.modelMetadataEnabled)
+            void this.refreshModelMetadata();
+    }
+    /** Potentially failing ordinary-setting side effects are isolated from model application. */
+    applyModelSettingsEffects() { getLogger().reconfigure(this.config.log); }
+    /** A partially applied model snapshot must never reach another provider request. */
+    blockModelSettingsRequests() {
+        this.modelSettingsBlocked = true;
+        this.config.modelSettingsRestartRequired = true;
+        this.resetModelMetadataRequest();
+    }
+    /** The UI uses this before accepting or draining queued prompts. */
+    areModelSettingsBlocked() { return this.modelSettingsBlocked; }
     setModel(provider, model, baseUrl) {
+        if (this.isModelSettingsBusy())
+            throw new Error('Model settings are busy.');
+        if (this.modelMetadataEnabled)
+            this.resetModelMetadataRequest();
+        this.settingsRevision += 1;
         this.config = { ...this.config, provider, model, baseUrl };
+        this.config.modelProfileState = resolveModelProfileState(this.config);
         this.agent.setModel({ providerId: provider, modelId: model, ...(baseUrl ? { baseUrl } : {}) });
         // NOT NEUTRAL TO THE FAST TIER even when the user never touched a `fast.*`
         // key (§3.9 / RV-3): `fast.provider: ''` and `fast.baseUrl: ''` INHERIT from
@@ -1371,22 +1475,33 @@ export class AgentController {
         // numerator's calibration is one turn stale until the next `turn_end`
         // (RV-13), which is the trade this call names.
         this.contextMeter.onWindowChanged();
+        if (this.modelMetadataEnabled)
+            void this.refreshModelMetadata();
     }
     setThinkingLevel(level) {
+        this.settingsRevision += 1;
         this.config = { ...this.config, thinkingLevel: level };
         this.agent.setThinkingLevel(level);
     }
     setMaxTokens(value) {
+        this.settingsRevision += 1;
         this.config = { ...this.config, maxTokens: value };
         this.agent.setMaxTokens(value);
     }
     setApiKey(provider, key) {
         // The Agent resolves keys via `resolveKey(this.config)` at call time, so
         // updating the config here is sufficient — no Agent rebuild needed.
+        this.settingsRevision += 1;
         this.config = {
             ...this.config,
             apiKeys: { ...this.config.apiKeys, [provider]: key },
         };
+        if (this.modelMetadataEnabled) {
+            this.resetModelMetadataRequest();
+            this.modelRegistry.clearCache(provider);
+            this.contextMeter.onWindowChanged();
+            void this.refreshModelMetadata();
+        }
         // Rule 5 of §3.2 reads `apiKeys`, so a key edit is a tier event: this is the
         // path that turns `no_key` back into a working tier without a relaunch.
         this.fast?.onConfigChanged();
@@ -1397,6 +1512,7 @@ export class AgentController {
     }
     setCwd(cwd) {
         this.cwd = cwd;
+        this.settingsRevision += 1;
         this.config = { ...this.config, cwd };
         // The project scope moved with the cwd, so rescan BEFORE rebuilding — then
         // let the single prompt entry point emit a prompt that reflects both the new
@@ -1544,9 +1660,38 @@ export class AgentController {
      */
     getModelInfoFor(ref) {
         const found = this.modelRegistry.getModel(ref.providerId, ref.modelId);
-        if (found)
-            return found;
-        return this.modelRegistry.buildRuntimeModel(ref.providerId, ref.modelId);
+        const baseUrl = ref.baseUrl ?? (ref.providerId === this.config.provider && ref.modelId === this.config.model
+            ? this.config.baseUrl : undefined);
+        return {
+            ...(found ?? this.modelRegistry.buildRuntimeModel(ref.providerId, ref.modelId)),
+            ...this.modelRegistry.getContextWindow(ref.providerId, ref.modelId, baseUrl),
+        };
+    }
+    /** Best-effort metadata lookup; never block typing or a model request. */
+    async refreshModelMetadata() {
+        if (this.disposed || this.modelSettingsBlocked)
+            return;
+        this.modelMetadataEnabled = true;
+        const generation = ++this.modelMetadataGeneration;
+        const { provider, baseUrl } = this.config;
+        try {
+            const key = this.resolveKey(provider);
+            if (!key)
+                return;
+            await this.modelRegistry.discoverModels(provider, key, baseUrl, this.modelMetadataAbort.signal);
+            if (this.disposed || generation !== this.modelMetadataGeneration)
+                return;
+            this.contextMeter.onWindowChanged();
+        }
+        catch {
+            // Offline or unsupported discovery leaves catalog/unknown metadata intact.
+        }
+    }
+    /** Invalidate an old connection without restarting a lookup on every prompt. */
+    resetModelMetadataRequest() {
+        this.modelMetadataGeneration += 1;
+        this.modelMetadataAbort.abort();
+        this.modelMetadataAbort = new AbortController();
     }
     /**
      * Whether the STATIC table knows this model's price (C-11 / RV-4).
@@ -1581,6 +1726,7 @@ export class AgentController {
      * `/fast` reports that honestly by checking `isFastRegistered()` first.
      */
     setFastEnabled(enabled) {
+        this.settingsRevision += 1;
         this.fast?.setEnabled(enabled);
     }
     getFastConfig() {
@@ -1596,6 +1742,7 @@ export class AgentController {
      */
     setFastConfig(patch) {
         const fast = clampFastConfig({ ...this.config.fast, ...patch });
+        this.settingsRevision += 1;
         this.config = { ...this.config, fast };
         // `onConfigChanged` rebuilds the prompt; when there is no wiring (the tier
         // was never registered) nothing has to be rebuilt, because no block is
@@ -1695,6 +1842,7 @@ export class AgentController {
      * on purpose (§3.2).
      */
     setCompactionEnabled(enabled) {
+        this.settingsRevision += 1;
         this.compaction?.setEnabled(enabled);
     }
     getCompactionConfig() {
@@ -1709,6 +1857,7 @@ export class AgentController {
      */
     setCompactionConfig(patch) {
         const compaction = clampCompactionConfig({ ...this.config.compaction, ...patch });
+        this.settingsRevision += 1;
         this.config = { ...this.config, compaction };
         this.compaction?.onConfigChanged();
         return compaction;
@@ -1757,6 +1906,8 @@ export class AgentController {
      * unbypassable. `replaceMessages` validates NOTHING.
      */
     async compactNow(instructions) {
+        if (this.modelSettingsBlocked)
+            return { ok: false, reason: 'settings_restart_required' };
         if (!this.compaction)
             return { ok: false, reason: 'not_registered' };
         const controller = new AbortController();

package/dist/agent/model-profile-settings.d.ts

@@ -0,0 +1,31 @@
+import type { ModelRef } from '@aragon-agent/core';
+import { type CliConfig } from '../config/schema.js';
+import { type ModelSettingsDraft, type ModelSettingsSaveResult } from '../config/model-profile-store.js';
+/** Fully prepared live state; applying it performs no input parsing or disk access. */
+export interface ModelSettingsSnapshot {
+    config: CliConfig;
+    model: ModelRef;
+    systemPrompt: string;
+}
+/** Narrow controller port keeps persistence independent from the agent implementation. */
+export interface ModelSettingsController {
+    getConfig(): CliConfig;
+    getSettingsRevision(): number;
+    isModelSettingsBusy(): boolean;
+    isFastRegistered(): boolean;
+    prepareModelSettingsSnapshot(config: CliConfig): ModelSettingsSnapshot;
+    applyModelSettingsSnapshot(snapshot: ModelSettingsSnapshot): void;
+    applyModelSettingsEffects(): void;
+    blockModelSettingsRequests(): void;
+}
+/** Capture both baselines when the editor opens, without migrating or writing anything. */
+export declare function createModelSettingsDraft(live: CliConfig, liveRevision: number): ModelSettingsDraft;
+/** Map stable failure codes to safe UI text; never include parser or SDK error messages. */
+export declare function modelSettingsResultMessage(result: ModelSettingsSaveResult): string;
+/** Validate and prepare everything before the one synchronous, atomic disk commit. */
+export declare function saveModelSettings(input: {
+    draft: ModelSettingsDraft;
+    controller: ModelSettingsController;
+}): ModelSettingsSaveResult;
+/** Reload the complete model snapshot; invalid disk content never replaces a live session. */
+export declare function reloadModelSettings(controller: ModelSettingsController): ModelSettingsSaveResult;