@visorcraft/idlehands 1.4.6 → 2.0.1

package/dist/agent.js

@@ -1,14 +1,23 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { generateMinimalDiff, toolResultSummary, execCommandFromSig, formatDurationMs, looksLikePlanningNarration, capTextByApproxTokens, isLikelyBinaryBuffer, sanitizePathsInMessage, digestToolResult, } from './agent/formatting.js';
+import { DEFAULT_SUB_AGENT_RESULT_TOKEN_CAP, DEFAULT_SUB_AGENT_SYSTEM_PROMPT, MCP_TOOLS_REQUEST_TOKEN, } from './agent/constants.js';
+import { AgentLoopBreak } from './agent/errors.js';
+import { execRcShouldSignalFailure, looksLikeReadOnlyExecCommand, readOnlyExecCacheable, withCachedExecObservationHint, withReplayedExecHint, } from './agent/exec-helpers.js';
+import { generateMinimalDiff, toolResultSummary, execCommandFromSig, formatDurationMs, looksLikePlanningNarration, capTextByApproxTokens, sanitizePathsInMessage, digestToolResult, } from './agent/formatting.js';
+import { autoPickModel } from './agent/model-pick.js';
 import { reviewArtifactKeys, looksLikeCodeReviewRequest, looksLikeReviewRetrievalRequest, retrievalAllowsStaleArtifact, parseReviewArtifactStalePolicy, parseReviewArtifact, reviewArtifactStaleReason, gitHead, normalizeModelsResponse, } from './agent/review-artifact.js';
+import { capApprovalMode, ensureInformativeAssistantText, isContextWindowExceededError, makeAbortController, userContentToText, userDisallowsDelegation, } from './agent/session-utils.js';
+import { buildSubAgentContextBlock, extractLensBody } from './agent/subagent-context.js';
 import { parseToolCallsFromContent, getMissingRequiredParams, getArgValidationIssues, stripMarkdownFences, parseJsonArgs, } from './agent/tool-calls.js';
 import { ToolLoopGuard } from './agent/tool-loop-guard.js';
+import { isLspTool, isMutationTool, isReadOnlyTool, planModeSummary } from './agent/tool-policy.js';
+import { buildToolsSchema } from './agent/tools-schema.js';
 import { OpenAIClient } from './client.js';
 import { loadProjectContext } from './context.js';
 import { loadGitContext, isGitDirty, stashWorkingTree } from './git.js';
 import { selectHarness } from './harnesses.js';
 import { enforceContextBudget, stripThinking, estimateTokensFromMessages, estimateToolSchemaTokens, } from './history.js';
+import { truncateToolResultContent } from './agent/context-budget.js';
 import { HookManager, loadHookPlugins } from './hooks/index.js';
 import { projectIndexKeys, parseIndexMeta, isFreshIndex, indexSummaryLine } from './indexer.js';
 import { LensStore } from './lens.js';
