@visorcraft/idlehands 2.2.11 → 2.2.13

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({
@@ -1676,10 +1741,10 @@ export async function createSession(opts) {
         const hasOnToolResult = Boolean(hookObj.onToolResult);
         const hasOnToolLoop = Boolean(hookObj.onToolLoop);
         const hasOnTurnEnd = Boolean(hookObj.onTurnEnd);
-        const emitToolCall = async (id, name, args) => {
+        const emitToolCall = async (id, name, args, phase = 'executing') => {
             if (!hasOnToolCall && !hooksEnabled)
                 return;
-            const call = { id, name, args };
+            const call = { id, name, args, phase };
             if (hasOnToolCall)
                 hookObj.onToolCall?.(call);
             if (hooksEnabled) {
@@ -1993,6 +2058,8 @@ export async function createSession(opts) {
         const toolLoopWarningKeys = new Set();
         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');
@@ -2278,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.
@@ -2313,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.
@@ -2356,6 +2442,39 @@ export async function createSession(opts) {
                                 requestId: `r${reqCounter}`,
                                 onToken: hookObj.onToken,
                                 onFirstDelta,
+                                onToolCallDelta: (delta) => {
+                                    const name = typeof delta?.name === 'string' ? delta.name : '';
+                                    if (!name)
+                                        return;
+                                    const id = typeof delta?.id === 'string' && delta.id.trim().length
+                                        ? delta.id
+                                        : `stream_call_${delta.index}`;
+                                    const previewKey = `${turns}:${id}:${name}`;
+                                    let parsedArgs = {};
+                                    const rawArgs = typeof delta.argumentsSoFar === 'string' ? delta.argumentsSoFar.trim() : '';
+                                    if (rawArgs) {
+                                        try {
+                                            const parsed = parseJsonArgs(rawArgs);
+                                            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                                                parsedArgs = parsed;
+                                            }
+                                        }
+                                        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');
+                                },
                             };
                             if (primaryUsesRuntimeModel && primaryRoute?.model) {
                                 // Runtime-native routing: lane model/fallbacks reference runtime model IDs.
@@ -2383,6 +2502,7 @@ export async function createSession(opts) {
                                         }
                                     },
                                 });
+                                noteStreamFallback('runtime-router', resp);
                             }
                             else {
                                 const isLikelyAuthError = (errMsg) => {
@@ -2430,6 +2550,7 @@ export async function createSession(opts) {
                                                 }
                                             },
                                         });
+                                        noteStreamFallback(target.name ?? 'default', resp);
                                         break;
                                     }
                                     catch (providerErr) {
@@ -2449,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 ─────────────