@visorcraft/idlehands 2.2.12 → 2.2.14

package/dist/agent.js

@@ -312,6 +312,71 @@ export async function createSession(opts) {
         if (recentToolUsage.length > 60)
             recentToolUsage.shift();
     };
+    const extractPartialToolArgsPreview = (toolName, rawArgs) => {
+        const out = {};
+        const text = String(rawArgs ?? '');
+        if (!text.trim())
+            return out;
+        const pickString = (key) => {
+            const m = text.match(new RegExp(`"${key}"\\s*:\\s*"([^\\n\"]*)`));
+            return m?.[1];
+        };
+        const pickNumber = (key) => {
+            const m = text.match(new RegExp(`"${key}"\\s*:\\s*(-?\\d+)`));
+            if (!m)
+                return undefined;
+            const n = Number.parseInt(m[1], 10);
+            return Number.isFinite(n) ? n : undefined;
+        };
+        const pathLikeTools = new Set([
+            'read_file',
+            'write_file',
+            'edit_range',
+            'edit_file',
+            'insert_file',
+            'list_dir',
+            'lsp_diagnostics',
+            'lsp_symbols',
+            'lsp_hover',
+            'lsp_definition',
+            'lsp_references',
+        ]);
+        if (pathLikeTools.has(toolName)) {
+            const path = pickString('path');
+            if (path)
+                out.path = path;
+        }
+        if (toolName === 'search_files') {
+            const pattern = pickString('pattern');
+            const path = pickString('path');
+            if (pattern)
+                out.pattern = pattern;
+            if (path)
+                out.path = path;
+        }
+        if (toolName === 'exec') {
+            const command = pickString('command');
+            const cwd = pickString('cwd');
+            if (command)
+                out.command = command;
+            if (cwd)
+                out.cwd = cwd;
+        }
+        if (toolName === 'vault_search') {
+            const query = pickString('query');
+            if (query)
+                out.query = query;
+        }
+        if (toolName === 'edit_range') {
+            const start = pickNumber('start_line');
+            const end = pickNumber('end_line');
+            if (start != null)
+                out.start_line = start;
+            if (end != null)
+                out.end_line = end;
+        }
+        return out;
+    };
     const vault = vaultEnabled
         ? (opts.runtime?.vault ??
             new VaultStore({
@@ -1994,6 +2059,7 @@ export async function createSession(opts) {
         let forceToollessRecoveryTurn = false;
         let toollessRecoveryUsed = false;
         const streamedToolCallPreviews = new Set();
+        const streamedToolCallPreviewScores = new Map();
         // ── Security: credential leak detection + prompt injection guard ──
         const leakDetector = new LeakDetector();
         const promptGuard = new PromptGuard('warn');
@@ -2279,6 +2345,7 @@ export async function createSession(opts) {
                     hookObj.onFirstDelta?.();
                 };
                 let resp;
+                let streamFallbackDiag;
                 try {
                     try {
                         // turns is 1-indexed (incremented at loop top), so first iteration = 1.
@@ -2314,6 +2381,24 @@ export async function createSession(opts) {
                         if (cfg.verbose) {
                             console.error(`[turn-debug] prompt_bytes=${promptBytesEstimate} tools=${toolsForTurn.length} tool_schema_bytes=${toolSchemaBytesEstimate} tool_schema_tokens~=${toolSchemaTokenEstimate}`);
                         }
+                        const noteStreamFallback = (providerName, response) => {
+                            const fallback = response?.meta?.stream_fallback;
+                            if (!fallback || typeof fallback !== 'object')
+                                return;
+                            const reason = String(fallback.reason ?? 'unknown');
+                            const attempt = Number(fallback.attempt ?? NaN);
+                            const status = Number(fallback.status ?? NaN);
+                            const detail = [
+                                Number.isFinite(attempt) ? `attempt=${attempt}` : null,
+                                Number.isFinite(status) ? `status=${status}` : null,
+                            ]
+                                .filter(Boolean)
+                                .join(' ');
+                            streamFallbackDiag = `${providerName}:${reason}${detail ? ` (${detail})` : ''}`;
+                            if (cfg.verbose) {
+                                console.warn(`[routing] stream fallback provider=${providerName} reason=${reason}${detail ? ` ${detail}` : ''}`);
+                            }
+                        };
                         // ── Response cache: check for cached response ──────────────
                         // Only cache tool-less turns (final answers, explanations) since
                         // tool-calling turns have side effects that shouldn't be replayed.
@@ -2365,9 +2450,6 @@ export async function createSession(opts) {
                                         ? delta.id
                                         : `stream_call_${delta.index}`;
                                     const previewKey = `${turns}:${id}:${name}`;
-                                    if (streamedToolCallPreviews.has(previewKey))
-                                        return;
-                                    streamedToolCallPreviews.add(previewKey);
                                     let parsedArgs = {};
                                     const rawArgs = typeof delta.argumentsSoFar === 'string' ? delta.argumentsSoFar.trim() : '';
                                     if (rawArgs) {
@@ -2380,7 +2462,17 @@ export async function createSession(opts) {
                                         catch {
                                             // partial JSON chunks are expected during streaming
                                         }
+                                        if (!Object.keys(parsedArgs).length) {
+                                            parsedArgs = extractPartialToolArgsPreview(name, rawArgs);
+                                        }
                                     }
+                                    const score = Object.keys(parsedArgs).length + (rawArgs ? 1 : 0);
+                                    const prevScore = streamedToolCallPreviewScores.get(previewKey) ?? 0;
+                                    const shouldEmit = !streamedToolCallPreviews.has(previewKey) || score > prevScore;
+                                    if (!shouldEmit)
+                                        return;
+                                    streamedToolCallPreviews.add(previewKey);
+                                    streamedToolCallPreviewScores.set(previewKey, Math.max(prevScore, score));
                                     void emitToolCall(id, name, parsedArgs, 'planned');
                                 },
                             };
@@ -2410,6 +2502,7 @@ export async function createSession(opts) {
                                         }
                                     },
                                 });
+                                noteStreamFallback('runtime-router', resp);
                             }
                             else {
                                 const isLikelyAuthError = (errMsg) => {
@@ -2457,6 +2550,7 @@ export async function createSession(opts) {
                                                 }
                                             },
                                         });
+                                        noteStreamFallback(target.name ?? 'default', resp);
                                         break;
                                     }
                                     catch (providerErr) {
@@ -2476,6 +2570,9 @@ export async function createSession(opts) {
                                 }
                             }
                         } // end if (!resp) — cache miss path