@@ -18,148 +27,12 @@ import { BASE_MAX_TOKENS, deriveContextWindow, deriveGenerationParams, supportsV
 import { ReplayStore } from './replay.js';
 import { checkExecSafety, checkPathSafety } from './safety.js';
 import { normalizeApprovalMode } from './shared/config-utils.js';
-import { SYS_CONTEXT_SCHEMA, collectSnapshot } from './sys/context.js';
+import { collectSnapshot } from './sys/context.js';
 import { ToolError, ValidationError } from './tools/tool-error.js';
 import * as tools from './tools.js';
 import { stateDir, timestampedId } from './utils.js';
 import { VaultStore } from './vault.js';
 export { parseToolCallsFromContent };
-function makeAbortController() {
-    // Node 24: AbortController is global.
-    return new AbortController();
-}
-const CACHED_EXEC_OBSERVATION_HINT = '[idlehands hint] Reused cached output for repeated read-only exec call (unchanged observation).';
-function looksLikeReadOnlyExecCommand(command) {
-    // Strip leading `cd <path> &&` / `cd <path>;` prefixes — cd is read-only
-    // navigation, the actual command that matters comes after.
-    let cmd = String(command || '')
-        .trim()
-        .toLowerCase();
-    if (!cmd)
-        return false;
-    cmd = cmd.replace(/^(\s*cd\s+[^;&|]+\s*(?:&&|;)\s*)+/i, '').trim();
-    if (!cmd)
-        return false;
-    // Shell redirects are likely writes.
-    if (/(^|\s)(?:>>?|<<?)\s*/.test(cmd))
-        return false;
-    // Obvious mutators.
-    if (/\b(?:rm|mv|cp|touch|mkdir|rmdir|chmod|chown|truncate|dd)\b/.test(cmd))
-        return false;
-    if (/\b(?:sed|perl)\b[^\n]*\s-i\b/.test(cmd))
-        return false;
-    if (/\btee\b/.test(cmd))
-        return false;
-    // Git: allow common read-only subcommands, block mutating verbs.
-    if (/\bgit\b/.test(cmd)) {
-        if (/\bgit\b[^\n|;&]*\b(?:add|am|apply|bisect|checkout|switch|clean|clone|commit|fetch|merge|pull|push|rebase|reset|revert|stash)\b/.test(cmd)) {
-            return false;
-        }
-        if (/\bgit\b[^\n|;&]*\b(?:log|show|status|diff|rev-parse|branch(?:\s+--list)?|tag(?:\s+--list)?|ls-files|grep)\b/.test(cmd)) {
-            return true;
-        }
-    }
-    if (/^\s*(?:grep|rg|ag|ack|find|ls|cat|head|tail|wc|stat)\b/.test(cmd))
-        return true;
-    if (/\|\s*(?:grep|rg|ag|ack)\b/.test(cmd))
-        return true;
-    // Additional read-only commands: file info, path lookup, system/user info
-    if (/^\s*(?:file|which|type|uname|env|printenv|id|whoami|pwd)\b/.test(cmd))
-        return true;
-    // Git read-only subcommands that aren't covered above
-    if (/\bgit\b[^\n|;&]*\b(?:blame|remote|config\s+--(?:get|list|global|local|system))\b/.test(cmd))
-        return true;
-    return false;
-}
-function execRcShouldSignalFailure(command) {
-    const cmd = String(command || '').toLowerCase();
-    if (!cmd)
-        return false;
-    // Common checks where non-zero usually means real failure.
-    if (/\b(?:npm|pnpm|yarn)\s+(?:run\s+)?(?:test|build|lint|typecheck|check)\b/.test(cmd))
-        return true;
-    if (/\bnode\s+--test\b/.test(cmd))
-        return true;
-    if (/\b(?:pytest|go\s+test|cargo\s+test|ctest|mvn\s+test|gradle\s+test)\b/.test(cmd))
-        return true;
-    if (/\b(?:cargo\s+build|go\s+build|tsc\b)\b/.test(cmd))
-        return true;
-    // Grep/rg no-match rc=1 should not be treated as failure.
-    if (/^\s*(?:rg|grep|ag|ack)\b/.test(cmd))
-        return false;
-    return false;
-}
-function withCachedExecObservationHint(content) {
-    if (!content)
-        return content;
-    try {
-        const parsed = JSON.parse(content);
-        const out = typeof parsed?.out === 'string' ? parsed.out : '';
-        if (out.includes(CACHED_EXEC_OBSERVATION_HINT))
-            return content;
-        parsed.out = out ? `${out}\n${CACHED_EXEC_OBSERVATION_HINT}` : CACHED_EXEC_OBSERVATION_HINT;
-        parsed.cached_observation = true;
-        return JSON.stringify(parsed);
-    }
-    catch {
-        if (content.includes(CACHED_EXEC_OBSERVATION_HINT))
-            return content;
-        return `${content}\n${CACHED_EXEC_OBSERVATION_HINT}`;
-    }
-}
-const REPLAYED_EXEC_HINT = '[idlehands hint] You already ran this exact command. This is the replayed result from your previous execution. Do NOT re-run it — use the output below to continue your task.';
-function withReplayedExecHint(content) {
-    if (!content)
-        return content;
-    try {
-        const parsed = JSON.parse(content);
-        const out = typeof parsed?.out === 'string' ? parsed.out : '';
-        if (out.includes(REPLAYED_EXEC_HINT))
-            return content;
-        parsed.out = out ? `${REPLAYED_EXEC_HINT}\n${out}` : REPLAYED_EXEC_HINT;
-        parsed.replayed = true;
-        return JSON.stringify(parsed);
-    }
-    catch {
-        if (content.includes(REPLAYED_EXEC_HINT))
-            return content;
-        return `${REPLAYED_EXEC_HINT}\n${content}`;
-    }
-}
-function readOnlyExecCacheable(content) {
-    try {
-        const parsed = JSON.parse(content);
-        const rc = Number(parsed?.rc ?? NaN);
-        return Number.isFinite(rc) && rc === 0;
-    }
-    catch {
-        return false;
-    }
-}
-function ensureInformativeAssistantText(text, ctx) {
-    if (String(text ?? '').trim())
-        return text;
-    if (ctx.toolCalls > 0) {
-        return 'I completed the requested tool work, but I have no user-visible response text yet. Ask me to summarize what was done.';
-    }
-    return `I have no user-visible response text for this turn (turn=${ctx.turns}). Please try again or rephrase your request.`;
-}
-function isContextWindowExceededError(err) {
-    const status = Number(err?.status ?? NaN);
-    const msg = String(err?.message ?? err ?? '');
-    if (status === 413)
-        return true;
-    if (!msg)
-        return false;
-    return /(exceeds?\s+the\s+available\s+context\s+size|exceed_context|context\s+size|context\s+window|maximum\s+context\s+length|too\s+many\s+tokens|request\s*\(\d+\s*tokens\))/i.test(msg);
-}
-/** Errors that should break the outer agent loop, not be caught by per-tool handlers */
-class AgentLoopBreak extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'AgentLoopBreak';
-    }
-}
 const SYSTEM_PROMPT = `You are a coding agent with filesystem and shell access. Execute the user's request using the provided tools.
 
 Rules:
@@ -186,429 +59,6 @@ Rules:
 Tool call format:
 - Use tool_calls. Do not write JSON tool invocations in your message text.
 `;
