@dreb/coding-agent 2.45.4 → 2.47.0

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

@@ -21,6 +21,7 @@ import { parseModelPattern } from "../../core/model-resolver.js";
 import { takeOverStdout, writeRawStdout } from "../../core/output-guard.js";
 import { SessionManager } from "../../core/session-manager.js";
 import { TabTitleGenerator } from "../../core/tab-title.js";
+import { validateThinkingLevelForModel } from "../../core/thinking.js";
 import { discoverAgentTypes, getBackgroundAgents, rehydrateBackgroundAgentsFromDisk, } from "../../core/tools/subagent.js";
 import { theme } from "../interactive/theme/theme.js";
 import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
@@ -155,6 +156,7 @@ export function toRpcBackgroundAgentInfo(a) {
         sessionDir: a.sessionDir,
         sessionFile: a.sessionFile,
         cwd: a.cwd,
+        arbitrations: a.arbitrations?.map((record) => structuredClone(record)),
     };
 }
 /** Discover available subagent types for RPC clients, sorted by display name. */
@@ -191,6 +193,7 @@ export function getSettingsForRpc(settingsManager) {
         transport: settingsManager.getTransport(),
         hideThinkingBlock: settingsManager.getHideThinkingBlock(),
         agentModels: settingsManager.getAgentModels(),
+        subagentArbiter: settingsManager.getGlobalSubagentArbiterSettings(),
     };
 }
 function formatSettingsErrors(errors) {
@@ -257,6 +260,7 @@ const SETTINGS_UPDATE_KEYS = [
     "transport",
     "hideThinkingBlock",
     "agentModels",
+    "subagentArbiter",
 ];
 const QUEUE_MODES = ["all", "one-at-a-time"];
 const TRANSPORT_SETTINGS = ["sse", "websocket", "auto"];
@@ -534,6 +538,64 @@ export async function setSettingsForRpc(settingsManager, modelRegistry, update)
             return validation;
         }
     }
