mixdog 0.9.166 → 0.9.167

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs

@@ -31,6 +31,9 @@ import {
     updateSessionStatus,
     closeSession,
     getSession,
+    getSessionLastProgressAt,
+    getSessionProgressSnapshot,
+    linkParentSignalToSession,
 } from '../session/manager.mjs';
 import {
     abortAgentProgressWatchdog,
@@ -306,6 +309,27 @@ export function buildAgentDispatchAskSessionArgs(factoryOpts = {}, callArgs = {}
 // cancellation sources, so collapse them before installing that one link.
 // The first already-aborted source wins (in declaration order), retaining its
 // original reason instead of replacing it with a generic AbortError.
+function nonEmptyString(value) {
+    return typeof value === 'string' && value ? value : null;
+}
+
+function abortDispatchWatchdog({
+    controller, sessionId, agent, error, snapshot, policy, now, anchorTs, lastProgressAt,
+}) {
+    const sess = getSession(sessionId);
+    abortAgentProgressWatchdog(controller, {
+        sessionId,
+        agent,
+        error,
+        snapshot,
+        policy,
+        now,
+        anchorTs,
+        lastProgressAt,
+        iteration: typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null,
+    });
+}
+
 function composeAgentDispatchAbortSignal(signals) {
     const sources = (Array.isArray(signals) ? signals : [])
         .filter((signal) => signal instanceof AbortSignal);
@@ -455,9 +479,7 @@ export function makeAgentDispatch(opts = {}) {
         // and the downstream skill-discovery path tolerates null. Combined
         // with the frozen agent skill meta-tools (collect.mjs) this keeps
         // every caller on the same provider cache shard.
-        const cwd = (typeof callCwd === 'string' && callCwd)
-            ? callCwd
-            : ((typeof opts.cwd === 'string' && opts.cwd) ? opts.cwd : null);
+        const cwd = nonEmptyString(callCwd) || nonEmptyString(opts.cwd);
 
         // Unified dispatch: Pool B/C share bit-identical tools + system prompt
         // unless a hidden role declares a narrow toolSchemaProfile. Per-role
@@ -512,24 +534,14 @@ export function makeAgentDispatch(opts = {}) {
         await updateStatus(session.id, 'running');
         // Parent→child abort cascade: when opts.parentSignal (factory) or
         // callParentSignal (per-call) fires, abort the sub-session's own
-        // controller so the provider call tears down promptly. Best-effort:
-        // if the session/manager import is unavailable we fall back silently.
-        const _managerMod = await import('../session/manager.mjs').catch(() => null);
-        const _linkSignal = _managerMod?.linkParentSignalToSession;
-        const _getProgressSnapshot = _managerMod?.getSessionProgressSnapshot;
-        const _getLastProgressAt = _managerMod?.getSessionLastProgressAt;
-        const _getSession = _managerMod?.getSession || readSession;
-        // Watchdog policy is split:
-        // - firstResponseTimeoutMs cuts quickly only when the model produces no
-        //   first stream/tool activity at all.
-        // - idle/tool-running caps come from role stallCap (hidden roles) or env defaults.
+        // controller so the provider call tears down promptly.
         const _watchdogPolicy = resolveAgentWatchdogPolicy(agent, {
             idleTimeoutMs: Number.isFinite(callIdleTimeoutMs)
                 ? callIdleTimeoutMs
                 : opts.idleTimeoutMs,
             firstResponseTimeoutMs: opts.firstResponseTimeoutMs,
         });
-        const _idleController = (agentWatchdogPolicyActive(_watchdogPolicy) && _linkSignal)
+        const _idleController = agentWatchdogPolicyActive(_watchdogPolicy)
             ? new AbortController()
             : null;
         // Do not link factory parent, per-call cancellation, and the
@@ -541,53 +553,47 @@ export function makeAgentDispatch(opts = {}) {
             callParentSignal,
             _idleController?.signal,
         ]);
-        if (_linkSignal && _abortLink.signal) {
-            try { _linkSignal(session.id, _abortLink.signal); } catch { /* ignore */ }
+        if (_abortLink.signal) {
+            try { linkParentSignalToSession(session.id, _abortLink.signal); } catch { /* ignore */ }
         }
         // Watchdog blind spot guard: when the runtime snapshot is missing AND
         // no progress timestamp exists (pre-liveness hang, swept runtime), the
         // dispatch start time anchors staleness so the abort still fires.
         const _watchdogAnchorTs = Date.now();
-        const _idleTimer = (_idleController && (typeof _getProgressSnapshot === 'function' || typeof _getLastProgressAt === 'function'))
+        const _idleTimer = _idleController
             ? setInterval(() => {
                 if (_idleController.signal?.aborted) return;
                 const now = Date.now();
-                const snapshot = typeof _getProgressSnapshot === 'function' ? _getProgressSnapshot(session.id) : null;
-                const abortErr = snapshot
-                    ? evaluateAgentWatchdogAbort(snapshot, now, _watchdogPolicy)
-                    : null;
-                if (!abortErr && !snapshot) {
-                    const reported = typeof _getLastProgressAt === 'function' ? _getLastProgressAt(session.id) : 0;
-                    const last = reported || _watchdogAnchorTs;
-                    if (_watchdogPolicy.idleStaleMs > 0 && now - last > _watchdogPolicy.idleStaleMs) {
-                        const err = new AgentStallAbortError(`agent task stale (${_watchdogPolicy.idleStaleMs}ms without progress)`);
-                        const sess = typeof _getSession === 'function' ? _getSession(session.id) : null;
-                        abortAgentProgressWatchdog(_idleController, {
+                const snapshot = getSessionProgressSnapshot(session.id);
+                if (snapshot) {
+                    const abortErr = evaluateAgentWatchdogAbort(snapshot, now, _watchdogPolicy);
+                    if (abortErr) {
+                        abortDispatchWatchdog({
+                            controller: _idleController,
                             sessionId: session.id,
                             agent,
-                            error: err,
+                            error: abortErr,
+                            snapshot,
                             policy: _watchdogPolicy,
                             now,
                             anchorTs: _watchdogAnchorTs,
-                            lastProgressAt: reported,
-                            iteration: typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null,
                         });
                     }
                     return;
                 }
-                if (abortErr) {
-                    const sess = typeof _getSession === 'function' ? _getSession(session.id) : null;
-                    abortAgentProgressWatchdog(_idleController, {
-                        sessionId: session.id,
-                        agent,
-                        error: abortErr,
-                        snapshot,
-                        policy: _watchdogPolicy,
-                        now,
-                        anchorTs: _watchdogAnchorTs,
-                        iteration: typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null,
-                    });
-                }
+                const reported = getSessionLastProgressAt(session.id);
+                const last = reported || _watchdogAnchorTs;
+                if (_watchdogPolicy.idleStaleMs <= 0 || now - last <= _watchdogPolicy.idleStaleMs) return;
+                abortDispatchWatchdog({
+                    controller: _idleController,
+                    sessionId: session.id,
+                    agent,
+                    error: new AgentStallAbortError(`agent task stale (${_watchdogPolicy.idleStaleMs}ms without progress)`),
+                    policy: _watchdogPolicy,
+                    now,
+                    anchorTs: _watchdogAnchorTs,
+                    lastProgressAt: reported,
+                });
             }, 1000)
             : null;
         if (_idleTimer && typeof _idleTimer.unref === 'function') _idleTimer.unref();

package/src/runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs

@@ -6,6 +6,7 @@
 
 import { appendAgentTrace } from '../agent-trace-io.mjs';
 import { getHiddenAgent } from '../internal-agents.mjs';
+import { envNonNegativeInt, envPresent } from '../../../shared/env.mjs';
 import {
     PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
     PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS,
@@ -196,10 +197,8 @@ export function abortAgentProgressWatchdog(controller, ctx) {
 }
 
 function envTimeoutMs(name, fallback) {
-    const raw = process.env[name];
-    if (raw === undefined || raw === '') return fallback;
-    const n = Number(raw);
-    return Number.isFinite(n) && n >= 0 ? Math.floor(n) : fallback;
+    if (!envPresent(name)) return fallback;
+    return envNonNegativeInt(name, fallback);
 }
 
 const DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = envTimeoutMs(

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -328,8 +328,29 @@ function classifyPatchFailure(text) {
     return null;
 }
 
+function toolTraceText(value) {
+    if (typeof value === 'string') return value;
+    const parts = Array.isArray(value) ? value : value?.content;
+    if (Array.isArray(parts)) {
+        return parts.filter((part) => part?.type === 'text' && typeof part.text === 'string')
+            .map((part) => part.text).join('\n');
+    }
+    return value == null ? '' : JSON.stringify(value);
+}
+
+function toolFailureCause(text) {
+    const body = text.trim().replace(/^Error:\s*/i, '');
+    if (body.startsWith('{')) {
+        try {
+            const value = JSON.parse(body);
+            if (value?.ok === false && typeof value.error === 'string') return value.error;
+        } catch { /* Bounded or non-JSON output keeps its original text. */ }
+    }
+    return text;
+}
+
 function classifyToolFailure(resultText, toolName) {
-    const raw = String(resultText ?? '');
+    const raw = toolFailureCause(toolTraceText(resultText));
     const text = raw.toLowerCase();
     if (isExpectedToolCancellation(raw)) return 'expected-cancellation';
     // Shell renderers put the machine-readable status on the leading line.
@@ -340,6 +361,7 @@ function classifyToolFailure(resultText, toolName) {
         .map((line) => line.trim())
         .find((line) => line && !line.startsWith('⚠️ '))
         ?.replace(/^Error:\s*/i, '') || '';
+    if (/^\[shell-tool-failed\]\s+shell arg "[^"]+" is unsupported\b/i.test(leading)) return 'schema/args';
     if (/^\[shell-tool-failed\](?:\s|$)/i.test(leading)) return 'tool-call/failure';
     if (/^\[shell-run-failed\](?:\s|$)/i.test(leading)) {
         if (/\[timeout:|cause:\s*(?:timeout|cancellation)\b/i.test(leading)) return 'timeout/abort';
@@ -349,6 +371,21 @@ function classifyToolFailure(resultText, toolName) {
     }
     if (/compacted-history placeholder/.test(text)) return 'expected-preflight';
     if (/\[tool-input-validation\]/.test(text)) return 'schema/args';
+    // These are emitted validation/cancellation contracts, not keywords found
+    // somewhere in a quoted document, command output, or error preview.
+    if (/^(?:Browser command interrupted by local user input\.|computer_session_aborted: queued command was cancelled before execution|computer_user_control_active:)/i.test(leading)) return 'expected-cancellation';
+    if (/^The arguments provided to `[^`]+` are invalid JSON and could not be parsed:/i.test(leading)
+        || /^new Goal tasks must omit ids; use updates for existing tasks$/i.test(leading)
+        || /^goal task exceeds \d+ characters$/i.test(leading)
+        || /^goal (?:tasks|updates) support at most \d+ entries$/i.test(leading)
+        || /^goal arguments contain unknown fields:/i.test(leading)
+        || /^Unsupported field for GitHub [\w.]+\.$/i.test(leading)
+        || /^browser action "[^"]+" (?:does not accept input field|requires input\.|accepts only one input target form|fields must be inside input:|input\.[^\n]*(?:must be|requires|accepts at most))/i.test(leading)
+        || /^Computer Use [^\n]*(?:does not accept|requires input|must be|accepts at most)/i.test(leading)
+        || /^regex parse error:/i.test(leading)) return 'schema/args';
+    if (toolName === 'web_fetch' && /\berrorCode:\s*HTTP_ERROR\b/.test(raw)) return 'upstream/http';
+    if (toolName === 'media' && /^generation failed on [^\n]+failed \([45]\d\d\):/i.test(leading)) return 'upstream/http';
+    if (toolName === 'web_search' && /^Web search failed: native web search failed: .+: runtime is closing$/i.test(leading)) return 'lifecycle/closing';
     // `shell` results quote git/patch output verbatim (e.g. `git apply`
     // rejects); only real patch surfaces may claim the patch taxonomy, so an
     // ordinary command exit is never rewritten into a patch failure.
@@ -368,8 +405,8 @@ function classifyToolFailure(resultText, toolName) {
         if (patchCategory) return patchCategory;
         if (/\bstat\b.*\bfor delete\b.*\(os error 2\)/.test(text)) return 'path/enoent';
     }
-    if (/requires either|invalid arguments|unknown parameter|unknown memory action/.test(text)
-        || /must be|schema|required|old_string is .*>?=/.test(text)) return 'schema/args';
+    if (/requires either|invalid arguments|unknown parameter|unknown memory action/i.test(leading)
+        || /must be|schema|required|old_string is .*>?=/i.test(leading)) return 'schema/args';
     if (/not in allow-list|not allowed/.test(text)) return 'permission';
     if (String(toolName || '') === 'shell' || /^\s*\[exit code:\s*\d+\]/i.test(raw)) return 'command-exit';
     if (isReadOnlyNavigationMiss(toolName, raw)) return 'navigation/miss';
@@ -396,7 +433,7 @@ function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolM
     if (process.env.MIXDOG_AGENT_TRACE_DISABLE === '1') return;
     if (!_resolveToolFailurePath()) return;
     try {
-        const cleanText = _redactLogText(String(resultText ?? ''));
+        const cleanText = _redactLogText(toolTraceText(resultText));
         // A session close is deliberate orchestration, not a tool failure.
         // traceAgentTool still records the error/category on the normal trace.
         if (isExpectedToolCancellation(cleanText)) return;
@@ -413,7 +450,7 @@ function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolM
             cwd: cwd || null,
             tool_ms: Number.isFinite(Number(toolMs)) ? Number(toolMs) : null,
             tool_args: summarizeToolArgs(toolName, toolArgs),
-            error_first_line: _firstNonEmptyLine(cleanText).slice(0, 300),
+            error_first_line: _firstNonEmptyLine(toolFailureCause(cleanText)).slice(0, 300),
             error_preview: cleanText.slice(0, 1200),
             result_bytes_est: Buffer.byteLength(cleanText, 'utf8'),
             result_lines_est: cleanText.length > 0 ? cleanText.split('\n').length : 0,
@@ -465,13 +502,13 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
     // Keep a short redacted error preview on the tool row itself so trace
     // analysis can see WHY a call failed without joining the failure log.
     const errorFirstLine = resultKind === 'error'
-        ? _firstNonEmptyLine(_redactLogText(String(resultText ?? ''))).slice(0, 200) || null
+        ? _firstNonEmptyLine(toolFailureCause(_redactLogText(toolTraceText(resultText)))).slice(0, 200) || null
         : null;
     // Failure taxonomy on the tool row itself (mirrors the failure log's
     // `category`) so trace-level aggregation can exclude expected command
     // exits (`command-exit`) without joining tool-failures.jsonl.
     const errorCategory = resultKind === 'error'
-        ? classifyToolFailure(String(resultText ?? ''), toolName)
+        ? classifyToolFailure(resultText, toolName)
         : null;
     // Flat shape — fields named exactly as the agent_calls PG columns so
     // insertAgentCalls can pick them up by direct property access without

package/src/runtime/agent/orchestrator/agent-trace.mjs

@@ -1,4 +1,5 @@
 import { isInclusiveProvider } from '../../shared/llm/cost.mjs';
+import { currentUsageContext } from '../../shared/llm/usage-context.mjs';
 import { estimateJsonBytes, hashStructuredValue } from '../../shared/json-metrics.mjs';
 import {
   appendAgentTrace,
@@ -261,6 +262,7 @@ function traceAgentUsage({
     cacheWriteTokens,
     promptTokens,
     model,
+    pricingModel,
     modelDisplay,
     responseId,
     rawUsage,
@@ -272,6 +274,10 @@ function traceAgentUsage({
     continuationResetReason,
     inputTokensInclusive,
 }) {
+    const identity = currentUsageContext();
+    provider = identity?.provider || provider;
+    sessionId = identity?.sessionId || sessionId;
+    inputTokensInclusive = identity?.inputTokensInclusive ?? inputTokensInclusive;
     const accounting = resolveTraceUsageInput({
         provider,
         inputTokens,
@@ -308,6 +314,9 @@ function traceAgentUsage({
         ...(continuationResetReason !== undefined ? { continuation_reset_reason: continuationResetReason } : {}),
         payload: {
             provider: provider || null,
+            requested_model: identity?.requestedModel || null,
+            pricing_model: pricingModel || identity?.pricingModel || null,
+            source_type: identity?.sourceType || null,
             prompt_tokens: promptTotal,
             uncached_input_tokens: accounting.uncachedInputTokens,
             thinking_tokens: thinkingTokens,

package/src/runtime/agent/orchestrator/config.mjs

@@ -100,7 +100,7 @@ export function buildDefaultConfig(options = {}) {
     return {
         providers,
         disabledAgents: [...DEFAULT_DISABLED_AGENT_IDS],
-        workflow: { active: 'default' },
+        workflow: { active: 'solo' },
     };
 }
 
@@ -242,7 +242,7 @@ export function loadConfig(options = {}) {
                 // Explicit "off" roster. canonicalizeAgentRouteStorage normalizes
                 // and drops it when empty, so an all-enabled config stays clean.
                 disabledAgents: Array.isArray(raw.disabledAgents) ? raw.disabledAgents : [],
-                workflow: raw.workflow && typeof raw.workflow === 'object' ? { active: String(raw.workflow.active || 'default') } : { active: 'default' },
+                workflow: raw.workflow && typeof raw.workflow === 'object' ? { active: String(raw.workflow.active || 'solo') } : { active: 'solo' },
                 profile: normalizeProfileConfig(raw.profile),
                 skills: normalizeSkillsConfig(raw.skills),
                 extensionScopes: normalizeExtensionScopes(raw.extensionScopes),
@@ -285,7 +285,7 @@ export function loadConfig(options = {}) {
         modelSettings: {},
         onboarding: {},
         agents: {},
-        workflow: { active: 'default' },
+        workflow: { active: 'solo' },
         profile: normalizeProfileConfig(null),
         skills: normalizeSkillsConfig(null),
         extensionScopes: normalizeExtensionScopes(null),
@@ -384,7 +384,7 @@ function buildAgentSaveBuilder(config) {
             modelSettings: canonicalRoutes.modelSettings,
             onboarding: config.onboarding || {},
             agents: canonicalRoutes.agents,
-            workflow: config.workflow || { active: 'default' },
+            workflow: config.workflow || { active: 'solo' },
             profile,
             skills,
             extensionScopes,
@@ -396,6 +396,11 @@ function buildAgentSaveBuilder(config) {
             modules,
             builtins,
         };
+        if (canonicalRoutes.disabledAgents) {
+            next.disabledAgents = canonicalRoutes.disabledAgents;
+        } else {
+            delete next.disabledAgents;
+        }
         delete next.workflowRoutes;
         return removeRetiredAgentFields(next);
     };