@dreb/coding-agent 2.53.1 → 2.54.0

package/dist/modes/rpc/rpc-mode.js

@@ -18,7 +18,7 @@ import { canonicalizeTrustedRoots, matchContextTrust, validateTrustedContextFold
 import { DailyCostTracker } from "../../core/daily-cost-tracker.js";
 import { acquireDreamLock, buildDreamPrompt, cleanupDreamTmpDirs, parseDreamCommand, performDreamBackup, pruneOldBackups, resolveDreamContext, validateArchivePath, validateMemoryLinks, } from "../../core/dream.js";
 import { getGitBranch } from "../../core/git-branch.js";
-import { parseModelPattern } from "../../core/model-resolver.js";
+import { parseModelPattern, resolveModelScopePatterns } from "../../core/model-resolver.js";
 import { takeOverStdout, writeRawStdout } from "../../core/output-guard.js";
 import { SessionManager } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS, parseBuiltinSlashCommand } from "../../core/slash-commands.js";
@@ -281,9 +281,12 @@ export function listAgentTypesForRpc(cwd) {
  * These seed fresh runtimes, NOT the live session state (`get_state` reports that). Extracted
  * (like {@link deleteSessionForRpc}) so it is unit-testable without a live RPC session.
  */
-export function getSettingsForRpc(settingsManager) {
+export function getSettingsForRpc(settingsManager, availableModels = []) {
     const contextTrust = settingsManager.getGlobalContextTrustPolicy();
     const configuredTrustedFolders = settingsManager.getConfiguredTrustedContextFolders();
+    const enabledModels = settingsManager.getEnabledModels();
+    const hasProjectEnabledModelsOverride = settingsManager.hasProjectEnabledModelsOverride();
+    const scopeResolution = resolveModelScopePatterns(enabledModels ?? [], availableModels);
     return {
         defaultProvider: settingsManager.getDefaultProvider(),
         defaultModel: settingsManager.getDefaultModel(),
@@ -302,8 +305,26 @@ export function getSettingsForRpc(settingsManager) {
         hideThinkingBlock: settingsManager.getHideThinkingBlock(),
         agentModels: settingsManager.getAgentModels(),
         subagentArbiter: settingsManager.getGlobalSubagentArbiterSettings(),
+        enabledModels,
+        resolvedScopedModels: scopeResolution.models.map(({ model, thinkingLevel }) => ({
+            provider: model.provider,
+            id: model.id,
+            name: model.name,
+            reasoning: model.reasoning,
+            ...(thinkingLevel !== undefined ? { thinkingLevel } : {}),
+        })),
+        scopeWarnings: scopeResolution.warnings,
+        hasProjectEnabledModelsOverride,
+        enabledModelsSource: hasProjectEnabledModelsOverride
+            ? "project"
+            : enabledModels === undefined
+                ? "default"
+                : "global",
     };
 }
+async function buildSettingsSnapshotForRpc(settingsManager, modelRegistry) {
+    return getSettingsForRpc(settingsManager, modelRegistry ? await modelRegistry.getAvailable() : []);
+}
 function formatSettingsErrors(errors) {
     return errors.map((entry) => `${entry.scope}: ${entry.error.message}`).join("; ");
 }
@@ -316,7 +337,7 @@ function formatSettingsErrors(errors) {
  * content. Reload failures leave SettingsManager's previous values in memory, therefore
  * they must be surfaced as an RPC error instead of producing a stale snapshot.
  */
-export async function getFreshSettingsForRpc(settingsManager) {
+export async function getFreshSettingsForRpc(settingsManager, modelRegistry) {
     return settingsWriteLock(async () => {
         try {
             // A runtime setter may have enqueued a write outside the RPC settings lock.
@@ -349,7 +370,13 @@ export async function getFreshSettingsForRpc(settingsManager) {
                 error: detail ? `Failed to reload settings: ${detail}` : "Failed to reload settings from durable storage",
             };
         }
-        return { ok: true, settings: getSettingsForRpc(settingsManager) };
+        try {
+            const availableModels = modelRegistry ? await modelRegistry.getAvailable() : [];
+            return { ok: true, settings: getSettingsForRpc(settingsManager, availableModels) };
+        }
+        catch (error) {
+            return { ok: false, error: `Failed to load available models: ${error.message}` };
+        }
     });
 }
 const SETTINGS_UPDATE_KEYS = [
@@ -368,6 +395,7 @@ const SETTINGS_UPDATE_KEYS = [
     "transport",
     "hideThinkingBlock",
     "agentModels",
+    "enabledModels",
     "subagentArbiter",
 ];
 const QUEUE_MODES = ["all", "one-at-a-time"];
@@ -450,7 +478,7 @@ function settingsWriteLock(fn) {
     settingsWriteQueue = next.catch(() => { });
     return next;
 }
-async function persistContextTrustMutationForRpc(settingsManager, folders, targetPath, mutation) {
+async function persistContextTrustMutationForRpc(settingsManager, folders, targetPath, mutation, modelRegistry) {
     settingsManager.drainErrors();
     if (settingsManager.hasGlobalSettingsLoadError()) {
         return {
@@ -482,11 +510,15 @@ async function persistContextTrustMutationForRpc(settingsManager, folders, targe
         return evaluated;
     return {
         ok: true,
-        result: { evaluation: evaluated.evaluation, settings: getSettingsForRpc(settingsManager), ...mutation },
+        result: {
+            evaluation: evaluated.evaluation,
+            settings: await buildSettingsSnapshotForRpc(settingsManager, modelRegistry),
+            ...mutation,
+        },
     };
 }
 /** Add a canonical directory to the global trusted roots and flush the change. */
-export async function trustContextFolderForRpc(settingsManager, path) {
+export async function trustContextFolderForRpc(settingsManager, path, modelRegistry) {
     return settingsWriteLock(async () => {
         const evaluated = evaluateContextTrustForRpc(settingsManager, path);
         if (!evaluated.ok)
@@ -505,11 +537,11 @@ export async function trustContextFolderForRpc(settingsManager, path) {
             ...(folders.includes(evaluated.evaluation.canonicalTarget)
                 ? { addedRoot: evaluated.evaluation.canonicalTarget }
                 : {}),
-        });
+        }, modelRegistry);
     });
 }
 /** Remove the root actually granting a directory access, rather than the supplied descendant. */
-export async function untrustContextFolderForRpc(settingsManager, path) {
+export async function untrustContextFolderForRpc(settingsManager, path, modelRegistry) {
     return settingsWriteLock(async () => {
         const evaluated = evaluateContextTrustForRpc(settingsManager, path);
         if (!evaluated.ok)
@@ -523,16 +555,19 @@ export async function untrustContextFolderForRpc(settingsManager, path) {
         if (evaluated.evaluation.state === "untrusted") {
             return {
                 ok: true,
-                result: { evaluation: evaluated.evaluation, settings: getSettingsForRpc(settingsManager) },
+                result: {
+                    evaluation: evaluated.evaluation,
+                    settings: await buildSettingsSnapshotForRpc(settingsManager, modelRegistry),
+                },
             };
         }
         const removedRoot = evaluated.evaluation.grantingRoot;
         const roots = canonicalizeTrustedRoots(settingsManager.getConfiguredTrustedContextFolders());
-        return persistContextTrustMutationForRpc(settingsManager, roots.filter((root) => root !== removedRoot), evaluated.evaluation.canonicalTarget, { removedRoot });
+        return persistContextTrustMutationForRpc(settingsManager, roots.filter((root) => root !== removedRoot), evaluated.evaluation.canonicalTarget, { removedRoot }, modelRegistry);
     });
 }
 /** Remove a configured trusted-folder string exactly as stored and flush the change. */
-export async function removeTrustedContextFolderForRpc(settingsManager, path) {
+export async function removeTrustedContextFolderForRpc(settingsManager, path, modelRegistry) {
     return settingsWriteLock(async () => {
         if (typeof path !== "string" || path.length === 0) {
             return { ok: false, error: "remove_trusted_context_folder requires a non-empty string path" };
@@ -563,7 +598,13 @@ export async function removeTrustedContextFolderForRpc(settingsManager, path) {
             settingsManager.reload();
             return { ok: false, error: `Failed to persist settings: ${detail}` };
         }
-        return { ok: true, result: { settings: getSettingsForRpc(settingsManager), removedFolder: path } };
+        return {
+            ok: true,
+            result: {
+                settings: await buildSettingsSnapshotForRpc(settingsManager, modelRegistry),
+                removedFolder: path,
+            },
+        };
     });
 }
 /**
@@ -646,6 +687,48 @@ export async function setSettingsForRpc(settingsManager, modelRegistry, update)
             return validation;
         }
     }
+    let canonicalEnabledModels;
+    if (update.enabledModels !== undefined && update.enabledModels !== null) {
+        if (!Array.isArray(update.enabledModels)) {
+            return {
+                ok: false,
+                error: "Invalid enabledModels: must be a non-empty array of exact model references or null",
+            };
+        }
+        if (update.enabledModels.length === 0) {
+            return {
+                ok: false,
+                error: "Invalid enabledModels: at least one model must remain enabled; use null to enable all",
+            };
+        }
+        const availableModels = await modelRegistry.getAvailable();
+        const seen = new Set();
+        canonicalEnabledModels = [];
+        for (const reference of update.enabledModels) {
+            if (typeof reference !== "string" || reference.trim().length === 0 || reference !== reference.trim()) {
+                return { ok: false, error: "Invalid enabledModels: every entry must be a non-empty exact model reference" };
+            }
+            const normalizedReference = reference.toLowerCase();
+            const matches = availableModels.filter((model) => `${model.provider}/${model.id}`.toLowerCase() === normalizedReference);
+            if (matches.length !== 1) {
+                return {
+                    ok: false,
+                    error: `Invalid enabledModels entry ${JSON.stringify(reference)}: expected an available exact provider/model reference`,
+                };
+            }
+            const match = matches[0];
+            const canonical = `${match.provider}/${match.id}`;
+            if (seen.has(canonical)) {
+                return { ok: false, error: `Invalid enabledModels: duplicate model ${JSON.stringify(canonical)}` };
+            }
+            seen.add(canonical);
+            canonicalEnabledModels.push(canonical);
+        }
+        if (canonicalEnabledModels.length === availableModels.length &&
+            availableModels.every((model) => seen.has(`${model.provider}/${model.id}`))) {
+            canonicalEnabledModels = undefined;
+        }
+    }
     let subagentArbiter = update.subagentArbiter === null ? undefined : update.subagentArbiter;
     if (subagentArbiter !== undefined) {
         if (!isPlainObject(subagentArbiter)) {
@@ -789,6 +872,12 @@ export async function setSettingsForRpc(settingsManager, modelRegistry, update)
                 settingsManager.setHideThinkingBlock(update.hideThinkingBlock);
             }
             const warnings = [];
+            if (update.enabledModels !== undefined) {
+                if (settingsManager.hasProjectEnabledModelsOverride()) {
+                    warnings.push("A project-level enabledModels value (.dreb/settings.json) takes precedence — this change to global settings will have no effect. Edit the project settings file to change it.");
+                }
+                settingsManager.setEnabledModels(canonicalEnabledModels);
+            }
             if (update.subagentArbiter !== undefined) {
                 settingsManager.setGlobalSubagentArbiterSettings(subagentArbiter);
             }
@@ -832,9 +921,10 @@ export async function setSettingsForRpc(settingsManager, modelRegistry, update)
                     return { ok: false, error: `Failed to persist settings: ${detail}` };
                 }
             }
+            const snapshot = getSettingsForRpc(settingsManager, await modelRegistry.getAvailable());
             return warnings.length > 0
-                ? { ok: true, settings: getSettingsForRpc(settingsManager), warnings }
-                : { ok: true, settings: getSettingsForRpc(settingsManager) };
+                ? { ok: true, settings: snapshot, warnings }
+                : { ok: true, settings: snapshot };
         }
         catch (error) {
             if (updatesContextTrustPolicy) {
@@ -1693,7 +1783,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
             // Settings (persistent defaults)
             // =================================================================
             case "get_settings": {
-                const result = await getFreshSettingsForRpc(session.settingsManager);
+                const result = await getFreshSettingsForRpc(session.settingsManager, session.modelRegistry);
                 return result.ok ? success(id, "get_settings", result.settings) : error(id, "get_settings", result.error);
             }
             case "set_settings": {
@@ -1712,19 +1802,19 @@ export async function runRpcMode(session, modelFallbackMessage) {
                     : error(id, "evaluate_context_trust", result.error);
             }
             case "trust_context_folder": {
-                const result = await trustContextFolderForRpc(session.settingsManager, command.path);
+                const result = await trustContextFolderForRpc(session.settingsManager, command.path, session.modelRegistry);
                 return result.ok
                     ? success(id, "trust_context_folder", result.result)
                     : error(id, "trust_context_folder", result.error);
             }
             case "untrust_context_folder": {
-                const result = await untrustContextFolderForRpc(session.settingsManager, command.path);
+                const result = await untrustContextFolderForRpc(session.settingsManager, command.path, session.modelRegistry);
                 return result.ok
                     ? success(id, "untrust_context_folder", result.result)
                     : error(id, "untrust_context_folder", result.error);
             }
             case "remove_trusted_context_folder": {
-                const result = await removeTrustedContextFolderForRpc(session.settingsManager, command.path);
+                const result = await removeTrustedContextFolderForRpc(session.settingsManager, command.path, session.modelRegistry);
                 return result.ok
                     ? success(id, "remove_trusted_context_folder", result.result)
                     : error(id, "remove_trusted_context_folder", result.error);