oroute-cli 0.1.0 → 0.2.0

package/package.json

@@ -1,17 +1,32 @@
 {
   "name": "oroute-cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "O'Route CLI — AI API auto-routing for 13 models from your terminal",
   "type": "module",
   "bin": {
-    "oroute": "./dist/index.js"
+    "oroute": "./bin/oroute.cjs"
   },
   "files": [
-    "dist/**/*"
+    "bin/oroute.cjs",
+    "dist/oroute.cjs"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
-    "ai", "cli", "llm", "routing", "claude", "gpt", "gemini",
-    "deepseek", "qwen", "anthropic", "openai", "agent", "coding"
+    "ai",
+    "cli",
+    "llm",
+    "routing",
+    "claude",
+    "gpt",
+    "gemini",
+    "deepseek",
+    "qwen",
+    "anthropic",
+    "openai",
+    "agent",
+    "coding"
   ],
   "author": "O'Route <netclaus@gmail.com>",
   "license": "MIT",
@@ -21,13 +36,19 @@
     "url": "https://github.com/netclaus/oroute"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node esbuild.config.mjs",
+    "build:bundle": "node esbuild.config.mjs",
     "dev": "tsx src/index.ts",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "@types/node": "^22.19.15",
+    "esbuild": "^0.27.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "pdf-parse": "1.1.1"
   }
 }

package/dist/agent.d.ts

@@ -1,11 +0,0 @@
-export interface AgentConfig {
-    apiKey?: string;
-    apiUrl?: string;
-    model?: string;
-    confirmBeforeWrite?: boolean;
-    confirmBeforeExecute?: boolean;
-    skipConfirmations?: boolean;
-    planMode?: boolean;
-}
-/** Main agent chat loop with tool use */
-export declare function agentChat(config: AgentConfig): Promise<void>;

package/dist/agent.js