+                        if (streamFallbackDiag && lastTurnDebug) {
+                            lastTurnDebug.streamFallback = streamFallbackDiag;
+                        }
                         // Successful response resets overflow recovery budget.
                         overflowCompactionAttempts = 0;
                         // ── Response cache: store cacheable responses ─────────────
@@ -3133,8 +3230,10 @@ export async function createSession(opts) {
                         if (name === 'read_file' || name === 'read_files') {
                             const filePath = typeof args.path === 'string' ? args.path : '';
                             const searchTerm = typeof args.search === 'string' ? args.search : '';
-                            // Fix 1: Hard cumulative budget — refuse reads past hard cap
-                            if (cumulativeReadOnlyCalls > READ_BUDGET_HARD) {
+                            // Fix 1: Hard cumulative budget — refuse reads once hard cap is reached.
+                            // Count only actual executed read-only calls (not cache replays), so this check
+                            // blocks the next call exactly at the configured cap.
+                            if (cumulativeReadOnlyCalls >= READ_BUDGET_HARD) {
                                 await emitToolCall(callId, name, args);
                                 await emitToolResult({
                                     id: callId,
@@ -3539,6 +3638,13 @@ export async function createSession(opts) {
                             toolCallId: callId,
                             result: content,
                         });
+                        // Count only actual read-only executions toward cumulative read budget.
+                        // Cached/replayed read observations should not consume budget.
+                        if (isReadOnlyToolDynamic(name) &&
+                            !reusedCachedReadTool &&
+                            !reusedCachedReadOnlyExec) {
+                            cumulativeReadOnlyCalls += 1;
+                        }
                         // ── Per-file mutation spiral detection ──
                         // Track edits to the same file. If the model keeps editing the same file
                         // over and over, it's likely in an edit→break→read→edit corruption spiral.
@@ -3706,9 +3812,6 @@ export async function createSession(opts) {
                             console.warn(`[guardrail] capped ${droppedCount} read-only tool calls (per-turn limit ${READ_ONLY_PER_TURN_CAP})`);
                         }
                     }
-                    // Fix 1: Hard cumulative read budget — escalating enforcement
-                    const readOnlyThisTurn = toolCallsArr.filter((tc) => isReadOnlyToolDynamic(tc.function.name));
-                    cumulativeReadOnlyCalls += readOnlyThisTurn.length;
                     if (harness.toolCalls.parallelCalls) {
                         // Models that support parallel calls: read-only in parallel, mutations sequential
                         const readonly = toolCallsArr.filter((tc) => isReadOnlyToolDynamic(tc.function.name));