@dreb/coding-agent 2.17.0 → 2.19.0

package/dist/core/tools/subagent.js

@@ -3,6 +3,7 @@ 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";
@@ -108,6 +109,31 @@ function loadAgentsFromDir(dir, agents) {
 // and process.argv[1] may return corrupted or truncated data.
 const DREB_SCRIPT = process.argv[1] || "dreb";
 const NODE_EXEC = process.execPath;
+// Tools that must never be available to subagents — wait (subagents should
+// never no-op; they have a task to complete) and subagent (no recursive spawning).
+const SUBAGENT_EXCLUDED_TOOLS = ["wait", "subagent"];
+// Default standard tools for subagents when no tools are specified in the agent
+// definition. This is the set passed via --tools to the child process.
+//
+// NOTE: Always-active tools (search, skill, tasks_update, suggest_next) are NOT
+// listed here — the child process adds them unconditionally regardless of --tools.
+// Internal tools (tmp_read) are also excluded.
+const SUBAGENT_DEFAULT_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls", "web_search", "web_fetch"];
+/**
+ * Filter a comma-separated tools string, removing any tools in SUBAGENT_EXCLUDED_TOOLS.
+ * Returns the filtered tools as a comma-separated string (always non-empty — falls
+ * back to SUBAGENT_DEFAULT_TOOLS if all specified tools were excluded).
+ */
+export function filterSubagentTools(tools) {
+    if (!tools)
+        return SUBAGENT_DEFAULT_TOOLS.join(",");
+    const filtered = tools
+        .split(",")
+        .map((t) => t.trim())
+        .filter((t) => !SUBAGENT_EXCLUDED_TOOLS.includes(t))
+        .join(",");
+    return filtered || SUBAGENT_DEFAULT_TOOLS.join(",");
+}
 // TODO: Support PATH-based binary discovery.
 // Currently returns the captured argv[1].
 function findDrebBinary() {
@@ -147,9 +173,9 @@ async function spawnSubagent(agentConfig, task, cwd, signal, onProgress, parentP
             args.push("--provider", parentProvider);
         }
     }
-    if (agentConfig.tools) {
-        args.push("--tools", agentConfig.tools);
-    }
+    // Always pass --tools to ensure wait/subagent are excluded from child processes.
+    // filterSubagentTools always returns a non-empty string.
+    args.push("--tools", filterSubagentTools(agentConfig.tools));
     if (agentConfig.systemPrompt) {
         args.push("--append-system-prompt", agentConfig.systemPrompt);
     }
@@ -433,6 +459,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 });
+            console.error(`[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 });
+                console.error(`[subagent] Model "${modelStr}" failed probe (${probe.reason}). Trying next fallback...`);
+                continue;
+            }
+        }
+        console.error(`[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}".`;
+            console.error(`[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
@@ -474,7 +667,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) {
@@ -504,20 +697,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 };
@@ -528,6 +726,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}`;
     }