@visorcraft/idlehands 1.0.9 → 1.1.2

package/README.md

@@ -13,6 +13,7 @@ Idle Hands is built for people who want an agent that can actually ship work, no
 
 - **TUI-first UX** for real daily use (streaming output, slash commands, approvals)
 - **Runtime orchestration** (hosts/backends/models) for local + remote model stacks
+- **Size-aware runtime probes** so very large GGUF/RPC models get sane startup timeouts by default
 - **Safety + approvals** with explicit modes (`plan`, `reject`, `default`, `auto-edit`, `yolo`)
 - **Headless mode** for CI and scripts (`json`, `stream-json`, `--fail-on-error`, `--diff-only`)
 - **Bot frontends** (Telegram + Discord) with service management
@@ -158,6 +159,24 @@ If you use a dedicated `idlehands` account, install/manage the service while log
 
 ---
 
+
+## Runtime probe defaults (size-aware)
+
+When a model does not explicitly set probe timeout and probe interval, Idle Hands derives defaults from estimated model size on the target host.
+
+Default tiers used by idlehands select:
+
+| Model size (GiB) | probe timeout | probe interval |
+|---:|---:|---:|
+| <= 10 | 120s | 1000ms |
+| <= 40 | 300s | 1200ms |
+| <= 80 | 900s | 2000ms |
+| <= 140 | 3600s | 5000ms |
+| > 140 | 5400s | 5000ms |
+
+Per-model override remains available in runtimes.json under models.launch.
+Explicit per-model values always take precedence.
+
 ## Documentation map
 
 - [Getting Started](https://visorcraft.github.io/IdleHands/guide/getting-started)

package/dist/agent.js

@@ -592,6 +592,14 @@ export function parseToolCallsFromContent(content) {
     const xmlCalls = parseXmlToolCalls(trimmed);
     if (xmlCalls?.length)
         return xmlCalls;
+    // Case 5: Lightweight function-tag calls (seen in some Qwen content-mode outputs):
+    // <function=tool_name>
+    // {...json args...}
+    // </function>
+    // or single-line <function=tool_name>{...}</function>
+    const fnTagCalls = parseFunctionTagToolCalls(trimmed);
+    if (fnTagCalls?.length)
+        return fnTagCalls;
     return null;
 }
 /**
@@ -1006,8 +1014,51 @@ export async function createSession(opts) {
         sessionMeta += `\n\n[Sub-agents] spawn_task is available (isolated context, sequential queue, default max_iterations=${subMaxIter}).`;
     }
     // Harness-driven suffix: append to first user message (NOT system prompt — §9b KV cache rule)
+    // Check if model needs content-mode tool calls (known incompatible templates)
+    // This runs before harness checks so it works regardless of quirk flags.
+    {
+        const modelName = cfg.model ?? '';
+        const { OpenAIClient: OAIClient } = await import('./client.js');
+        if (!client.contentModeToolCalls && OAIClient.needsContentMode(modelName)) {
+            client.contentModeToolCalls = true;
+            client.recordKnownPatternMatch();
+            if (cfg.verbose) {
+                console.warn(`[info] Model "${modelName}" matched known content-mode pattern — using content-based tool calls`);
+            }
+        }
+    }
     if (harness.quirks.needsExplicitToolCallFormatReminder) {
-        sessionMeta += '\n\nIMPORTANT: Use the tool_calls mechanism to invoke tools. Do NOT write JSON tool invocations in your message text.';
+        if (client.contentModeToolCalls) {
+            // In content mode, tell the model to use JSON tool calls in its output
+            sessionMeta += '\n\nYou have access to the following tools. To call a tool, output a JSON block in your response like this:\n```json\n{"name": "tool_name", "arguments": {"param": "value"}}\n```\nAvailable tools:\n';
+            const toolSchemas = getToolsSchema();
+            for (const t of toolSchemas) {
+                const fn = t.function;
+                if (fn) {
+                    const params = fn.parameters?.properties
+                        ? Object.entries(fn.parameters.properties).map(([k, v]) => `${k}: ${v.type ?? 'any'}`).join(', ')
+                        : '';
+                    sessionMeta += `- ${fn.name}(${params}): ${fn.description ?? ''}\n`;
+                }
+            }
+            sessionMeta += '\nIMPORTANT: Output tool calls as JSON blocks in your message. Do NOT use the tool_calls API mechanism.\nIf you use XML/function tags (e.g. <function=name>), include a full JSON object of arguments between braces.';
+        }
+        else {
+            sessionMeta += '\n\nIMPORTANT: Use the tool_calls mechanism to invoke tools. Do NOT write JSON tool invocations in your message text.';
+        }
+        // One-time tool-call template smoke test (first ask() call only, skip in content mode)
+        if (!client.contentModeToolCalls && !client.__toolCallSmokeTested) {
+            client.__toolCallSmokeTested = true;
+            try {
+                const smokeErr = await client.smokeTestToolCalls(cfg.model ?? 'default');
+                if (smokeErr) {
+                    console.error(`\x1b[33m[warn] Tool-call smoke test failed: ${smokeErr}\x1b[0m`);
+                    console.error(`\x1b[33m  This model/server may not support tool-call replay correctly.\x1b[0m`);
+                    console.error(`\x1b[33m  Consider using a different model or updating llama.cpp.\x1b[0m`);
+                }
+            }
+            catch { }
+        }
     }
     if (harness.systemPromptSuffix) {
         sessionMeta += '\n\n' + harness.systemPromptSuffix;
@@ -1357,6 +1408,41 @@ export async function createSession(opts) {
     const clearPlan = () => {
         planSteps = [];
     };
+    // Session-level vault context injection: search vault for entries relevant to
+    // the last user message and inject them into the conversation. Used after any
+    // compaction to restore context the model lost when messages were dropped.
+    let lastVaultInjectionQuery = '';
+    const injectVaultContext = async () => {
+        if (!vault)
+            return;
+        let lastUser = null;
+        for (let j = messages.length - 1; j >= 0; j--) {
+            if (messages[j].role === 'user') {
+                lastUser = messages[j];
+                break;
+            }
+        }
+        const userText = userContentToText((lastUser?.content ?? '')).trim();
+        if (!userText)
+            return;
+        const query = userText.slice(0, 200);
+        if (query === lastVaultInjectionQuery)
+            return;
+        const hits = await vault.search(query, 4);
+        if (!hits.length)
+            return;
+        const lines = hits.map((r) => `${r.updatedAt} ${r.kind} ${r.key ?? r.tool ?? r.id} ${String(r.value ?? r.snippet ?? '').replace(/\s+/g, ' ').slice(0, 180)}`);
+        if (!lines.length)
+            return;
+        lastVaultInjectionQuery = query;
+        const vaultContextHeader = vaultMode === 'passive'
+            ? '[Trifecta Vault (passive)]'
+            : '[Vault context after compaction]';
+        messages.push({
+            role: 'user',
+            content: `${vaultContextHeader} Relevant entries for "${query}":\n${lines.join('\n')}`
+        });
+    };
     const compactHistory = async (opts) => {
         const beforeMessages = messages.length;
         const beforeTokens = estimateTokensFromMessages(messages);
@@ -1401,6 +1487,7 @@ export async function createSession(opts) {
             messages = compacted;
             if (dropped.length) {
                 messages.push({ role: 'system', content: `[compacted: ${dropped.length} messages archived to Vault - vault_search to recall]` });
+                await injectVaultContext().catch(() => { });
             }
         }
         return {
@@ -1759,7 +1846,6 @@ export async function createSession(opts) {
         // that happen back-to-back with no other tool calls in between.
         let lastTurnSigs = new Set();
         const consecutiveCounts = new Map();
-        let lastPassiveVaultQuery = '';
         let malformedCount = 0;
         let noProgressTurns = 0;
         const NO_PROGRESS_TURN_CAP = 3;
@@ -1772,34 +1858,6 @@ export async function createSession(opts) {
         let lastSuccessfulTestRun = null;
         // One-time nudge to prevent post-success churn after green test runs.
         let finalizeAfterTestsNudgeUsed = false;
-        const maybeInjectVaultContext = async () => {
-            if (!vault || vaultMode !== 'passive')
-                return;
-            let lastUser = null;
-            for (let j = messages.length - 1; j >= 0; j--) {
-                if (messages[j].role === 'user') {
-                    lastUser = messages[j];
-                    break;
-                }
-            }
-            const userText = userContentToText((lastUser?.content ?? '')).trim();
-            if (!userText)
-                return;
-            const query = userText.slice(0, 200);
-            if (query === lastPassiveVaultQuery)
-                return;
-            const hits = await vault.search(query, 4);
-            if (!hits.length)
-                return;
-            const lines = hits.map((r) => `${r.updatedAt} ${r.kind} ${r.key ?? r.tool ?? r.id} ${String(r.value ?? r.snippet ?? '').replace(/\s+/g, ' ').slice(0, 180)}`);
-            if (!lines.length)
-                return;
-            lastPassiveVaultQuery = query;
-            messages.push({
-                role: 'user',
-                content: `[Trifecta Vault (passive)] Relevant entries for "${query}":\n${lines.join('\n')}`
-            });
-        };
         const archiveToolOutputForVault = async (msg) => {
             if (!lens || !vault || msg.role !== 'tool' || typeof msg.content !== 'string')
                 return msg;
@@ -1901,8 +1959,9 @@ export async function createSession(opts) {
                     }
                 }
                 messages = compacted;
-                if (vaultMode === 'passive' && compactedDropped) {
-                    await maybeInjectVaultContext().catch(() => { });
+                if (dropped.length) {
+                    messages.push({ role: 'system', content: `[auto-compacted: ${dropped.length} old messages dropped to stay within context budget. Do NOT re-read files or re-run commands you have already seen — use vault_search to recall prior results if needed.]` });
+                    await injectVaultContext().catch(() => { });
                 }
                 const ac = makeAbortController();
                 inFlight = ac;
@@ -2189,9 +2248,13 @@ export async function createSession(opts) {
                             // Update to "now" for next turn.
                             mutationVersionBySig.set(sig, mutationVersion);
                             if (!hasMutatedSince) {
-                                // Allow a few more repeats for exec since "run tests" loops are common.
+                                const count = sigCounts.get(sig) ?? 0;
                                 const loopThreshold = harness.quirks.loopsOnToolError ? 3 : 6;
-                                if ((sigCounts.get(sig) ?? 0) >= loopThreshold) {
+                                // At 3x, inject vault context so the model gets the data it needs
+                                if (count >= 3 && count < loopThreshold) {
+                                    await injectVaultContext().catch(() => { });
+                                }
+                                if (count >= loopThreshold) {
                                     const args = sig.slice(toolName.length + 1);
                                     const argsPreview = args.length > 220 ? args.slice(0, 220) + '…' : args;
                                     throw new Error(`tool ${toolName}: identical call repeated ${loopThreshold}x across turns; breaking loop. ` +
@@ -2212,13 +2275,13 @@ export async function createSession(opts) {
                                 consecutiveCounts.set(sig, 1);
                             }
                             const consec = consecutiveCounts.get(sig) ?? 1;
-                            if (consec >= 4) {
-                                const args = sig.slice(toolName.length + 1);
-                                const argsPreview = args.length > 220 ? args.slice(0, 220) + '…' : args;
-                                messages.push({
-                                    role: 'user',
-                                    content: `[System] You have read the same resource ${consec} consecutive times (${toolName} ${argsPreview}). The content has not changed. Please proceed with your task using the information you already have.`,
-                                });
+                            if (consec >= 3) {
+                                await injectVaultContext().catch(() => { });
+                            }
+                            // Hard-break: after 6 consecutive identical reads, stop the session
+                            if (consec >= 6) {
+                                throw new Error(`tool ${toolName}: identical read repeated ${consec}x consecutively; breaking loop. ` +
+                                    `The resource content has not changed between reads.`);
                             }
                             continue;
                         }
@@ -2821,4 +2884,30 @@ async function autoPickModel(client, cached) {
         clearTimeout(timer);
     }
 }
+function parseFunctionTagToolCalls(content) {
+    const m = content.match(/<function=([\w.-]+)>([\s\S]*?)<\/function>/i);
+    if (!m)
+        return null;
+    const name = m[1];
+    const body = (m[2] ?? '').trim();
+    // If body contains JSON object, use it as arguments; else empty object.
+    let args = '{}';
+    const jsonStart = body.indexOf('{');
+    const jsonEnd = body.lastIndexOf('}');
+    if (jsonStart !== -1 && jsonEnd > jsonStart) {
+        const sub = body.slice(jsonStart, jsonEnd + 1);
+        try {
+            JSON.parse(sub);
+            args = sub;
+        }
+        catch {
+            // keep {}
+        }
+    }
+    return [{
+            id: 'call_0',
+            type: 'function',
+            function: { name, arguments: args }
+        }];
+}
 //# sourceMappingURL=agent.js.map