@dreb/coding-agent 2.18.0 → 2.19.1

package/dist/core/tools/subagent.js

@@ -3,11 +3,13 @@ import { randomBytes } from "node:crypto";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+import { complete } from "@dreb/ai";
 import { Text } from "@dreb/tui";
 import { Type } from "@sinclair/typebox";
 import { CONFIG_DIR_NAME, getPackageDir, getSubagentSessionsDir } from "../../config.js";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
 import { attachJsonlLineReader } from "../../modes/rpc/jsonl.js";
+import { log } from "../logger.js";
 import { resolveCliModel } from "../model-resolver.js";
 import { getTextOutput, invalidArgText, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
@@ -86,20 +88,20 @@ function loadAgentsFromDir(dir, agents) {
                 const content = readFileSync(join(dir, file), "utf-8");
                 const parsed = parseAgentFrontmatter(content);
                 if (!parsed.ok) {
-                    console.error(`[subagent] Skipping agent file ${join(dir, file)}: ${parsed.error}`);
+                    log.warn(`[subagent] Skipping agent file ${join(dir, file)}: ${parsed.error}`);
                 }
                 else {
                     agents.set(parsed.config.name, parsed.config);
                 }
             }
             catch (err) {
-                console.error(`[subagent] Could not read agent file ${join(dir, file)}: ${err instanceof Error ? err.message : String(err)}`);
+                log.warn(`[subagent] Could not read agent file ${join(dir, file)}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
     }
     catch (err) {
         if (err.code !== "ENOENT") {
-            console.error(`[subagent] Could not read agents directory ${dir}: ${err instanceof Error ? err.message : String(err)}`);
+            log.warn(`[subagent] Could not read agents directory ${dir}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
 }
@@ -140,7 +142,7 @@ function findDrebBinary() {
 }
 async function spawnSubagent(agentConfig, task, cwd, signal, onProgress, parentProvider, sessionDir) {
     const drebBin = findDrebBinary();
-    console.error(`[subagent] spawn: agent=${agentConfig.name} cwd=${cwd}`);
+    log.debug(`[subagent] spawn: agent=${agentConfig.name} cwd=${cwd}`);
     // Validate cwd exists — spawn() throws a misleading ENOENT blaming the
     // binary when the cwd is invalid, making the real cause hard to diagnose
     if (!existsSync(cwd)) {
@@ -226,12 +228,12 @@ async function spawnSubagent(agentConfig, task, cwd, signal, onProgress, parentP
             }
         });
         proc.stderr?.on("error", (err) => {
-            console.error(`[subagent] stderr stream error (agent=${agentConfig.name}): ${err.message}`);
+            log.warn(`[subagent] stderr stream error (agent=${agentConfig.name}): ${err.message}`);
         });
         // Parse JSONL events from stdout
         if (proc.stdout) {
             proc.stdout.on("error", (err) => {
-                console.error(`[subagent] stdout stream error (agent=${agentConfig.name}): ${err.message}`);
+                log.warn(`[subagent] stdout stream error (agent=${agentConfig.name}): ${err.message}`);
             });
             attachJsonlLineReader(proc.stdout, (line) => {
                 if (!line.trim())
@@ -247,7 +249,7 @@ async function spawnSubagent(agentConfig, task, cwd, signal, onProgress, parentP
                     // (e.g. startup errors printed before JSONL mode begins)
                     plainStdoutLines.push(line.trim());
                     if (line.trim().startsWith("{")) {
-                        console.error(`[subagent] Failed to parse JSONL event: ${line.slice(0, 200)}`);
+                        log.warn(`[subagent] Failed to parse JSONL event: ${line.slice(0, 200)}`);
                     }
                     return;
                 }
@@ -303,7 +305,7 @@ async function spawnSubagent(agentConfig, task, cwd, signal, onProgress, parentP
             signal?.removeEventListener("abort", onAbort);
             const exitCode = code ?? 1;
             const stderr = stderrChunks.join("");
-            console.error(`[subagent] close: agent=${agentConfig.name} exit=${exitCode} messages=${collectedMessages.length}${exitCode !== 0 ? ` stderr=${stderr.slice(0, 200)} stdout=${plainStdoutLines.join("|").slice(0, 200)}` : ""}`);
+            log.debug(`[subagent] close: agent=${agentConfig.name} exit=${exitCode} messages=${collectedMessages.length}${exitCode !== 0 ? ` stderr=${stderr.slice(0, 200)} stdout=${plainStdoutLines.join("|").slice(0, 200)}` : ""}`);
             // Extract final text output from collected assistant messages
             const outputParts = [];
             for (const msg of collectedMessages) {
@@ -374,12 +376,12 @@ export function discoverSessionFile(sessionDir, agentName) {
             }
         }
         if (best) {
-            console.error(`[subagent] session file: ${best.path} (agent=${agentName})`);
+            log.debug(`[subagent] session file: ${best.path} (agent=${agentName})`);
             return best.path;
         }
     }
     catch (err) {
-        console.error(`[subagent] failed to discover session file (agent=${agentName}): ${err instanceof Error ? err.message : String(err)}`);
+        log.warn(`[subagent] failed to discover session file (agent=${agentName}): ${err instanceof Error ? err.message : String(err)}`);
     }
     return undefined;
 }
@@ -458,6 +460,173 @@ export function resolveModelStringSingle(modelStr, parentProvider, registry) {
     }
     return { ok: true, modelId: resolved.model.id, provider: resolved.model.provider };
 }
+function compactErrorReason(reason) {
+    const singleLine = reason.replace(/\s+/g, " ").trim();
+    return singleLine.length > 180 ? `${singleLine.slice(0, 177)}...` : singleLine || "unknown error";
+}
+function reasonFromRuntimeError(value) {
+    if (value instanceof Error)
+        return value.message;
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object") {
+        const maybeMessage = value;
+        if (typeof maybeMessage.errorMessage === "string")
+            return maybeMessage.errorMessage;
+        if (typeof maybeMessage.message === "string")
+            return maybeMessage.message;
+    }
+    return String(value);
+}
+export function isRuntimeUnavailableError(value) {
+    if (value instanceof Error || typeof value === "string")
+        return true;
+    if (value && typeof value === "object") {
+        const maybeMessage = value;
+        return maybeMessage.stopReason === "error" || maybeMessage.stopReason === "aborted";
+    }
+    return false;
+}
+function makeProbeSignal(parentSignal, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutError = new Error(`Model availability probe timed out after ${timeoutMs}ms`);
+    let timeout;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+            controller.abort(timeoutError);
+            reject(timeoutError);
+        }, timeoutMs);
+    });
+    const parentAbortHandler = () => controller.abort(parentSignal?.reason);
+    parentSignal?.addEventListener("abort", parentAbortHandler, { once: true });
+    if (parentSignal?.aborted)
+        controller.abort(parentSignal.reason);
+    return {
+        signal: controller.signal,
+        timeoutPromise,
+        cleanup: () => {
+            clearTimeout(timeout);
+            parentSignal?.removeEventListener("abort", parentAbortHandler);
+        },
+    };
+}
+export async function probeModelAvailability(model, options = {}) {
+    const { signal, registry, timeoutMs = 10_000 } = options;
+    if (signal?.aborted)
+        return { ok: false, reason: "Aborted before spawn", aborted: true };
+    const probeSignal = makeProbeSignal(signal, timeoutMs);
+    try {
+        const context = {
+            systemPrompt: "You are a model availability probe. Reply briefly.",
+            messages: [{ role: "user", content: "hi", timestamp: Date.now() }],
+        };
+        const apiKey = await Promise.race([
+            registry ? registry.getApiKey(model) : Promise.resolve(undefined),
+            probeSignal.timeoutPromise,
+        ]);
+        if (signal?.aborted)
+            return { ok: false, reason: "Aborted before spawn", aborted: true };
+        const result = await Promise.race([
+            complete(model, context, {
+                apiKey,
+                maxRetryDelayMs: 0,
+                maxTokens: 1,
+                signal: probeSignal.signal,
+            }),
+            probeSignal.timeoutPromise,
+        ]);
+        if (signal?.aborted)
+            return { ok: false, reason: "Aborted before spawn", aborted: true };
+        if (isRuntimeUnavailableError(result)) {
+            return { ok: false, reason: compactErrorReason(reasonFromRuntimeError(result)) };
+        }
+        return { ok: true };
+    }
+    catch (err) {
+        if (signal?.aborted)
+            return { ok: false, reason: "Aborted before spawn", aborted: true };
+        return { ok: false, reason: compactErrorReason(reasonFromRuntimeError(err)) };
+    }
+    finally {
+        probeSignal.cleanup();
+    }
+}
+export async function resolveModelForSubagentSpawn(models, parentProvider, registry, parentModel, signal) {
+    if (signal?.aborted)
+        return { ok: false, error: "Aborted before spawn", skippedModels: [] };
+    // Runtime probing only applies to agent definition fallback lists. Single
+    // models, per-invocation overrides, and registry-less environments keep the
+    // existing spawn-time resolution behavior exactly.
+    if (!Array.isArray(models) || !registry) {
+        const resolved = resolveModelWithFallbacks(models, parentProvider, registry, parentModel);
+        return { ...resolved, skippedModels: [] };
+    }
+    const skippedModels = [];
+    let lastError = "";
+    for (const modelStr of models) {
+        if (signal?.aborted)
+            return { ok: false, error: "Aborted before spawn", skippedModels };
+        const resolved = resolveModelStringSingle(modelStr, parentProvider, registry);
+        if (!resolved.ok) {
+            lastError = resolved.error;
+            const reason = compactErrorReason(resolved.error);
+            skippedModels.push({ model: modelStr, reason });
+            log.warn(`[subagent] Model "${modelStr}" unavailable (${reason}). Trying next fallback...`);
+            continue;
+        }
+        const modelObj = resolved.provider ? registry.find(resolved.provider, resolved.modelId) : undefined;
+        if (modelObj) {
+            const probe = await probeModelAvailability(modelObj, { signal, registry });
+            if (!probe.ok && probe.aborted) {
+                return { ok: false, error: "Aborted before spawn", skippedModels };
+            }
+            if (signal?.aborted)
+                return { ok: false, error: "Aborted before spawn", skippedModels };
+            if (!probe.ok) {
+                lastError = probe.reason;
+                skippedModels.push({ model: modelStr, reason: probe.reason });
+                log.warn(`[subagent] Model "${modelStr}" failed probe (${probe.reason}). Trying next fallback...`);
+                continue;
+            }
+        }
+        log.debug(`[subagent] Using model "${resolved.modelId}" for subagent.`);
+        return { ...resolved, skippedModels };
+    }
+    if (signal?.aborted)
+        return { ok: false, error: "Aborted before spawn", skippedModels };
+    if (parentModel) {
+        const parentResolved = resolveModelStringSingle(parentModel, parentProvider, registry);
+        if (parentResolved.ok) {
+            const warning = `Agent preferred models were unavailable. Falling back to parent model "${parentResolved.modelId}".`;
+            log.warn(`[subagent] ${warning}`);
+            return { ...parentResolved, warning, skippedModels };
+        }
+        lastError = parentResolved.error;
+    }
+    return {
+        ok: false,
+        skippedModels,
+        error: `None of the fallback models passed availability checks: ${[
+            ...models,
+            ...(parentModel ? [parentModel] : []),
+        ].join(", ")}. Last error: ${lastError || "all probes failed"}`,
+    };
+}
+export function formatModelFallbackSummary(skippedModels, selectedModel) {
+    if (skippedModels.length === 0)
+        return undefined;
+    const skipped = skippedModels.map((s) => `- ${s.model}: ${s.reason}`).join("\n");
+    return `[MODEL FALLBACK: skipped ${skippedModels.length} unavailable model(s); using "${selectedModel ?? "unknown"}".]\n${skipped}`;
+}
+export function prependModelFallbackSummary(output, skippedModels, selectedModel) {
+    const fallbackSummary = formatModelFallbackSummary(skippedModels, selectedModel);
+    return fallbackSummary ? `${fallbackSummary}\n\n${output}` : output;
+}
+function formatSkippedModelFailureDetails(skippedModels) {
+    if (skippedModels.length === 0)
+        return undefined;
+    return `Skipped models:\n${skippedModels.map((s) => `- ${s.model}: ${s.reason}`).join("\n")}`;
+}
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const MAX_TASK_LENGTH = 32_768; // 32 KB — prevent E2BIG from oversized argv
@@ -499,7 +668,7 @@ function clampCwd(defaultCwd, itemCwd) {
     }
     return { ok: true, cwd: resolved };
 }