+    let subagentArbiter = update.subagentArbiter === null ? undefined : update.subagentArbiter;
+    if (subagentArbiter !== undefined) {
+        if (!isPlainObject(subagentArbiter)) {
+            return { ok: false, error: "subagentArbiter must be an object or null" };
+        }
+        const validKeys = ["enabled", "model", "thinking", "guidePath"];
+        const unknownArbiterKeys = Object.keys(subagentArbiter).filter((key) => !validKeys.includes(key));
+        if (unknownArbiterKeys.length > 0) {
+            return { ok: false, error: `Unknown subagentArbiter key(s): ${unknownArbiterKeys.join(", ")}` };
+        }
+        if (subagentArbiter.enabled !== undefined && typeof subagentArbiter.enabled !== "boolean") {
+            return { ok: false, error: "subagentArbiter.enabled must be a boolean" };
+        }
+        if (subagentArbiter.enabled === false) {
+            // Explicit disablement is the recovery path for fail-closed policies.
+            // Preserve retained fields without validating them so malformed manual
+            // edits cannot trap users in a policy that blocks every child spawn.
+            subagentArbiter = { ...subagentArbiter };
+        }
+        else {
+            if (subagentArbiter.model !== undefined &&
+                (typeof subagentArbiter.model !== "string" || !subagentArbiter.model.trim())) {
+                return { ok: false, error: "subagentArbiter.model must be a non-empty exact provider/model string" };
+            }
+            if (subagentArbiter.thinking !== undefined &&
+                (typeof subagentArbiter.thinking !== "string" || !isValidThinkingLevel(subagentArbiter.thinking))) {
+                return {
+                    ok: false,
+                    error: `Invalid subagentArbiter.thinking: ${JSON.stringify(subagentArbiter.thinking)}. Valid values: ${VALID_THINKING_LEVELS.join(", ")}`,
+                };
+            }
+            if (subagentArbiter.guidePath !== undefined &&
+                (typeof subagentArbiter.guidePath !== "string" || !subagentArbiter.guidePath.trim())) {
+                return { ok: false, error: "subagentArbiter.guidePath must be a non-empty string" };
+            }
+            if (subagentArbiter.enabled === true && !subagentArbiter.model) {
+                return { ok: false, error: "Enabling subagentArbiter requires an exact provider/model" };
+            }
+            if (subagentArbiter.model) {
+                const slash = subagentArbiter.model.indexOf("/");
+                if (slash <= 0 || slash === subagentArbiter.model.length - 1 || /\s/.test(subagentArbiter.model)) {
+                    return { ok: false, error: "subagentArbiter.model must be an exact provider/model" };
+                }
+                const provider = subagentArbiter.model.slice(0, slash);
+                const modelId = subagentArbiter.model.slice(slash + 1);
+                const models = await modelRegistry.getAvailable();
+                const model = models.find((candidate) => candidate.provider === provider && candidate.id === modelId);
+                if (!model)
+                    return { ok: false, error: `Arbiter model not found: ${subagentArbiter.model}` };
+                if (subagentArbiter.thinking !== undefined) {
+                    const validation = validateThinkingLevelForModel(model, subagentArbiter.thinking);
+                    if (!validation.ok)
+                        return validation;
+                }
+            }
+            subagentArbiter = { ...subagentArbiter };
+        }
+    }
     let trustedContextFolders;
     if (update.trustedContextFolders !== undefined) {
         try {
@@ -619,6 +681,9 @@ export async function setSettingsForRpc(settingsManager, modelRegistry, update)
                 settingsManager.setHideThinkingBlock(update.hideThinkingBlock);
             }
             const warnings = [];
+            if (update.subagentArbiter !== undefined) {
+                settingsManager.setGlobalSubagentArbiterSettings(subagentArbiter);
+            }
             if (update.agentModels !== undefined) {
                 for (const [agentName, models] of Object.entries(update.agentModels)) {
                     if (settingsManager.hasProjectAgentModelOverride(agentName)) {
@@ -790,77 +855,105 @@ export async function navigateTreeForRpc(session, targetId, options) {
         ...(result.editorText !== undefined ? { editorText: result.editorText } : {}),
     };
 }
-/**
- * Run in RPC mode.
- * Listens for JSON commands on stdin, outputs events and responses on stdout.
- */
-export async function runRpcMode(session, modelFallbackMessage) {
-    takeOverStdout();
-    const output = (obj) => {
-        writeRawStdout(serializeJsonLine(obj));
-    };
-    const success = (id, command, data) => {
-        if (data === undefined) {
-            return { id, type: "response", command, success: true };
-        }
-        return { id, type: "response", command, success: true, data };
-    };
-    const error = (id, command, message) => {
-        return { id, type: "response", command, success: false, error: message };
-    };
-    if (session.sessionFile && session.messages.length > 0) {
-        const rehydratedCount = rehydrateBackgroundAgentsFromDisk(session.sessionFile);
-        if (rehydratedCount > 0) {
-            console.error(`[rpc] Rehydrated ${rehydratedCount} background subagent${rehydratedCount === 1 ? "" : "s"} from disk`);
-        }
-    }
-    // Pending extension UI requests waiting for response
-    const pendingExtensionRequests = new Map();
-    // Shutdown request flag
-    let shutdownRequested = false;
-    let dailyCostTracker;
-    let dailyCostTrackerPrimed = false;
+export function createRpcExtensionUIContext(output, pendingExtensionRequests, onAskStop = () => { }) {
     /** Helper for dialog methods with signal/timeout support */
-    function createDialogPromise(opts, defaultValue, request, parseResponse) {
+    function createDialogPromise(opts, defaultValue, request, parseResponse, onTimeout) {
         if (opts?.signal?.aborted)
             return Promise.resolve(defaultValue);
         const id = crypto.randomUUID();
         return new Promise((resolve, reject) => {
             let timeoutId;
+            let settled = false;
             const cleanup = () => {
+                if (settled)
+                    return false;
+                settled = true;
                 if (timeoutId)
                     clearTimeout(timeoutId);
                 opts?.signal?.removeEventListener("abort", onAbort);
                 pendingExtensionRequests.delete(id);
+                output({ type: "extension_ui_response_handled", id });
+                return true;
             };
             const onAbort = () => {
-                cleanup();
+                if (!cleanup())
+                    return;
                 resolve(defaultValue);
             };
             opts?.signal?.addEventListener("abort", onAbort, { once: true });
             if (opts?.timeout) {
                 timeoutId = setTimeout(() => {
-                    cleanup();
+                    if (!cleanup())
+                        return;
+                    onTimeout?.();
                     resolve(defaultValue);
                 }, opts.timeout);
             }
+            const rpcRequest = {
+                type: "extension_ui_request",
+                id,
+                ...request,
+            };
             pendingExtensionRequests.set(id, {
+                request: rpcRequest,
                 resolve: (response) => {
-                    cleanup();
-                    resolve(parseResponse(response));
+                    if (!cleanup())
+                        return;
+                    try {
+                        resolve(parseResponse(response));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                },
+                reject: (error) => {
+                    if (!cleanup())
+                        return;
+                    reject(error);
                 },
-                reject,
             });
-            output({ type: "extension_ui_request", id, ...request });
+            output(rpcRequest);
         });
     }
     /**
      * Create an extension UI context that uses the RPC protocol.
      */
-    const createExtensionUIContext = () => ({
+    return {
         select: (title, options, opts) => createDialogPromise(opts, undefined, { method: "select", title, options, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined),
         confirm: (title, message, opts) => createDialogPromise(opts, false, { method: "confirm", title, message, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? false : "confirmed" in r ? r.confirmed : false),
         input: (title, placeholder, opts) => createDialogPromise(opts, undefined, { method: "input", title, placeholder, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined),
+        ask: (request, opts) => createDialogPromise(opts, undefined, {
+            method: "ask",
+            title: request.title ?? "Question",
+            question: request.question,
+            options: request.options,
+            allowFreeText: request.allowFreeText,
+            multiSelect: request.multiSelect,
+            multiline: request.multiline,
+            timeout: opts?.timeout,
+            // Preserve the authoritative deadline across Dashboard reload,
+            // resync, and drill-in hydration instead of restarting the full
+            // duration whenever the question component remounts.
+            expiresAt: opts?.timeout ? Date.now() + opts.timeout : undefined,
+        }, (response) => {
+            if ("cancelled" in response && response.cancelled) {
+                onAskStop();
+                return undefined;
+            }
+            const selected = response.selected;
+            const customText = response.customText;
+            if (!Array.isArray(selected) || !selected.every((value) => typeof value === "string")) {
+                throw new Error("Invalid RPC ask response: selected must be an array of strings");
+            }
+            if (customText !== undefined && typeof customText !== "string") {
+                throw new Error("Invalid RPC ask response: customText must be a string");
+            }
+            if (selected.length === 0 && !customText?.trim()) {
+                onAskStop();
+                return undefined;
+            }
+            return { selected, customText };
+        }, onAskStop),
         notify(message, type) {
             // Fire and forget - no response needed
             output({
@@ -939,26 +1032,11 @@ export async function runRpcMode(session, modelFallbackMessage) {
             // Host should track editor state locally if needed
             return "";
         },
-        async editor(title, prefill) {
-            const id = crypto.randomUUID();
-            return new Promise((resolve, reject) => {
-                pendingExtensionRequests.set(id, {
-                    resolve: (response) => {
-                        if ("cancelled" in response && response.cancelled) {
-                            resolve(undefined);
-                        }
-                        else if ("value" in response) {
-                            resolve(response.value);
-                        }
-                        else {
-                            resolve(undefined);
-                        }
-                    },
-                    reject,
-                });
-                output({ type: "extension_ui_request", id, method: "editor", title, prefill });
-            });
-        },
+        editor: (title, prefill) => createDialogPromise(undefined, undefined, { method: "editor", title, prefill }, (response) => "cancelled" in response && response.cancelled
+            ? undefined
+            : "value" in response
+                ? response.value
+                : undefined),
         setEditorComponent() {
             // Custom editor components not supported in RPC mode
         },
@@ -982,7 +1060,45 @@ export async function runRpcMode(session, modelFallbackMessage) {
         setToolsExpanded(_expanded) {
             // Tool expansion not supported in RPC mode - no TUI
         },
-    });
+    };
+}
+/** Cancel every pending dialog during RPC host teardown. */
+export function cancelPendingRpcExtensionRequests(pendingExtensionRequests) {
+    for (const [id, pending] of [...pendingExtensionRequests]) {
+        pending.resolve({ type: "extension_ui_response", id, cancelled: true });
+    }
+}
+export async function runRpcMode(session, modelFallbackMessage) {
+    takeOverStdout();
+    const output = (obj) => {
+        writeRawStdout(serializeJsonLine(obj));
+    };
+    const success = (id, command, data) => {
+        if (data === undefined) {
+            return { id, type: "response", command, success: true };
+        }
+        return { id, type: "response", command, success: true, data };
+    };
+    const error = (id, command, message) => {
+        return { id, type: "response", command, success: false, error: message };
+    };
+    if (session.sessionFile && session.messages.length > 0) {
+        const rehydratedCount = rehydrateBackgroundAgentsFromDisk(session.sessionFile);
+        if (rehydratedCount > 0) {
+            console.error(`[rpc] Rehydrated ${rehydratedCount} background subagent${rehydratedCount === 1 ? "" : "s"} from disk`);
+        }
+    }
+    // Pending extension UI requests waiting for response. Keep the emitted
+    // payload alongside its callbacks so recovery snapshots can reconstruct the
+    // answer UI after a Dashboard reload or replay gap.
+    const pendingExtensionRequests = new Map();
+    // Shutdown request flag
+    let shutdownRequested = false;
+    let dailyCostTracker;
+    let dailyCostTrackerPrimed = false;
+    // Extension UI context uses the RPC protocol; built by a module-scope
+    // factory so the dialog round trip is unit-testable (see createRpcExtensionUIContext).
+    const createExtensionUIContext = () => createRpcExtensionUIContext(output, pendingExtensionRequests, () => void session.abort());
     // Set up extensions with RPC-based UI context
     await session.bindExtensions({
         uiContext: createExtensionUIContext(),
@@ -1121,6 +1237,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
                     state: getStateForRpc(session, modelFallbackMessage),
                     messages: getDashboardMessagesForRpc(session),
                     backgroundAgents: getBackgroundAgents().map(toRpcBackgroundAgentInfo),
+                    pendingExtensionUiRequests: [...pendingExtensionRequests.values()].map(({ request }) => request),
                 };
                 return success(id, "get_dashboard_snapshot", data);
             }
@@ -1450,6 +1567,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
      */
     let detachInput = () => { };
     async function shutdown() {
+        cancelPendingRpcExtensionRequests(pendingExtensionRequests);
         const currentRunner = session.extensionRunner;
         if (currentRunner?.hasHandlers("session_shutdown")) {
             await currentRunner.emit({ type: "session_shutdown" });