-const MCP_TOOLS_REQUEST_TOKEN = '[[MCP_TOOLS_REQUEST]]';
-const DEFAULT_SUB_AGENT_SYSTEM_PROMPT = `You are a focused coding sub-agent. Execute only the delegated task.
-- Work in the current directory. Use relative paths for all file operations.
-- Read the target file before editing. You need the exact text for search/replace.
-- Keep tool usage tight and efficient.
-- Prefer surgical edits over rewrites.
-- Do NOT create files outside the working directory unless explicitly requested.
-- When running commands in a subdirectory, use exec's cwd parameter — NOT "cd /path && cmd".
-- Run verification commands when relevant.
-- Return a concise outcome summary.`;
-const DEFAULT_SUB_AGENT_RESULT_TOKEN_CAP = 4000;
-const LSP_TOOL_NAMES = [
-    'lsp_diagnostics',
-    'lsp_symbols',
-    'lsp_hover',
-    'lsp_definition',
-    'lsp_references',
-];
-const LSP_TOOL_NAME_SET = new Set(LSP_TOOL_NAMES);
-const FILE_MUTATION_TOOL_SET = new Set([
-    'edit_file',
-    'edit_range',
-    'apply_patch',
-    'write_file',
-    'insert_file',
-]);
-/** Approval mode permissiveness ranking (lower = more restrictive). */
-const APPROVAL_MODE_RANK = {
-    plan: 0,
-    reject: 1,
-    default: 2,
-    'auto-edit': 3,
-    yolo: 4,
-};
-/**
- * Cap a sub-agent's approval mode at the parent's level.
- * Sub-agents cannot escalate beyond the parent's approval mode.
- */
-function capApprovalMode(requested, parentMode) {
-    return APPROVAL_MODE_RANK[requested] <= APPROVAL_MODE_RANK[parentMode] ? requested : parentMode;
-}
-async function buildSubAgentContextBlock(cwd, rawFiles) {
-    const values = Array.isArray(rawFiles) ? rawFiles : [];
-    const files = values
-        .map((v) => (typeof v === 'string' ? v.trim() : ''))
-        .filter(Boolean)
-        .slice(0, 12);
-    if (!files.length)
-        return { block: '', included: [], skipped: [] };
-    const MAX_TOTAL_CHARS = 24_000;
-    const MAX_PER_FILE_CHARS = 4_000;
-    let total = 0;
-    const parts = [];
-    const included = [];
-    const skipped = [];
-    for (const rel of files) {
-        const abs = path.resolve(cwd, rel);
-        const relFromCwd = path.relative(cwd, abs);
-        if (relFromCwd.startsWith('..') || path.isAbsolute(relFromCwd)) {
-            skipped.push(`${rel} (outside cwd)`);
-            continue;
-        }
-        let stat;
-        try {
-            stat = await fs.stat(abs);
-        }
-        catch {
-            skipped.push(`${rel} (missing)`);
-            continue;
-        }
-        if (!stat?.isFile()) {
-            skipped.push(`${rel} (not a file)`);
-            continue;
-        }
-        const buf = await fs.readFile(abs).catch(() => null);
-        if (!buf) {
-            skipped.push(`${rel} (unreadable)`);
-            continue;
-        }
-        if (isLikelyBinaryBuffer(buf)) {
-            skipped.push(`${rel} (binary)`);
-            continue;
-        }
-        const raw = buf.toString('utf8');
-        const body = raw.length > MAX_PER_FILE_CHARS
-            ? `${raw.slice(0, MAX_PER_FILE_CHARS)}\n[truncated: ${raw.length} chars total]`
-            : raw;
-        const section = `[file:${rel}]\n${body}\n[/file:${rel}]`;
-        if (total + section.length > MAX_TOTAL_CHARS) {
-            skipped.push(`${rel} (context budget reached)`);
-            continue;
-        }
-        parts.push(section);
-        included.push(rel);
-        total += section.length;
-    }
-    return { block: parts.join('\n\n'), included, skipped };
-}
-function extractLensBody(projection) {
-    const lines = String(projection ?? '').split(/\r?\n/);
-    if (!lines.length)
-        return '';
-    let start = 0;
-    if (lines[0].startsWith('# '))
-        start = 1;
-    if (lines[start]?.startsWith('# lens:'))
-        start += 1;
-    return lines
-        .slice(start)
-        .filter((line) => line.trim().length > 0)
-        .slice(0, 40)
-        .join('\n');
-}
-function buildToolsSchema(opts) {
-    const obj = (properties, required = []) => ({
-        type: 'object',
-        additionalProperties: false,
-        properties,
-        required,
-    });
-    const str = () => ({ type: 'string' });
-    const bool = () => ({ type: 'boolean' });
-    const int = (min, max) => ({
-        type: 'integer',
-        ...(min !== undefined && { minimum: min }),
-        ...(max !== undefined && { maximum: max }),
-    });
-    const schemas = [
-        // ────────────────────────────────────────────────────────────────────────────
-        // Token-safe reads (require limit; allow plain output without per-line numbers)
-        // ────────────────────────────────────────────────────────────────────────────
-        {
-            type: 'function',
-            function: {
-                name: 'read_file',
-                description: 'Read a bounded slice of a file. Never repeat an identical call consecutively; reuse the prior result.',
-                parameters: obj({
-                    path: str(),
-                    offset: int(1, 1_000_000),
-                    limit: int(1, 240),
-                    search: str(),
-                    context: int(0, 80),
-                    format: { type: 'string', enum: ['plain', 'numbered', 'sparse'] },
-                    max_bytes: int(256, 20_000),
-                }, ['path', 'limit']),
-            },
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'read_files',
-                description: 'Batch read bounded file slices. Never repeat an identical call consecutively; reuse the prior result.',
-                parameters: obj({
-                    requests: {
-                        type: 'array',
-                        items: obj({
-                            path: str(),
-                            offset: int(1, 1_000_000),
-                            limit: int(1, 240),
-                            search: str(),
-                            context: int(0, 80),
-                            format: { type: 'string', enum: ['plain', 'numbered', 'sparse'] },
-                            max_bytes: int(256, 20_000),
-                        }, ['path', 'limit']),
-                    },
-                }, ['requests']),
-            },
-        },
-        // ────────────────────────────────────────────────────────────────────────────
-        // Writes/edits
-        // ────────────────────────────────────────────────────────────────────────────
-        {
-            type: 'function',
-            function: {
-                name: 'write_file',
-                description: 'Write file (atomic, backup). Existing non-empty files require overwrite=true (or force=true).',
-                parameters: obj({ path: str(), content: str(), overwrite: bool(), force: bool() }, [
-                    'path',
-                    'content',
-                ]),
-            },
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'apply_patch',
-                description: 'Apply unified diff patch (multi-file).\n\nUSAGE EXAMPLE:\n  apply_patch({\n    patch: "--- a/src/file.ts\\n+++ b/src/file.ts\\n@@ -1,5 +1,5 @@\\n-old text\\n+new text\\n",\n    files: ["src/file.ts"]\n  })\n\nThe patch must be valid unified diff text. Tool-call arguments must be valid JSON. Use strip=1 if paths include directory prefixes.\nFiles listed must match the paths in the diff.',
-                parameters: obj({
-                    patch: str(),
-                    files: { type: 'array', items: str() },
-                    strip: int(0, 5),
-                }, ['patch', 'files']),
-            },
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'edit_range',
-                description: 'Replace a line range in a file.\n\nUSAGE EXAMPLE:\n  edit_range({\n    path: "src/file.ts",\n    start_line: 10,\n    end_line: 15,\n    replacement: "new content\\nmore content"\n  })\n\n- start_line and end_line are 1-indexed (first line is 1, not 0)\n- To delete lines, set replacement to empty string ""\n- To insert at a position, set start_line and end_line to the same value\n- Tool-call arguments must be valid JSON (double quotes, no trailing commas/comments)\n- The replacement text replaces the entire range inclusive',
-                parameters: obj({
-                    path: str(),
-                    start_line: int(1),
-                    end_line: int(1),
-                    replacement: str(),
-                }, ['path', 'start_line', 'end_line', 'replacement']),
-            },
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'edit_file',
-                description: 'Legacy exact replace (requires old_text). Prefer apply_patch/edit_range.',
-                parameters: obj({ path: str(), old_text: str(), new_text: str(), replace_all: bool() }, [
-                    'path',
-                    'old_text',
-                    'new_text',
-                ]),
-            },
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'insert_file',
-                description: 'Insert text at line (0=prepend, -1=append).',
-                parameters: obj({ path: str(), line: int(), text: str() }, ['path', 'line', 'text']),
-            },
-        },
-        // ────────────────────────────────────────────────────────────────────────────
-        // Bounded listings/search (expose existing caps)
-        // ────────────────────────────────────────────────────────────────────────────
-        {
-            type: 'function',
-            function: {
-                name: 'list_dir',
-                description: 'List directory entries. Never repeat an identical call consecutively for the same path/options; reuse the prior result.',
-                parameters: obj({ path: str(), recursive: bool(), max_entries: int(1, 500) }, ['path']),
-            },
-        },
-        {
-            type: 'function',
-            function: {
-                name: 'search_files',
-                description: 'Search regex in files.',
-                parameters: obj({ pattern: str(), path: str(), include: str(), max_results: int(1, 100) }, [
-                    'pattern',
-                    'path',
-                ]),
-            },
-        },
-        // ────────────────────────────────────────────────────────────────────────────
-        // Exec (minified schema)
-        // ────────────────────────────────────────────────────────────────────────────
-        {
-            type: 'function',
-            function: {
-                name: 'exec',
-                description: 'Run bash -c; returns JSON rc/out/err.',
-                parameters: obj({ command: str(), cwd: str(), timeout: int(1, 120) }, ['command']),
-            },
-        },
-    ];
-    if (opts?.allowSpawnTask !== false) {
-        schemas.push({
-            type: 'function',
-            function: {
-                name: 'spawn_task',
-                description: 'Run a sub-agent task (no parent history).',
-                parameters: obj({
-                    task: str(),
-                    context_files: { type: 'array', items: str() },
-                    model: str(),
-                    endpoint: str(),
-                    max_iterations: int(),
-                    max_tokens: int(),
-                    timeout_sec: int(),
-                    system_prompt: str(),
-                    approval_mode: {
-                        type: 'string',
-                        enum: ['plan', 'reject', 'default', 'auto-edit', 'yolo'],
-                    },
-                }, ['task']),
-            },
-        });
-    }
-    if (opts?.activeVaultTools) {
-        schemas.push({
-            type: 'function',
-            function: {
-                name: 'vault_search',
-                description: 'Search vault.',
-                parameters: obj({ query: str(), limit: int() }, ['query']),
-            },
-        }, {
-            type: 'function',
-            function: {
-                name: 'vault_note',
-                description: 'Write vault note.',
-                parameters: obj({ key: str(), value: str() }, ['key', 'value']),
-            },
-        });
-    }
-    else if (opts?.passiveVault) {
-        // In passive mode, expose vault_search (read-only) so the model can recover
-        // compacted context on demand, but don't expose vault_note (write).
-        schemas.push({
-            type: 'function',
-            function: {
-                name: 'vault_search',
-                description: 'Search vault memory for earlier context that was compacted away. Use sparingly — only when you need to recall specific details from earlier in the conversation.',
-                parameters: obj({ query: str(), limit: int() }, ['query']),
-            },
-        });
-    }
-    // Phase 9: sys_context tool is only available in sys mode.
-    if (opts?.sysMode) {
-        schemas.push(SYS_CONTEXT_SCHEMA);
-    }
-    if (opts?.lspTools) {
-        schemas.push({
-            type: 'function',
-            function: {
-                name: 'lsp_diagnostics',
-                description: 'Get LSP diagnostics (errors/warnings) for file or project.',
-                parameters: obj({ path: str(), severity: int() }, []),
-            },
-        }, {
-            type: 'function',
-            function: {
-                name: 'lsp_symbols',
-                description: 'List symbols (functions, classes, vars) in a file.',
-                parameters: obj({ path: str() }, ['path']),
-            },
-        }, {
-            type: 'function',
-            function: {
-                name: 'lsp_hover',
-                description: 'Get type/docs for symbol at position.',
-                parameters: obj({ path: str(), line: int(), character: int() }, [
-                    'path',
-                    'line',
-                    'character',
-                ]),
-            },
-        }, {
-            type: 'function',
-            function: {
-                name: 'lsp_definition',
-                description: 'Go to definition of symbol at position.',
-                parameters: obj({ path: str(), line: int(), character: int() }, [
-                    'path',
-                    'line',
-                    'character',
-                ]),
-            },
-        }, {
-            type: 'function',
-            function: {
-                name: 'lsp_references',
-                description: 'Find all references to symbol at position.',
-                parameters: obj({ path: str(), line: int(), character: int(), max_results: int() }, [
-                    'path',
-                    'line',
-                    'character',
-                ]),
-            },
-        });
-    }
-    if (opts?.mcpTools?.length) {
-        schemas.push(...opts.mcpTools);
-    }
-    return schemas;
-}
-function isReadOnlyTool(name) {
-    return (name === 'read_file' ||
-        name === 'read_files' ||
-        name === 'list_dir' ||
-        name === 'search_files' ||
-        name === 'vault_search' ||
-        name === 'sys_context');
-}
-/** Human-readable summary of what a blocked tool call would do. */
-function planModeSummary(name, args) {
-    switch (name) {
-        case 'write_file':
-            return `write ${args.path ?? 'unknown'} (${typeof args.content === 'string' ? args.content.split('\n').length : '?'} lines)`;
-        case 'apply_patch':
-            return `apply patch to ${Array.isArray(args.files) ? args.files.length : '?'} file(s)`;
-        case 'edit_range':
-            return `edit ${args.path ?? 'unknown'} lines ${args.start_line ?? '?'}-${args.end_line ?? '?'}`;
-        case 'edit_file':
-            return `edit ${args.path ?? 'unknown'} (replace ${typeof args.old_text === 'string' ? args.old_text.split('\n').length : '?'} lines)`;
-        case 'insert_file':
-            return `insert into ${args.path ?? 'unknown'} at line ${args.line ?? '?'}`;
-        case 'exec':
-            return `run: ${typeof args.command === 'string' ? args.command.slice(0, 80) : 'unknown'}`;
-        case 'spawn_task':
-            return `spawn sub-agent task: ${typeof args.task === 'string' ? args.task.slice(0, 80) : 'unknown'}`;
-        case 'vault_note':
-            return `vault note: ${args.key ?? 'unknown'}`;
-        default:
-            return `${name}(${Object.keys(args).join(', ')})`;
-    }
-}
-function userContentToText(content) {
-    if (typeof content === 'string')
-        return content;
-    return content
-        .filter((p) => p.type === 'text')
-        .map((p) => p.text)
-        .join('\n')
-        .trim();
-}
-function userDisallowsDelegation(content) {
-    const text = userContentToText(content).toLowerCase();
-    if (!text)
-        return false;
-    const mentionsDelegation = /\b(?:spawn[_\-\s]?task|sub[\-\s]?agents?|delegate|delegation)\b/.test(text);
-    if (!mentionsDelegation)
-        return false;
-    const negationNearDelegation = /\b(?:do not|don't|dont|no|without|avoid|skip|never)\b[^\n.]{0,90}\b(?:spawn[_\-\s]?task|sub[\-\s]?agents?|delegate|delegation)\b/.test(text) ||
-        /\b(?:spawn[_\-\s]?task|sub[\-\s]?agents?|delegate|delegation)\b[^\n.]{0,50}\b(?:do not|don't|dont|not allowed|forbidden|no)\b/.test(text);
-    return negationNearDelegation;
-}
 export async function createSession(opts) {
     const cfg = opts.config;
     const projectDir = cfg.dir ?? process.cwd();
@@ -1313,7 +763,7 @@ export async function createSession(opts) {
                 else if (step.tool === 'spawn_task') {
                     content = await runSpawnTaskCore(step.args, { signal: inFlight?.signal });
                 }
-                else if (LSP_TOOL_NAME_SET.has(step.tool) && lspManager) {
+                else if (isLspTool(step.tool) && lspManager) {
                     content = await dispatchLspTool(step.tool, step.args);
                 }
                 else if (mcpManager?.hasTool(step.tool)) {
@@ -1968,10 +1418,39 @@ export async function createSession(opts) {
         const hookObj = typeof hooks === 'function' ? { onToken: hooks } : (hooks ?? {});
         let turns = 0;
         let toolCalls = 0;
+        const tokenEstimateCache = new WeakMap();
+        const estimateTokensCached = (msgs) => {
+            const key = msgs;
+            const cached = tokenEstimateCache.get(key);
+            if (cached !== undefined)
+                return cached;
+            const v = estimateTokensFromMessages(msgs);
+            tokenEstimateCache.set(key, v);
+            return v;
+        };
+        const perfEnabled = process.env.IDLEHANDS_PERF_TRACE === '1';
+        const perf = {
+            modelMs: 0,
+            ttftMsSum: 0,
+            ttftSamples: 0,
+            compactions: 0,
+            compactMs: 0,
+        };
         const askId = `ask-${timestampedId()}`;
-        const emitToolCall = async (call) => {
-            hookObj.onToolCall?.(call);
-            await hookManager.emit('tool_call', { askId, turn: turns, call });
+        const hooksEnabled = hookManager.isEnabled();
+        const hasOnToolCall = Boolean(hookObj.onToolCall);
+        const hasOnToolResult = Boolean(hookObj.onToolResult);
+        const hasOnToolLoop = Boolean(hookObj.onToolLoop);
+        const hasOnTurnEnd = Boolean(hookObj.onTurnEnd);
+        const emitToolCall = async (id, name, args) => {
+            if (!hasOnToolCall && !hooksEnabled)
+                return;
+            const call = { id, name, args };
+            if (hasOnToolCall)
+                hookObj.onToolCall?.(call);
+            if (hooksEnabled) {
+                await hookManager.emit('tool_call', { askId, turn: turns, call });
+            }
         };
         const emitToolStream = (stream) => {
             try {
@@ -1980,29 +1459,46 @@ export async function createSession(opts) {
             catch {
                 // best effort
             }
-            try {
-                void hookManager.emit('tool_stream', { askId, turn: turns, stream });
-            }
-            catch {
-                // best effort
+            if (hooksEnabled) {
+                try {
+                    void hookManager.emit('tool_stream', { askId, turn: turns, stream });
+                }
+                catch {
+                    // best effort
+                }
             }
         };
         const isReadOnlyToolDynamic = (toolName) => {
             return (isReadOnlyTool(toolName) ||
-                LSP_TOOL_NAME_SET.has(toolName) ||
+                isLspTool(toolName) ||
                 Boolean(mcpManager?.isToolReadOnly(toolName)));
         };
         const emitToolResult = async (result) => {
-            await hookObj.onToolResult?.(result);
-            await hookManager.emit('tool_result', { askId, turn: turns, result });
+            if (!hasOnToolResult && !hooksEnabled)
+                return;
+            if (hasOnToolResult)
+                await hookObj.onToolResult?.(result);
+            if (hooksEnabled) {
+                await hookManager.emit('tool_result', { askId, turn: turns, result });
+            }
         };
         const emitToolLoop = async (loop) => {
-            await hookObj.onToolLoop?.(loop);
-            await hookManager.emit('tool_loop', { askId, turn: turns, loop });
+            if (!hasOnToolLoop && !hooksEnabled)
+                return;
+            if (hasOnToolLoop)
+                await hookObj.onToolLoop?.(loop);
+            if (hooksEnabled) {
+                await hookManager.emit('tool_loop', { askId, turn: turns, loop });
+            }
         };
         const emitTurnEnd = async (stats) => {
-            await hookObj.onTurnEnd?.(stats);
-            await hookManager.emit('turn_end', { askId, stats });
+            if (!hasOnTurnEnd && !hooksEnabled)
+                return;
+            if (hasOnTurnEnd)
+                await hookObj.onTurnEnd?.(stats);
+            if (hooksEnabled) {
+                await hookManager.emit('turn_end', { askId, stats });
+            }
         };
         const finalizeAsk = async (text) => {
             const finalText = ensureInformativeAssistantText(text, { toolCalls, turns });
@@ -2034,13 +1530,20 @@ export async function createSession(opts) {
                     // best-effort — never block ask completion for summary persistence
                 }
             }
-            await hookManager.emit('ask_end', { askId, text: finalText, turns, toolCalls });
+            if (hooksEnabled)
+                await hookManager.emit('ask_end', { askId, text: finalText, turns, toolCalls });
+            if (perfEnabled) {
+                const wallMs = Date.now() - wallStart;
+                const avgTtft = perf.ttftSamples > 0 ? Math.round(perf.ttftMsSum / perf.ttftSamples) : 0;
+                console.error(`[perf] ask=${askId} turns=${turns} toolCalls=${toolCalls} wallMs=${wallMs} modelMs=${perf.modelMs} compactMs=${perf.compactMs} avgTTFTms=${avgTtft} compactions=${perf.compactions}`);
+            }
             return { text: finalText, turns, toolCalls };
         };
         const rawInstructionText = userContentToText(instruction).trim();
         lastAskInstructionText = rawInstructionText;
         lastCompactionReminderObjective = '';
-        await hookManager.emit('ask_start', { askId, instruction: rawInstructionText });
+        if (hooksEnabled)
+            await hookManager.emit('ask_start', { askId, instruction: rawInstructionText });
         const reviewKeys = reviewArtifactKeys(projectDir);
         const retrievalRequested = looksLikeReviewRetrievalRequest(rawInstructionText);
         const shouldPersistReviewArtifact = looksLikeCodeReviewRequest(rawInstructionText) && !retrievalRequested;
@@ -2313,15 +1816,17 @@ export async function createSession(opts) {
                 if (inFlight?.signal?.aborted)
                     break;
                 turns++;
-                await hookManager.emit('turn_start', { askId, turn: turns });
+                if (hooksEnabled)
+                    await hookManager.emit('turn_start', { askId, turn: turns });
                 const wallElapsed = (Date.now() - wallStart) / 1000;
                 if (wallElapsed > cfg.timeout) {
                     throw new Error(`session timeout exceeded (${cfg.timeout}s) after ${wallElapsed.toFixed(1)}s`);
                 }
                 await maybeAutoDetectModelChange();
+                const compactionStartMs = Date.now();
                 await runCompactionWithLock('auto context-budget compaction', async () => {
                     const beforeMsgs = messages;
-                    const beforeTokens = estimateTokensFromMessages(beforeMsgs);
+                    const beforeTokens = estimateTokensCached(beforeMsgs);
                     const compacted = enforceContextBudget({
                         messages: beforeMsgs,
                         contextWindow,
@@ -2330,8 +1835,15 @@ export async function createSession(opts) {
                         compactAt: cfg.compact_at ?? 0.8,
                         toolSchemaTokens: estimateToolSchemaTokens(getToolsSchema()),
                     });
-                    const compactedByRefs = new Set(compacted);
-                    const dropped = beforeMsgs.filter((m) => !compactedByRefs.has(m));
+                    let dropped;
+                    if (compacted.length === beforeMsgs.length) {
+                        // Fast path: no drops expected when lengths match.
+                        dropped = [];
+                    }
+                    else {
+                        const compactedByRefs = new Set(compacted);
+                        dropped = beforeMsgs.filter((m) => !compactedByRefs.has(m));
+                    }
                     if (dropped.length && vault) {
                         try {
                             // Store the original/current user prompt before compaction so it survives context loss.
@@ -2366,7 +1878,10 @@ export async function createSession(opts) {
                     messages = compacted;
                     let summaryUsed = false;
                     if (dropped.length) {
-                        const droppedTokens = estimateTokensFromMessages(dropped);
+                        let droppedTokens = 0;
+                        if (cfg.compact_summary !== false) {
+                            droppedTokens = estimateTokensCached(dropped);
+                        }
                         if (cfg.compact_summary !== false && droppedTokens > 200) {
                             try {
                                 const summaryContent = buildCompactionSummaryPrompt(dropped);
@@ -2414,11 +1929,12 @@ export async function createSession(opts) {
                         }
                     }
                     // Update token count AFTER injections so downstream reads are accurate
-                    currentContextTokens = estimateTokensFromMessages(messages);
-                    const afterTokens = estimateTokensFromMessages(compacted);
+                    currentContextTokens = estimateTokensCached(messages);
+                    const afterTokens = estimateTokensCached(compacted);
                     const freedTokens = Math.max(0, beforeTokens - afterTokens);
                     // Emit compaction event for callers (e.g. Anton controller → Discord)
                     if (dropped.length) {
+                        perf.compactions++;
                         try {
                             await hookObj.onCompaction?.({
                                 droppedMessages: dropped.length,
@@ -2440,6 +1956,7 @@ export async function createSession(opts) {
                         dryRun: false,
                     };
                 });
+                perf.compactMs += Date.now() - compactionStartMs;
                 const ac = makeAbortController();
                 inFlight = ac;
                 // If caller provided an AbortSignal (bench iteration timeout, etc), propagate it.
@@ -2511,6 +2028,11 @@ export async function createSession(opts) {
                     inFlight = null;
                 }
                 const ttcMs = Date.now() - turnStartMs;
+                perf.modelMs += ttcMs;
+                if (ttftMs !== undefined) {
+                    perf.ttftMsSum += ttftMs;
+                    perf.ttftSamples++;
+                }
                 const promptTokensTurn = resp.usage?.prompt_tokens ?? 0;
                 const completionTokensTurn = resp.usage?.completion_tokens ?? 0;
                 // Track server-reported usage when available
@@ -2743,7 +2265,7 @@ export async function createSession(opts) {
                         },
                     });
                     // Tool-call argument parsing and validation logic
-                    const fileMutationsInTurn = toolCallsArr.filter((tc) => FILE_MUTATION_TOOL_SET.has(tc.function?.name)).length;
+                    const fileMutationsInTurn = toolCallsArr.filter((tc) => isMutationTool(tc.function?.name)).length;
                     if (fileMutationsInTurn >= 3 && isGitDirty(ctx.cwd)) {
                         const shouldStash = confirmBridge
                             ? await confirmBridge(`Working tree is dirty and the agent plans ${fileMutationsInTurn} file edits. Stash current changes first? [Y/n]`, { tool: 'git_stash', args: { fileMutationsInTurn } })
@@ -2948,18 +2470,40 @@ export async function createSession(opts) {
                             }
                             continue;
                         }
-                        // Default behavior for mutating/other tools: break on repeated identical signature.
+                        // Improved handling of mutating tool loops - gradual recovery instead of immediate error
+                        const sigCount = sigCounts.get(sig) ?? 0;
                         const loopThreshold = harness.quirks.loopsOnToolError ? 2 : 3;
-                        if ((sigCounts.get(sig) ?? 0) >= loopThreshold) {
+                        if (sigCount >= loopThreshold) {
                             const argsObj = sigMetaBySig.get(sig)?.args ?? {};
                             const argsRaw = JSON.stringify(argsObj);
                             const argsPreview = argsRaw.length > 220 ? argsRaw.slice(0, 220) + '…' : argsRaw;
-                            throw new Error(`tool ${toolName}: identical call repeated ${loopThreshold}x across turns; breaking loop. ` +
-                                `args=${argsPreview}\n` +
-                                `Hint: you repeated the same tool call ${loopThreshold} times with identical arguments. ` +
-                                `If the call succeeded, move on to the next step. ` +
-                                `If it failed, check that all required parameters are present and correct. ` +
-                                `For write_file/edit_file/apply_patch/edit_range, ensure required args are present (content/old_text/new_text/patch/files/start_line/end_line/replacement).`);
+                            // At threshold: trigger toolless recovery instead of throwing error
+                            // This gives the model a chance to think and try a different approach
+                            console.error(`[tool-loop] critical: ${toolName} repeated ${sigCount}x with same args. Triggering recovery turn.`);
+                            shouldForceToollessRecovery = true;
+                            // Poison this specific tool signature to prevent re-execution
+                            poisonedToolSigs.add(sig);
+                            // Add helpful guidance
+                            messages.push({
+                                role: 'user',
+                                content: `[system] Tool loop detected: ${toolName} called ${sigCount}x with identical arguments.\n` +
+                                    `args=${argsPreview}\n\n` +
+                                    `The same edit is being attempted repeatedly. This usually means:\n` +
+                                    `1. The edit already succeeded - verify by reading the file\n` +
+                                    `2. The old_text doesn't match - read the file to see actual content\n` +
+                                    `3. A different approach is needed\n\n` +
+                                    `Do NOT repeat the same edit. Read the file first, then decide on next steps.`,
+                            });
+                            continue;
+                        }
+                        // At sigCount === loopThreshold - 1: inject early warning
+                        if (sigCount === loopThreshold - 1) {
+                            console.error(`[tool-loop] warning: ${toolName} repeated ${sigCount}x. Next repeat will trigger recovery.`);
+                            messages.push({
+                                role: 'user',
+                                content: `[system] Warning: ${toolName} has been called ${sigCount} times with identical arguments. ` +
+                                    `If this edit keeps failing, read the target file to verify its current state before trying again.`,
+                            });
                         }
                     }
                     // Update consecutive tracking: save this turn's signatures for next turn comparison.
@@ -3002,11 +2546,26 @@ export async function createSession(opts) {
                         catch {
                             // Respect harness retry limit for malformed JSON (§4i)
                             malformedCount++;
+                            // Detect if the model is outputting diff/patch format instead of JSON
+                            const looksLikeDiff = /^[\s"]*---\s+a\/|^\+\+\+\s+b\/|^@@\s+-\d+/m.test(rawArgs);
+                            const looksLikePatch = /^diff\s+--git|^Index:|^\*\*\*\s+/m.test(rawArgs);
                             if (malformedCount > harness.toolCalls.retryOnMalformed) {
                                 // Break the outer loop — this model won't self-correct
-                                throw new AgentLoopBreak(`tool ${name}: malformed JSON exceeded retry limit (${harness.toolCalls.retryOnMalformed}): ${rawArgs.slice(0, 200)}`);
+                                const hint = looksLikeDiff || looksLikePatch
+                                    ? ' The model is outputting diff/patch format instead of JSON. This may be a model compatibility issue.'
+                                    : '';
+                                throw new AgentLoopBreak(`tool ${name}: malformed JSON exceeded retry limit (${harness.toolCalls.retryOnMalformed}): ${rawArgs.slice(0, 200)}${hint}`);
+                            }
+                            // Give specific guidance based on the error pattern
+                            let hint = 'Return a valid JSON object for function.arguments.';
+                            if (looksLikeDiff || looksLikePatch) {
+                                hint =
+                                    'ERROR: You output a diff/patch format instead of JSON. ' +
+                                        'Tool arguments must be a JSON object like {"path": "file.txt", "old_text": "...", "new_text": "..."}. ' +
+                                        'Do NOT use unified diff format (--- a/ +++ b/ @@). ' +
+                                        'Use the exact JSON schema required by the tool.';
                             }
-                            throw new ToolError('invalid_args', `tool ${name}: arguments not valid JSON`, false, 'Return a valid JSON object for function.arguments.', { raw: rawArgs.slice(0, 200) });
+                            throw new ToolError('invalid_args', `tool ${name}: arguments not valid JSON`, false, hint, { raw: rawArgs.slice(0, 200) });
                         }
                         if (args == null || typeof args !== 'object' || Array.isArray(args)) {
                             throw new ValidationError([
@@ -3014,10 +2573,10 @@ export async function createSession(opts) {
                             ]);
                         }
                         const builtInFn = tools[name];
-                        const isLspTool = LSP_TOOL_NAME_SET.has(name);
+                        const lspToolCall = isLspTool(name);
                         const isSpawnTask = name === 'spawn_task';
                         const hasMcpTool = mcpManager?.hasTool(name) === true;
-                        if (!builtInFn && !isLspTool && !hasMcpTool && !isSpawnTask)
+                        if (!builtInFn && !lspToolCall && !hasMcpTool && !isSpawnTask)
                             throw new Error(`unknown tool: ${name}`);
                         // Keep parsed args by call-id so we can digest/archive tool outputs with context.
                         toolArgsByCallId.set(callId, args && typeof args === 'object' && !Array.isArray(args) ? args : {});
@@ -3051,7 +2610,7 @@ export async function createSession(opts) {
                                 throw new Error(`exec: ${reason} — command: ${args.command}`);
                             }
                         }
-                        if (FILE_MUTATION_TOOL_SET.has(name) && typeof args.path === 'string') {
+                        if (isMutationTool(name) && typeof args.path === 'string') {
                             const absPath = args.path.startsWith('/')
                                 ? args.path
                                 : path.resolve(projectDir, args.path);
@@ -3075,7 +2634,7 @@ export async function createSession(opts) {
                             const searchTerm = typeof args.search === 'string' ? args.search : '';
                             // Fix 1: Hard cumulative budget — refuse reads past hard cap
                             if (cumulativeReadOnlyCalls > READ_BUDGET_HARD) {
-                                await emitToolCall({ id: callId, name, args });
+                                await emitToolCall(callId, name, args);
                                 await emitToolResult({
                                     id: callId,
                                     name,
@@ -3102,7 +2661,7 @@ export async function createSession(opts) {
                                     blockedDirs.add(parentDir);
                                 }
                                 if (blockedDirs.has(parentDir) && uniqueCount > 8) {
-                                    await emitToolCall({ id: callId, name, args });
+                                    await emitToolCall(callId, name, args);
                                     await emitToolResult({
                                         id: callId,
                                         name,
@@ -3123,7 +2682,7 @@ export async function createSession(opts) {
                                     searchTermFiles.set(key, new Set());
                                 searchTermFiles.get(key).add(filePath);
                                 if (searchTermFiles.get(key).size >= 3) {
-                                    await emitToolCall({ id: callId, name, args });
+                                    await emitToolCall(callId, name, args);
                                     await emitToolResult({
                                         id: callId,
                                         name,
@@ -3159,7 +2718,7 @@ export async function createSession(opts) {
                                 reason: `plan mode: ${summary}`,
                             });
                             // Hook: onToolCall + onToolResult for plan-blocked actions
-                            await emitToolCall({ id: callId, name, args });
+                            await emitToolCall(callId, name, args);
                             await emitToolResult({
                                 id: callId,
                                 name,
@@ -3170,7 +2729,7 @@ export async function createSession(opts) {
                             return { id: callId, content: blockedMsg };
                         }
                         // Hook: onToolCall (Phase 8.5)
-                        await emitToolCall({ id: callId, name, args });
+                        await emitToolCall(callId, name, args);
                         if (cfg.step_mode) {
                             const stepPrompt = `Step mode: execute ${name}(${JSON.stringify(args).slice(0, 200)}) ? [Y/n]`;
                             const ok = confirmBridge
@@ -3259,7 +2818,7 @@ export async function createSession(opts) {
                                     }
                                 }
                             }
-                            else if (isLspTool && lspManager) {
+                            else if (isLspTool(name) && lspManager) {
                                 // LSP tool dispatch
                                 content = await dispatchLspTool(name, args);
                             }
@@ -3325,7 +2884,7 @@ export async function createSession(opts) {
                             if (lines.length > 0)
                                 resultEvent.searchMatches = lines.slice(0, 20);
                         }
-                        else if (FILE_MUTATION_TOOL_SET.has(name) && replay) {
+                        else if (isMutationTool(name) && replay) {
                             // Grab the most recent checkpoint for a diff preview
                             try {
                                 const cps = await replay.list(1);
@@ -3348,7 +2907,7 @@ export async function createSession(opts) {
                         await emitToolResult(resultEvent);
                         // Proactive LSP diagnostics after file mutations
                         if (lspManager?.hasServers() && lspCfg?.proactive_diagnostics !== false) {
-                            if (FILE_MUTATION_TOOL_SET.has(name)) {
+                            if (isMutationTool(name)) {
                                 const mutatedPath = typeof args.path === 'string' ? args.path : '';
                                 if (mutatedPath) {
                                     try {
@@ -3380,7 +2939,7 @@ export async function createSession(opts) {
                         // ── 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.
-                        if (FILE_MUTATION_TOOL_SET.has(name) && toolSuccess && typeof args.path === 'string') {
+                        if (isMutationTool(name) && toolSuccess && typeof args.path === 'string') {
                             const absPath = args.path.startsWith('/')
                                 ? args.path
                                 : path.resolve(projectDir, args.path);
@@ -3431,7 +2990,13 @@ export async function createSession(opts) {
                                 }
                             }
                         }
-                        return { id: callId, content };
+                        // Context-aware truncation: cap oversized tool results before returning
+                        // to prevent blowing out the context window on subsequent LLM calls.
+                        const truncated = truncateToolResultContent(content, contextWindow);
+                        if (truncated.truncated && cfg.verbose) {
+                            console.warn(`[context-budget] truncated ${name} result: ${content.length} → ${truncated.content.length} chars`);
+                        }
+                        return { id: callId, content: truncated.content };
                     };
                     const results = [];
                     let invalidArgsThisTurn = false;
@@ -3550,7 +3115,7 @@ export async function createSession(opts) {
                             }
                             catch (e) {
                                 results.push(await catchToolError(e, tc));
-                                if (FILE_MUTATION_TOOL_SET.has(tc.function.name)) {
+                                if (isMutationTool(tc.function.name)) {
                                     // Fail-fast: after mutating tool failure, stop the remaining batch.
                                     break;
                                 }
@@ -3568,7 +3133,7 @@ export async function createSession(opts) {
                             }
                             catch (e) {
                                 results.push(await catchToolError(e, tc));
-                                if (FILE_MUTATION_TOOL_SET.has(tc.function.name)) {
+                                if (isMutationTool(tc.function.name)) {
                                     // Fail-fast: after mutating tool failure, stop the remaining batch.
                                     break;
                                 }
@@ -3797,12 +3362,13 @@ export async function createSession(opts) {
                 })();
                 const err = new Error(`BUG: threw undefined in agent.ask() (turn=${turns}). lastMsg=${lastMsg?.role ?? 'unknown'}:${lastMsgPreview}`);
                 await persistFailure(err, `ask turn ${turns}`);
-                await hookManager.emit('ask_error', {
-                    askId,
-                    error: err.message,
-                    turns,
-                    toolCalls,
-                });
+                if (hooksEnabled)
+                    await hookManager.emit('ask_error', {
+                        askId,
+                        error: err.message,
+                        turns,
+                        toolCalls,
+                    });
                 throw err;
             }
             await persistFailure(e, `ask turn ${turns}`);
@@ -3813,12 +3379,13 @@ export async function createSession(opts) {
             // Never rethrow undefined; normalize to Error for debuggability.
             if (e === undefined) {
                 const normalized = new Error('BUG: threw undefined (normalized at ask() boundary)');
-                await hookManager.emit('ask_error', {
-                    askId,
-                    error: normalized.message,
-                    turns,
-                    toolCalls,
-                });
+                if (hooksEnabled)
+                    await hookManager.emit('ask_error', {
+                        askId,
+                        error: normalized.message,
+                        turns,
+                        toolCalls,
+                    });
                 throw normalized;
             }
             await hookManager.emit('ask_error', {
@@ -3918,21 +3485,4 @@ export async function runAgent(opts) {
     });
     return session.ask(opts.instruction, opts.onToken);
 }
-async function autoPickModel(client, cached) {
-    const ac = makeAbortController();
-    const timer = setTimeout(() => ac.abort(), 3000);
-    try {
-        const models = cached ?? normalizeModelsResponse(await client.models(ac.signal));
-        const q = models.data.find((m) => /qwen/i.test(m.id));
-        if (q)
-            return q.id;
-        const first = models.data[0]?.id;
-        if (!first)
-            throw new Error('No models found on server. Check your endpoint and that a model is loaded.');
-        return first;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
 //# sourceMappingURL=agent.js.map