-async function executeSingle(agents, agentName, task, cwd, signal, onProgress, modelOverride, parentProvider, registry, sessionDir, parentModel) {
+export async function executeSingle(agents, agentName, task, cwd, signal, onProgress, modelOverride, parentProvider, registry, sessionDir, parentModel) {
     const name = agentName || DEFAULT_AGENT;
     const config = agents.get(name);
     if (!config) {
@@ -529,20 +698,25 @@ async function executeSingle(agents, agentName, task, cwd, signal, onProgress, m
     let effectiveConfig = modelOverride ? { ...config, model: modelOverride } : config;
     let resolvedProvider = parentProvider;
     let warning;
+    let skippedModels = [];
     // Resolve and validate the model against the registry before spawning.
     // This catches typos and invalid model names immediately instead of failing
     // silently in the child process. Also passes the canonical model ID to the
-    // child, avoiding fuzzy matching entirely.
+    // child, avoiding fuzzy matching entirely. Agent definition fallback lists get
+    // an additional best-effort 1-token probe before spawn so runtime-unavailable
+    // models are skipped before committing to a child process.
     if (modelSpec) {
-        const resolved = resolveModelWithFallbacks(modelSpec, parentProvider, registry, parentModel);
+        const resolved = await resolveModelForSubagentSpawn(modelSpec, parentProvider, registry, parentModel, signal);
+        skippedModels = resolved.skippedModels;
         if (!resolved.ok) {
+            const skippedDetails = formatSkippedModelFailureDetails(skippedModels);
             return {
                 agent: name,
                 task,
                 exitCode: 1,
                 output: "",
                 stderr: "",
-                errorMessage: resolved.error,
+                errorMessage: skippedDetails ? `${resolved.error}\n\n${skippedDetails}` : resolved.error,
             };
         }
         effectiveConfig = { ...effectiveConfig, model: resolved.modelId };
@@ -553,6 +727,7 @@ async function executeSingle(agents, agentName, task, cwd, signal, onProgress, m
     }
     onProgress?.(`Running ${name} agent...`);
     const result = await spawnSubagent(effectiveConfig, task, cwd, signal, onProgress, resolvedProvider, sessionDir);
+    result.output = prependModelFallbackSummary(result.output, skippedModels, result.model ?? effectiveConfig.model?.toString());
     if (warning) {
         result.output = `[WARNING: ${warning}]\n\n${result.output}`;
     }
@@ -845,7 +1020,7 @@ export function createSubagentToolDefinition(cwd, options) {
                             onBackgroundComplete(agentId, result, bgSignal.aborted);
                         }
                         catch (err) {
-                            console.error(`[subagent] onBackgroundComplete threw for agent ${agentId}: ${err instanceof Error ? err.message : String(err)}. Background result lost.`);
+                            log.warn(`[subagent] onBackgroundComplete threw for agent ${agentId}: ${err instanceof Error ? err.message : String(err)}. Background result lost.`);
                         }
                     };
                     const run = async () => {
@@ -877,7 +1052,7 @@ export function createSubagentToolDefinition(cwd, options) {
                         }
                     };
                     run().catch((err) => {
-                        console.error(`[subagent] Unhandled background error (${agentId}): ${err instanceof Error ? err.message : String(err)}`);
+                        log.warn(`[subagent] Unhandled background error (${agentId}): ${err instanceof Error ? err.message : String(err)}`);
                         const entry = backgroundAgentRegistry.get(agentId);
                         if (entry && entry.status === "running")
                             entry.status = "failed";
@@ -893,7 +1068,7 @@ export function createSubagentToolDefinition(cwd, options) {
                             }, bgSignal.aborted);
                         }
                         catch (notifyErr) {
-                            console.error(`[subagent] CRITICAL: Last-resort notification failed for ${agentId}: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
+                            log.error(`[subagent] CRITICAL: Last-resort notification failed for ${agentId}: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
                         }
                     });
                     return agentId;