@@ -1,569 +0,0 @@
-/**
- * Agent loop — send messages with tools, handle tool_use, stream responses.
- * Integrates: A1 Streaming, A2 Context, A3 Markdown, A4 History, A5 Commands, A6 Multi-line, B1 Git, B6 Cost
- * B2 Glob, B3 Notebook, B4 ReadImage, B7 Session, C1 Parallel, C3 Hooks, C5 Memory
- */
-import * as os from 'node:os';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as readline from 'node:readline';
-import { readFileTool, readFileDefinition, writeFileTool, writeFileDefinition, generateDiff, listDirectoryTool, listDirectoryDefinition, searchFilesTool, searchFilesDefinition, executeCommandTool, executeCommandDefinition, editFileTool, editFileDefinition, generateEditDiff, globTool, globDefinition, readImageTool, readImageDefinition, } from './tools/index.js';
-import { GREEN, GRAY, BOLD, DIM, RESET, YELLOW, RED, printToolUse, printToolResult, printError, printSuccess, confirm, createSpinner, } from './ui.js';
-import { renderMarkdown } from './markdown.js';
-import { loadProjectContext, buildContextString } from './context.js';
-import { estimateTokens, TOKEN_THRESHOLD, compressHistory } from './history.js';
-import { parseSSEStream, isSSEResponse } from './streaming.js';
-import { handleSlashCommand } from './commands.js';
-import { createSessionStats, updateStats, printExitSummary } from './cost.js';
-import { loadHooks, runHooks } from './hooks.js';
-import { buildMemoryContext } from './memory.js';
-import { autoSaveSession } from './session.js';
-const TOOL_DEFINITIONS = [
-    readFileDefinition,
-    writeFileDefinition,
-    listDirectoryDefinition,
-    searchFilesDefinition,
-    executeCommandDefinition,
-    editFileDefinition,
-    globDefinition,
-    readImageDefinition,
-];
-/** C1: Tools that are safe to run in parallel (read-only, no side effects) */
-const PARALLEL_SAFE_TOOLS = new Set([
-    'read_file', 'list_directory', 'search_files', 'glob', 'read_image',
-]);
-/** Max chars to send as tool result to API (prevent token overflow) */
-const MAX_TOOL_RESULT_CHARS = 4000;
-/** Detect if a directory is a project (has package.json, .git, etc.) */
-function detectProject(dir) {
-    const markers = ['package.json', 'Cargo.toml', 'pyproject.toml', 'go.mod', '.git'];
-    for (const m of markers) {
-        if (fs.existsSync(path.join(dir, m))) {
-            if (m === 'package.json') {
-                try {
-                    const pkg = JSON.parse(fs.readFileSync(path.join(dir, m), 'utf-8'));
-                    return { isProject: true, name: pkg.name ?? path.basename(dir) };
-                }
-                catch {
-                    return { isProject: true, name: path.basename(dir) };
-                }
-            }
-            return { isProject: true, name: path.basename(dir) };
-        }
-    }
-    return { isProject: false };
-}
-/** Find nearest project directory by walking up */
-function findProjectRoot(startDir) {
-    let dir = startDir;
-    for (let i = 0; i < 10; i++) {
-        if (detectProject(dir).isProject)
-            return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
-}
-function buildSystemPrompt(cwd, contextStr, memoryStr) {
-    const project = detectProject(cwd);
-    const projectInfo = project.isProject
-        ? `\nProject: ${project.name} (${cwd})`
-        : '\nNo project detected in current directory.';
-    const contextSection = contextStr
-        ? `\n\n--- Project Context ---\n${contextStr}\n--- End Context ---`
-        : '';
-    const memorySection = memoryStr
-        ? `\n\n${memoryStr}`
-        : '';
-    return `You are O'Route CLI Agent, an expert developer assistant with file system access.
-
-Current working directory: ${cwd}${projectInfo}
-OS: ${os.platform()} ${os.arch()}
-Node: ${process.version}${contextSection}${memorySection}
-
-You have access to file system tools:
-- read_file: Read file contents (including .ipynb notebooks)
-- write_file: Create or overwrite files
-- edit_file: Replace a specific string in a file (str_replace)
-- list_directory: List directory tree structure (use "." for current dir)
-- search_files: Search for text patterns in files (grep-like)
-- execute_command: Run whitelisted shell commands (npm, pnpm, git, node, etc.)
-- glob: Find files matching glob patterns (e.g. "**/*.tsx")
-- read_image: Read image files for visual analysis
-
-Guidelines:
-- Always use "." as the path for list_directory to show current project, not absolute paths.
-- Keep tool results concise. If a directory has many files, use depth=1.
-- When the user writes in Korean, respond in Korean.
-- Be concise but thorough.
-- If a task requires multiple steps, execute them one at a time.
-- Always explain what you're doing before using tools.
-- Format responses with markdown for readability.`;
-}
-/** Truncate tool result to prevent token overflow */
-function truncateResult(result) {
-    if (result.length <= MAX_TOOL_RESULT_CHARS)
-        return result;
-    return result.slice(0, MAX_TOOL_RESULT_CHARS) + `\n... (truncated, ${result.length - MAX_TOOL_RESULT_CHARS} chars omitted)`;
-}
-/** Execute a single tool call and return the result */
-async function executeTool(tool, cwd, config) {
-    const confirmWrite = config.skipConfirmations ? false : (config.confirmBeforeWrite !== false);
-    const confirmExec = config.skipConfirmations ? false : (config.confirmBeforeExecute !== false);
-    try {
-        switch (tool.name) {
-            case 'read_file': {
-                const input = tool.input;
-                printToolUse('read_file', input.path);
-                const result = readFileTool(input, cwd);
-                printToolResult(result.content);
-                return truncateResult(JSON.stringify({ content: result.content, lines: result.lines, size: result.size }));
-            }
-            case 'write_file': {
-                const input = tool.input;
-                printToolUse('write_file', input.path);
-                const diff = generateDiff(input.path, input.content, cwd);
-                console.log(`${GRAY}${diff}${RESET}`);
-                if (confirmWrite) {
-                    const ok = await confirm(`Write to ${input.path}?`);
-                    if (!ok)
-                        return JSON.stringify({ success: false, reason: 'User declined' });
-                }
-                const result = writeFileTool(input, cwd);
-                printSuccess(`Written ${result.bytesWritten} bytes${result.isNew ? ' (new file)' : ''}`);
-                return JSON.stringify(result);
-            }
-            case 'list_directory': {
-                const input = tool.input;
-                printToolUse('list_directory', input.path);
-                const tree = listDirectoryTool(input, cwd);
-                printToolResult(tree);
-                return truncateResult(tree);
-            }
-            case 'search_files': {
-                const input = tool.input;
-                printToolUse('search_files', `"${input.pattern}" in ${input.path}`);
-                const results = searchFilesTool(input, cwd);
-                const formatted = results.map(r => `${r.file}:${r.line}: ${r.content}`).join('\n');
-                printToolResult(formatted || 'No matches found.');
-                return truncateResult(JSON.stringify(results));
-            }
-            case 'execute_command': {
-                const input = tool.input;
-                printToolUse('execute_command', input.command);
-                if (config.planMode) {
-                    console.log(`${YELLOW}  [PLAN MODE] Would execute: ${input.command}${RESET}`);
-                    return JSON.stringify({ stdout: '[plan mode — not executed]', stderr: '', exitCode: 0 });
-                }
-                if (confirmExec) {
-                    const ok = await confirm(`Execute: ${input.command}`);
-                    if (!ok)
-                        return JSON.stringify({ stdout: '', stderr: 'User declined', exitCode: -1 });
-                }
-                const result = executeCommandTool(input, cwd);
-                if (result.stdout)
-                    printToolResult(result.stdout);
-                if (result.stderr)
-                    console.log(`${RED}${result.stderr}${RESET}`);
-                if (result.exitCode === 0)
-                    printSuccess('Command completed');
-                else
-                    console.log(`${YELLOW}  Exit code: ${result.exitCode}${RESET}`);
-                return truncateResult(JSON.stringify(result));
-            }
-            case 'edit_file': {
-                const input = tool.input;
-                printToolUse('edit_file', input.path);
-                const diff = generateEditDiff(input);
-                console.log(`${GRAY}${diff}${RESET}`);
-                if (config.planMode) {
-                    console.log(`${YELLOW}  [PLAN MODE] Would edit: ${input.path}${RESET}`);
-                    return JSON.stringify({ success: true, note: 'plan mode — not executed' });
-                }
-                if (confirmWrite) {
-                    const ok = await confirm(`Edit ${input.path}?`);
-                    if (!ok)
-                        return JSON.stringify({ success: false, reason: 'User declined' });
-                }
-                const result = editFileTool(input, cwd);
-                printSuccess('Edit applied');
-                return JSON.stringify(result);
-            }
-            case 'glob': {
-                const input = tool.input;
-                printToolUse('glob', input.pattern);
-                const results = globTool(input, cwd);
-                const formatted = results.join('\n');
-                printToolResult(formatted || 'No matches found.');
-                return truncateResult(JSON.stringify({ matches: results, count: results.length }));
-            }
-            case 'read_image': {
-                const input = tool.input;
-                printToolUse('read_image', input.path);
-                const result = readImageTool(input, cwd);
-                printSuccess(`Read image: ${result.media_type}, ${(result.size / 1024).toFixed(1)}KB`);
-                return JSON.stringify(result);
-            }
-            default:
-                return JSON.stringify({ error: `Unknown tool: ${tool.name}` });
-        }
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        printError(msg);
-        return JSON.stringify({ error: msg });
-    }
-}
-/** Execute tool with hooks (C3) */
-async function executeToolWithHooks(tool, cwd, config, hooks) {
-    // C3: Run PreToolUse hooks
-    const shouldProceed = runHooks('PreToolUse', hooks, tool.name, tool.input, cwd);
-    if (!shouldProceed) {
-        return JSON.stringify({ error: 'Skipped by PreToolUse hook' });
-    }
-    const result = await executeTool(tool, cwd, config);
-    // C3: Run PostToolUse hooks
-    runHooks('PostToolUse', hooks, tool.name, tool.input, cwd);
-    return result;
-}
-/** Execute tool from streamed content block */
-async function executeStreamedTool(block, cwd, config, hooks) {
-    const toolBlock = {
-        type: 'tool_use',
-        id: block.id ?? '',
-        name: block.name ?? '',
-        input: block.input ?? {},
-    };
-    return executeToolWithHooks(toolBlock, cwd, config, hooks);
-}
-/** C1: Execute tools with parallel optimization for read-only tools */
-async function executeToolsParallel(blocks, cwd, config, hooks) {
-    const results = [];
-    // Group consecutive parallel-safe tools
-    let i = 0;
-    while (i < blocks.length) {
-        const block = blocks[i];
-        if (PARALLEL_SAFE_TOOLS.has(block.name ?? '')) {
-            // Collect consecutive parallel-safe tools
-            const parallelBatch = [block];
-            let j = i + 1;
-            while (j < blocks.length && PARALLEL_SAFE_TOOLS.has(blocks[j].name ?? '')) {
-                parallelBatch.push(blocks[j]);
-                j++;
-            }
-            if (parallelBatch.length > 1) {
-                // Execute in parallel
-                const batchResults = await Promise.all(parallelBatch.map(b => executeStreamedTool(b, cwd, config, hooks)));
-                for (let k = 0; k < parallelBatch.length; k++) {
-                    results.push({
-                        type: 'tool_result',
-                        tool_use_id: parallelBatch[k].id ?? '',
-                        content: batchResults[k],
-                    });
-                }
-            }
-            else {
-                // Single tool, execute normally
-                const result = await executeStreamedTool(block, cwd, config, hooks);
-                results.push({
-                    type: 'tool_result',
-                    tool_use_id: block.id ?? '',
-                    content: result,
-                });
-            }
-            i = j;
-        }
-        else {
-            // Sequential tool (write, execute, edit)
-            const result = await executeStreamedTool(block, cwd, config, hooks);
-            results.push({
-                type: 'tool_result',
-                tool_use_id: block.id ?? '',
-                content: result,
-            });
-            i++;
-        }
-    }
-    return results;
-}
-/** A6: Read multi-line input (between """ or ''') */
-async function readMultiLineInput(rl, delimiter) {
-    const lines = [];
-    return new Promise(resolve => {
-        const handler = (line) => {
-            if (line.trim() === delimiter) {
-                rl.removeListener('line', handler);
-                resolve(lines.join('\n'));
-                return;
-            }
-            lines.push(line);
-            process.stdout.write(`${GRAY}...${RESET} `);
-        };
-        process.stdout.write(`${GRAY}...${RESET} `);
-        rl.on('line', handler);
-    });
-}
-/** Main agent chat loop with tool use */
-export async function agentChat(config) {
-    const apiUrl = config.apiUrl ?? 'http://localhost:3001';
-    let model = config.model ?? 'auto';
-    let cwd = process.cwd();
-    const homeDir = os.homedir();
-    // Auto-detect project or warn if in home directory
-    if (cwd === homeDir) {
-        console.log(`${YELLOW}  Warning: Running from home directory.${RESET}`);
-        console.log(`${GRAY}  Tip: Run from a project folder, or specify: oroute /path/to/project${RESET}`);
-        console.log();
-        const projectRoot = findProjectRoot(cwd);
-        if (projectRoot && projectRoot !== homeDir) {
-            console.log(`${GREEN}  Found project: ${projectRoot}${RESET}`);
-            process.chdir(projectRoot);
-            cwd = projectRoot;
-        }
-    }
-    const project = detectProject(cwd);
-    // A2: Load project context
-    const projectContext = loadProjectContext(cwd);
-    const contextStr = buildContextString(projectContext);
-    // C5: Load memory context
-    const memoryStr = buildMemoryContext(cwd);
-    // C3: Load hooks
-    const hooks = loadHooks(cwd);
-    // B6: Initialize session stats
-    let sessionStats = createSessionStats();
-    console.log(`${GREEN}${BOLD}  O'Route Agent${RESET} v0.2.0`);
-    console.log(`${GRAY}  model: ${model} (auto-routed) · agent mode${RESET}`);
-    if (project.isProject) {
-        console.log(`${GRAY}  project: ${project.name}${RESET}`);
-    }
-    // B1: Show git info
-    if (projectContext.gitBranch) {
-        console.log(`${GRAY}  git: ${projectContext.gitBranch}${projectContext.gitStatus ? ` (${projectContext.gitStatus})` : ''}${RESET}`);
-    }
-    console.log(`${GRAY}  cwd: ${cwd}${RESET}`);
-    if (config.skipConfirmations) {
-        console.log(`${YELLOW}  --yes mode: confirmations skipped${RESET}`);
-    }
-    if (config.planMode) {
-        console.log(`${YELLOW}  --plan mode: tools shown but not executed${RESET}`);
-    }
-    console.log(`${GRAY}  Type /help for commands, """ for multi-line${RESET}`);
-    console.log();
-    let messages = [];
-    const systemPrompt = buildSystemPrompt(cwd, contextStr, memoryStr);
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const promptInput = () => new Promise(resolve => rl.question(`${GREEN}>${RESET} `, answer => resolve(answer.trim())));
-    while (true) {
-        const rawInput = await promptInput();
-        // A6: Multi-line input
-        let input = rawInput;
-        if (rawInput === '"""' || rawInput === "'''") {
-            input = await readMultiLineInput(rl, rawInput);
-            if (!input)
-                continue;
-        }
-        if (!input)
-            continue;
-        // A5: Slash commands
-        const cmdResult = handleSlashCommand(input, {
-            messages,
-            stats: sessionStats,
-            model,
-            cwd,
-            apiUrl,
-            apiKey: config.apiKey ?? '',
-            setModel: (m) => { model = m; },
-            setCwd: (d) => { cwd = d; },
-            setMessages: (m) => { messages = m; },
-            setStats: (s) => { sessionStats = s; },
-        });
-        if (cmdResult === 'exit') {
-            rl.close();
-            // B7: Auto-save session on exit
-            autoSaveSession(messages, sessionStats, cwd);
-            printExitSummary(sessionStats);
-            break;
-        }
-        if (cmdResult === 'handled')
-            continue;
-        // exit/quit without slash
-        if (input === 'exit' || input === 'quit') {
-            rl.close();
-            autoSaveSession(messages, sessionStats, cwd);
-            printExitSummary(sessionStats);
-            break;
-        }
-        messages.push({ role: 'user', content: input });
-        // A4: Auto-compress history before API call
-        const estimated = estimateTokens(messages);
-        if (estimated > TOKEN_THRESHOLD) {
-            const compressed = compressHistory(messages);
-            if (compressed.compressed) {
-                messages = compressed.messages;
-                console.log(`${DIM}  (history compressed to ${messages.length} messages)${RESET}`);
-            }
-        }
-        // Agent loop: send -> process tool_use -> send results -> repeat
-        let continueLoop = true;
-        let retryCount = 0;
-        const maxRetries = 3;
-        while (continueLoop) {
-            const spinner = createSpinner('Thinking...');
-            try {
-                const res = await fetch(`${apiUrl}/v1/messages`, {
-                    method: 'POST',
-                    headers: {
-                        'Authorization': `Bearer ${config.apiKey}`,
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({
-                        model,
-                        max_tokens: 8192,
-                        system: systemPrompt,
-                        messages,
-                        tools: TOOL_DEFINITIONS,
-                        stream: true,
-                    }),
-                    signal: AbortSignal.timeout(120000),
-                });
-                spinner.stop();
-                if (!res.ok) {
-                    const errBody = await res.text().catch(() => '');
-                    // Rate limit — wait and retry
-                    if (res.status === 429 && retryCount < maxRetries) {
-                        retryCount++;
-                        const waitSec = retryCount * 3;
-                        console.log(`${YELLOW}  Rate limited. Retrying in ${waitSec}s... (${retryCount}/${maxRetries})${RESET}`);
-                        await new Promise(r => setTimeout(r, waitSec * 1000));
-                        continue;
-                    }
-                    // Parse error message
-                    let errMsg = `HTTP ${res.status}`;
-                    try {
-                        const errObj = JSON.parse(errBody);
-                        errMsg = typeof errObj.error === 'string'
-                            ? errObj.error
-                            : errObj.error?.message ?? errMsg;
-                    }
-                    catch { /* use default */ }
-                    printError(errMsg);
-                    messages.pop();
-                    continueLoop = false;
-                    continue;
-                }
-                retryCount = 0;
-                // A1: Check if response is SSE streaming or regular JSON
-                if (isSSEResponse(res)) {
-                    // Streaming response
-                    let firstText = true;
-                    const streamResult = await parseSSEStream(res, (text) => {
-                        if (firstText) {
-                            console.log(); // newline before first text
-                            firstText = false;
-                        }
-                        process.stdout.write(text);
-                    });
-                    // After streaming text is done
-                    if (!firstText) {
-                        console.log(); // newline after streaming text
-                    }
-                    // B6: Update stats
-                    sessionStats = updateStats(sessionStats, streamResult.usage, streamResult.routingMetadata?.provider);
-                    // Build content blocks for history
-                    const contentBlocksForHistory = [];
-                    const toolBlocks = [];
-                    for (const block of streamResult.contentBlocks) {
-                        if (block.type === 'text') {
-                            contentBlocksForHistory.push({ type: 'text', text: block.text ?? '' });
-                        }
-                        else if (block.type === 'tool_use') {
-                            contentBlocksForHistory.push({
-                                type: 'tool_use',
-                                id: block.id ?? '',
-                                name: block.name ?? '',
-                                input: block.input ?? {},
-                            });
-                            toolBlocks.push(block);
-                        }
-                    }
-                    // Add assistant message to history
-                    messages.push({ role: 'assistant', content: contentBlocksForHistory });
-                    // C1: Execute tools (parallel for read-only, sequential for writes)
-                    if (toolBlocks.length > 0) {
-                        const toolResults = await executeToolsParallel(toolBlocks, cwd, config, hooks);
-                        messages.push({ role: 'user', content: toolResults });
-                    }
-                    else {
-                        // Show metadata
-                        const meta = streamResult.routingMetadata;
-                        if (meta) {
-                            console.log(`${DIM}  - ${meta.provider} · L${meta.taskComplexity} · ${meta.totalLatencyMs.toFixed(0)}ms · ${streamResult.usage.input_tokens}+${streamResult.usage.output_tokens} tokens${RESET}`);
-                        }
-                        console.log();
-                        continueLoop = false;
-                    }
-                    if (streamResult.stopReason === 'end_turn' && toolBlocks.length === 0) {
-                        continueLoop = false;
-                    }
-                }
-                else {
-                    // Non-streaming fallback (regular JSON response)
-                    const data = (await res.json());
-                    // B6: Update stats
-                    sessionStats = updateStats(sessionStats, data.usage, data.routing_metadata?.provider);
-                    // Process response content blocks
-                    const toolResults = [];
-                    for (const block of data.content) {
-                        if (block.type === 'text') {
-                            const text = block.text;
-                            if (text) {
-                                console.log();
-                                // A3: Render markdown
-                                console.log(renderMarkdown(text));
-                            }
-                        }
-                        else if (block.type === 'tool_use') {
-                            const toolBlock = block;
-                            const result = await executeToolWithHooks(toolBlock, cwd, config, hooks);
-                            toolResults.push({
-                                type: 'tool_result',
-                                tool_use_id: toolBlock.id,
-                                content: result,
-                            });
-                        }
-                    }
-                    // Add assistant message to history
-                    messages.push({ role: 'assistant', content: data.content });
-                    // If there were tool uses, send results back
-                    if (toolResults.length > 0) {
-                        messages.push({ role: 'user', content: toolResults });
-                    }
-                    else {
-                        // No tool use, show metadata and stop
-                        const meta = data.routing_metadata;
-                        if (meta) {
-                            console.log();
-                            console.log(`${DIM}  - ${meta.provider} · L${meta.taskComplexity} · ${meta.totalLatencyMs.toFixed(0)}ms · ${data.usage.input_tokens}+${data.usage.output_tokens} tokens${RESET}`);
-                        }
-                        console.log();
-                        continueLoop = false;
-                    }
-                    // Check stop reason
-                    if (data.stop_reason === 'end_turn' && toolResults.length === 0) {
-                        continueLoop = false;
-                    }
-                }
-            }
-            catch (err) {
-                spinner.stop();
-                const msg = err instanceof Error ? err.message : 'unknown error';
-                printError(`Request failed: ${msg}`);
-                messages.pop();
-                continueLoop = false;
-            }
-        }
-    }
-}
-//# sourceMappingURL=agent.js.map