codebot-ai 1.2.2 → 1.3.0

package/README.md

@@ -1,50 +1,60 @@
 # CodeBot AI
 
-Local-first AI coding assistant. Zero runtime dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, DeepSeek, Groq, Mistral, and Grok.
+[![npm version](https://img.shields.io/npm/v/codebot-ai.svg)](https://www.npmjs.com/package/codebot-ai)
+[![license](https://img.shields.io/npm/l/codebot-ai.svg)](https://github.com/zanderone1980/codebot-ai/blob/main/LICENSE)
+[![node](https://img.shields.io/node/v/codebot-ai.svg)](https://nodejs.org)
+
+**Zero-dependency autonomous AI agent.** Works with any LLM — local or cloud. Code, browse the web, run commands, search, automate routines, and more.
+
+Built by [Ascendral Software Development & Innovation](https://github.com/AscendralSoftware).
 
 ## Quick Start
 
 ```bash
-# Install globally
 npm install -g codebot-ai
-
-# Run — setup wizard launches automatically on first use
 codebot
 ```
 
-Or run without installing:
+That's it. The setup wizard launches on first run — pick your model, paste an API key (or use a local LLM), and you're coding.
 
 ```bash
+# Or run without installing
 npx codebot-ai
 ```
 
-Or from source:
-
-```bash
-git clone https://github.com/AscendralSoftware/codebot-ai.git
-cd codebot-ai
-npm install && npm run build
-./bin/codebot
-```
+## What Can It Do?
 
-## Setup
+- **Write & edit code** — reads your codebase, makes targeted edits, runs tests
+- **Run shell commands** — system checks, builds, deploys, git operations
+- **Browse the web** — navigates Chrome, clicks, types, reads pages, takes screenshots
+- **Search the internet** — real-time web search for docs, APIs, current info
+- **Automate routines** — schedule recurring tasks with cron (daily posts, email checks, monitoring)
+- **Call APIs** — HTTP requests to any REST endpoint
+- **Persistent memory** — remembers preferences and context across sessions
+- **Self-recovering** — retries on network errors, recovers from API failures, never drops out
 
-On first run, CodeBot detects your environment and walks you through configuration:
+## Supported Models
 
-- Scans for local LLM servers (Ollama, LM Studio, vLLM)
-- Detects API keys from environment variables
-- Lets you pick a provider and model
-- Saves config to `~/.codebot/config.json`
+Pick any model during setup. CodeBot works with all of them:
 
-To reconfigure anytime: `codebot --setup`
+| Provider | Models |
+|----------|--------|
+| **Local (Ollama/LM Studio/vLLM)** | qwen2.5-coder, qwen3, deepseek-coder, llama3.x, mistral, phi-4, codellama, starcoder2, and any model your server runs |
+| **Anthropic** | claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5 |
+| **OpenAI** | gpt-4o, gpt-4.1, o1, o3, o4-mini |
+| **Google** | gemini-2.5-pro, gemini-2.5-flash, gemini-2.0-flash |
+| **DeepSeek** | deepseek-chat, deepseek-reasoner |
+| **Groq** | llama-3.3-70b, mixtral-8x7b |
+| **Mistral** | mistral-large, codestral |
+| **xAI** | grok-3, grok-3-mini |
 
-### Environment Variables
+For local models, just have Ollama/LM Studio/vLLM running — CodeBot auto-detects them.
 
-Set an API key for your preferred cloud provider:
+For cloud models, set an environment variable:
 
 ```bash
-export ANTHROPIC_API_KEY="sk-ant-..."    # Claude
 export OPENAI_API_KEY="sk-..."           # GPT
+export ANTHROPIC_API_KEY="sk-ant-..."    # Claude
 export GEMINI_API_KEY="..."              # Gemini
 export DEEPSEEK_API_KEY="sk-..."         # DeepSeek
 export GROQ_API_KEY="gsk_..."            # Groq
@@ -52,52 +62,23 @@ export MISTRAL_API_KEY="..."             # Mistral
 export XAI_API_KEY="xai-..."             # Grok
 ```
 
-For local models, just have Ollama/LM Studio/vLLM running — CodeBot auto-detects them.
+Or paste your key during setup — either way works.
 
 ## Usage
 
-### Interactive Mode
-
-```bash
-codebot
-```
-
-### Single Message
-
 ```bash
-codebot "fix the bug in app.ts"
-codebot --model claude-sonnet-4-6 "explain this codebase"
+codebot                                        # Interactive REPL
+codebot "fix the bug in app.ts"                # Single task
+codebot --autonomous "refactor auth and test"  # Full auto — no permission prompts
+codebot --continue                             # Resume last session
+echo "explain this error" | codebot            # Pipe mode
 ```
 
-### Pipe Mode
-
-```bash
-echo "write a function that sorts by date" | codebot
-cat error.log | codebot "what's causing this?"
-```
-
-### Autonomous Mode
-
-Skip all permission prompts — full auto:
-
-```bash
-codebot --autonomous "refactor the auth module and run tests"
-```
-
-### Session Resume
-
-CodeBot auto-saves every conversation. Resume anytime:
-
-```bash
-codebot --continue              # Resume last session
-codebot --resume <session-id>   # Resume specific session
-```
-
-## CLI Options
+### CLI Options
 
 ```
 --setup              Run the setup wizard
---model <name>       Model to use (default: qwen2.5-coder:32b)
+--model <name>       Model to use
 --provider <name>    Provider: openai, anthropic, gemini, deepseek, groq, mistral, xai
 --base-url <url>     LLM API base URL
 --api-key <key>      API key (or use env vars)
@@ -107,25 +88,26 @@ codebot --resume <session-id>   # Resume specific session
 --max-iterations <n> Max agent loop iterations (default: 50)
 ```
 
-## Interactive Commands
+### Interactive Commands
 
 ```
-/help      Show commands
-/model     Show or change model
-/models    List all supported models
-/sessions  List saved sessions
-/auto      Toggle autonomous mode
-/undo      Undo last file edit (/undo [path])
-/usage     Show token usage for this session
-/clear     Clear conversation
-/compact   Force context compaction
-/config    Show configuration
-/quit      Exit
+/help       Show commands
+/model      Show or change model
+/models     List all supported models
+/sessions   List saved sessions
+/routines   List scheduled routines
+/auto       Toggle autonomous mode
+/undo       Undo last file edit (/undo [path])
+/usage      Show token usage for this session
+/clear      Clear conversation
+/compact    Force context compaction
+/config     Show configuration
+/quit       Exit
 ```
 
 ## Tools
 
-CodeBot has 11 built-in tools:
+CodeBot has 13 built-in tools:
 
 | Tool | Description | Permission |
 |------|-------------|-----------|
@@ -139,7 +121,9 @@ CodeBot has 11 built-in tools:
 | `think` | Internal reasoning scratchpad | auto |
 | `memory` | Persistent memory across sessions | auto |
 | `web_fetch` | HTTP requests and API calls | prompt |
+| `web_search` | Internet search with result summaries | prompt |
 | `browser` | Chrome automation via CDP | prompt |
+| `routine` | Schedule recurring tasks with cron | prompt |
 
 ### Permission Levels
 
@@ -147,7 +131,7 @@ CodeBot has 11 built-in tools:
 - **prompt** — Asks for approval (skipped in `--autonomous` mode)
 - **always-ask** — Always asks, even in autonomous mode
 
-### Browser Tool
+### Browser Automation
 
 Controls Chrome via the Chrome DevTools Protocol. Actions:
 
@@ -155,21 +139,34 @@ Controls Chrome via the Chrome DevTools Protocol. Actions:
 - `content` — Read page text
 - `screenshot` — Capture the page
 - `click` — Click an element by CSS selector
+- `find_by_text` — Find and interact with elements by visible text
 - `type` — Type into an input field
+- `scroll`, `press_key`, `hover` — Page interaction
 - `evaluate` — Run JavaScript on the page
 - `tabs` — List open tabs
 - `close` — Close browser connection
 
 Chrome is auto-launched with `--remote-debugging-port` if not already running.
 
+### Routines & Scheduling
+
+Schedule recurring tasks with cron expressions:
+
+```
+> Set up a routine to check my server health every hour
+> Create a daily routine at 9am to summarize my GitHub notifications
+```
+
+CodeBot creates the cron schedule, and the built-in scheduler runs tasks automatically while the agent is active. Manage with `/routines`.
+
 ### Memory
 
-CodeBot has persistent memory that survives across sessions:
+Persistent memory that survives across sessions:
 
 - **Global memory** (`~/.codebot/memory/`) — preferences, patterns
 - **Project memory** (`.codebot/memory/`) — project-specific context
-- Memory is automatically injected into the system prompt
-- The agent can read/write its own memory using the `memory` tool
+- Automatically injected into the system prompt
+- The agent reads/writes its own memory to learn your style
 
 ### Plugins
 
@@ -205,33 +202,54 @@ Connect external tool servers via [Model Context Protocol](https://modelcontextp
 
 MCP tools appear automatically with the `mcp_<server>_<tool>` prefix.
 
-## Supported Models
+## Stability
+
+CodeBot v1.3.0 is hardened for continuous operation:
+
+- **Automatic retry** — network errors, rate limits (429), and server errors (5xx) retry with exponential backoff
+- **Stream recovery** — if the LLM connection drops mid-response, the agent loop retries on the next iteration
+- **Context compaction** — when the conversation exceeds the model's context window, messages are intelligently summarized
+- **Process resilience** — unhandled exceptions and rejections are caught, logged, and the REPL keeps running
+- **Routine timeouts** — scheduled tasks are capped at 5 minutes to prevent the scheduler from hanging
+- **99 tests** — comprehensive suite covering error recovery, retry logic, tool execution, and edge cases
+
+## Programmatic API
+
+CodeBot can be used as a library:
 
-### Local (Ollama / LM Studio / vLLM)
+```typescript
+import { Agent, OpenAIProvider, AnthropicProvider } from 'codebot-ai';
 
-qwen2.5-coder (3b/7b/14b/32b), qwen3, deepseek-coder, codellama, llama3.x, mistral, mixtral, phi-3/4, starcoder2, granite-code, gemma2, command-r
+const provider = new AnthropicProvider({
+  baseUrl: 'https://api.anthropic.com',
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: 'claude-sonnet-4-6',
+});
 
-### Cloud
+const agent = new Agent({
+  provider,
+  model: 'claude-sonnet-4-6',
+  autoApprove: true,
+});
 
-- **Anthropic**: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5
-- **OpenAI**: gpt-4o, gpt-4.1, o1, o3, o4-mini
-- **Google**: gemini-2.5-pro, gemini-2.5-flash, gemini-2.0-flash
-- **DeepSeek**: deepseek-chat, deepseek-reasoner
-- **Groq**: llama-3.3-70b, mixtral-8x7b (fast inference)
-- **Mistral**: mistral-large, codestral
-- **xAI**: grok-3, grok-3-mini
+for await (const event of agent.run('list all TypeScript files')) {
+  if (event.type === 'text') process.stdout.write(event.text || '');
+}
+```
 
 ## Architecture
 
 ```
 src/
-  agent.ts              Agent loop with streaming, tool execution, permissions
+  agent.ts              Agent loop — streaming, tool execution, error recovery
   cli.ts                CLI interface, REPL, slash commands
   types.ts              TypeScript interfaces
   parser.ts             XML/JSON tool call parser (for models without native tool support)
   history.ts            Session persistence (JSONL)
   memory.ts             Persistent memory system
-  setup.ts              Interactive setup wizard
+  setup.ts              Interactive setup wizard (model-first UX)
+  scheduler.ts          Cron-based routine scheduler
+  retry.ts              Exponential backoff with jitter
   context/
     manager.ts          Context window management, LLM-powered compaction
     repo-map.ts         Project structure scanner
@@ -247,31 +265,8 @@ src/
     read.ts, write.ts, edit.ts, execute.ts
     batch-edit.ts       Multi-file atomic editing
     glob.ts, grep.ts, think.ts
-    memory.ts, web-fetch.ts, browser.ts
-```
-
-## Programmatic API
-
-CodeBot can be used as a library:
-
-```typescript
-import { Agent, OpenAIProvider, AnthropicProvider } from 'codebot-ai';
-
-const provider = new AnthropicProvider({
-  baseUrl: 'https://api.anthropic.com',
-  apiKey: process.env.ANTHROPIC_API_KEY,
-  model: 'claude-sonnet-4-6',
-});
-
-const agent = new Agent({
-  provider,
-  model: 'claude-sonnet-4-6',
-  autoApprove: true,
-});
-
-for await (const event of agent.run('list all TypeScript files')) {
-  if (event.type === 'text') process.stdout.write(event.text || '');
-}
+    memory.ts, web-fetch.ts, web-search.ts
+    browser.ts, routine.ts
 ```
 
 ## Configuration
@@ -282,6 +277,15 @@ Config is loaded in this order (later values win):
 2. Environment variables (`CODEBOT_MODEL`, `CODEBOT_PROVIDER`, etc.)
 3. CLI flags (`--model`, `--provider`, etc.)
 
+## From Source
+
+```bash
+git clone https://github.com/zanderone1980/codebot-ai.git
+cd codebot-ai
+npm install && npm run build
+./bin/codebot
+```
+
 ## License
 
-MIT - Ascendral Software Development & Innovation
+MIT - [Ascendral Software Development & Innovation](https://github.com/AscendralSoftware)

package/dist/agent.js

@@ -88,9 +88,15 @@ class Agent {
         this.messages.push(userMsg);
         this.onMessage?.(userMsg);
         if (!this.context.fitsInBudget(this.messages)) {
-            const result = await this.context.compactWithSummary(this.messages);
-            this.messages = result.messages;
-            yield { type: 'compaction', text: result.summary || 'Context compacted to fit budget.' };
+            try {
+                const result = await this.context.compactWithSummary(this.messages);
+                this.messages = result.messages;
+                yield { type: 'compaction', text: result.summary || 'Context compacted to fit budget.' };
+            }
+            catch {
+                this.messages = this.context.compact(this.messages, true);
+                yield { type: 'compaction', text: 'Context compacted (summary unavailable).' };
+            }
         }
         for (let i = 0; i < this.maxIterations; i++) {
             // Validate message integrity: ensure every tool_call has a matching tool response
@@ -100,29 +106,41 @@ class Agent {
             const toolSchemas = supportsTools ? this.tools.getSchemas() : undefined;
             let fullText = '';
             let toolCalls = [];
-            // Stream LLM response
-            for await (const event of this.provider.chat(this.messages, toolSchemas)) {
-                switch (event.type) {
-                    case 'text':
-                        fullText += event.text || '';
-                        yield { type: 'text', text: event.text };
-                        break;
-                    case 'thinking':
-                        yield { type: 'thinking', text: event.text };
-                        break;
-                    case 'tool_call_end':
-                        if (event.toolCall) {
-                            toolCalls.push(event.toolCall);
-                        }
-                        break;
-                    case 'usage':
-                        yield { type: 'usage', usage: event.usage };
-                        break;
-                    case 'error':
-                        yield { type: 'error', error: event.error };
-                        return;
+            let streamError = null;
+            // Stream LLM response — wrapped in try-catch for resilience
+            try {
+                for await (const event of this.provider.chat(this.messages, toolSchemas)) {
+                    switch (event.type) {
+                        case 'text':
+                            fullText += event.text || '';
+                            yield { type: 'text', text: event.text };
+                            break;
+                        case 'thinking':
+                            yield { type: 'thinking', text: event.text };
+                            break;
+                        case 'tool_call_end':
+                            if (event.toolCall) {
+                                toolCalls.push(event.toolCall);
+                            }
+                            break;
+                        case 'usage':
+                            yield { type: 'usage', usage: event.usage };
+                            break;
+                        case 'error':
+                            streamError = event.error || 'Unknown provider error';
+                            break;
+                    }
                 }
             }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                streamError = `Stream error: ${msg}`;
+            }
+            // On error: yield it to the UI but DON'T return — continue to next iteration
+            if (streamError) {
+                yield { type: 'error', error: streamError };
+                continue;
+            }
             // If no native tool calls, try parsing from text
             if (toolCalls.length === 0 && fullText) {
                 toolCalls = (0, parser_1.parseToolCalls)(fullText);
@@ -195,9 +213,15 @@ class Agent {
             }
             // Compact after tool results if needed
             if (!this.context.fitsInBudget(this.messages)) {
-                const result = await this.context.compactWithSummary(this.messages);
-                this.messages = result.messages;
-                yield { type: 'compaction', text: result.summary || 'Context compacted.' };
+                try {
+                    const result = await this.context.compactWithSummary(this.messages);
+                    this.messages = result.messages;
+                    yield { type: 'compaction', text: result.summary || 'Context compacted.' };
+                }
+                catch {
+                    this.messages = this.context.compact(this.messages, true);
+                    yield { type: 'compaction', text: 'Context compacted (summary unavailable).' };
+                }
             }
         }
         yield { type: 'error', error: `Max iterations (${this.maxIterations}) reached.` };

package/dist/cli.js

@@ -44,7 +44,7 @@ const setup_1 = require("./setup");
 const banner_1 = require("./banner");
 const tools_1 = require("./tools");
 const scheduler_1 = require("./scheduler");
-const VERSION = '1.2.2';
+const VERSION = '1.3.0';
 // Session-wide token tracking
 let sessionTokens = { input: 0, output: 0, total: 0 };
 const C = {
@@ -61,6 +61,17 @@ function c(text, style) {
     return `${C[style]}${text}${C.reset}`;
 }
 async function main() {
+    // Process-level safety nets: prevent silent crashes
+    process.on('unhandledRejection', (reason) => {
+        const msg = reason instanceof Error ? reason.message : String(reason);
+        console.error(`\x1b[31m\nUnhandled error: ${msg}\x1b[0m`);
+    });
+    process.on('uncaughtException', (err) => {
+        console.error(`\x1b[31m\nUncaught exception: ${err.message}\x1b[0m`);
+        if (err.message.includes('out of memory') || err.message.includes('ENOMEM')) {
+            process.exit(1);
+        }
+    });
     const args = parseArgs(process.argv.slice(2));
     if (args.help) {
         showHelp();
@@ -363,7 +374,12 @@ function handleSlashCommand(input, agent, config) {
         case '/routines': {
             const { RoutineTool } = require('./tools/routine');
             const rt = new RoutineTool();
-            rt.execute({ action: 'list' }).then((out) => console.log('\n' + out));
+            rt.execute({ action: 'list' })
+                .then((out) => console.log('\n' + out))
+                .catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(c(`Error listing routines: ${msg}`, 'red'));
+            });
             break;
         }
         case '/config':

package/dist/providers/anthropic.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicProvider = void 0;
+const retry_1 = require("../retry");
 class AnthropicProvider {
     name;
     config;
@@ -27,26 +28,45 @@ class AnthropicProvider {
             }));
         }
         const baseUrl = this.config.baseUrl.replace(/\/+$/, '');
+        const MAX_RETRIES = 3;
         let response;
-        try {
-            response = await fetch(`${baseUrl}/v1/messages`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': this.config.apiKey || '',
-                    'anthropic-version': '2023-06-01',
-                },
-                body: JSON.stringify(body),
-            });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            yield { type: 'error', error: `Connection failed: ${msg}` };
-            return;
+        let lastError = '';
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                response = await fetch(`${baseUrl}/v1/messages`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': this.config.apiKey || '',
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(60_000),
+                });
+                if (response.ok || !(0, retry_1.isRetryable)(null, response.status)) {
+                    break;
+                }
+                lastError = `Anthropic error ${response.status}`;
+                if (attempt < MAX_RETRIES) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt, response.headers.get('retry-after'));
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+                if (attempt < MAX_RETRIES && (0, retry_1.isRetryable)(err)) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt);
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+                yield { type: 'error', error: `Connection failed after ${attempt + 1} attempts: ${lastError}` };
+                return;
+            }
         }
-        if (!response.ok) {
-            const text = await response.text();
-            yield { type: 'error', error: `Anthropic error ${response.status}: ${text}` };
+        if (!response || !response.ok) {
+            const text = response ? await response.text().catch(() => '') : '';
+            yield { type: 'error', error: `Anthropic error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
             return;
         }
         if (!response.body) {

package/dist/providers/openai.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIProvider = void 0;
 const registry_1 = require("./registry");
+const retry_1 = require("../retry");
 class OpenAIProvider {
     name;
     config;
@@ -33,22 +34,42 @@ class OpenAIProvider {
         if (this.config.apiKey) {
             headers['Authorization'] = `Bearer ${this.config.apiKey}`;
         }
+        const MAX_RETRIES = 3;
         let response;
-        try {
-            response = await fetch(`${this.config.baseUrl}/v1/chat/completions`, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(body),
-            });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            yield { type: 'error', error: `Connection failed: ${msg}. Is your LLM server running?` };
-            return;
+        let lastError = '';
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                response = await fetch(`${this.config.baseUrl}/v1/chat/completions`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(60_000),
+                });
+                if (response.ok || !(0, retry_1.isRetryable)(null, response.status)) {
+                    break;
+                }
+                // Retryable HTTP status (429, 5xx)
+                lastError = `LLM error ${response.status}`;
+                if (attempt < MAX_RETRIES) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt, response.headers.get('retry-after'));
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+                if (attempt < MAX_RETRIES && (0, retry_1.isRetryable)(err)) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt);
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+                yield { type: 'error', error: `Connection failed after ${attempt + 1} attempts: ${lastError}. Is your LLM server running?` };
+                return;
+            }
         }
-        if (!response.ok) {
-            const text = await response.text();
-            yield { type: 'error', error: `LLM error ${response.status}: ${text}` };
+        if (!response || !response.ok) {
+            const text = response ? await response.text().catch(() => '') : '';
+            yield { type: 'error', error: `LLM error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
             return;
         }
         if (!response.body) {

package/dist/retry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Retry utilities for resilient network operations.
+ * Exponential backoff with jitter, Retry-After header support.
+ * Zero dependencies.
+ */
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    retryableStatuses?: number[];
+}
+declare const DEFAULTS: Required<RetryOptions>;
+/** Returns true if the error/status is retryable (network error or retryable HTTP status). */
+export declare function isRetryable(error: unknown, status?: number, opts?: RetryOptions): boolean;
+/**
+ * Calculate delay with exponential backoff + jitter.
+ * For 429 responses, respects Retry-After header.
+ */
+export declare function getRetryDelay(attempt: number, retryAfterHeader?: string | null, opts?: RetryOptions): number;
+export declare function sleep(ms: number): Promise<void>;
+export { DEFAULTS as RETRY_DEFAULTS };
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Retry utilities for resilient network operations.
+ * Exponential backoff with jitter, Retry-After header support.
+ * Zero dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETRY_DEFAULTS = void 0;
+exports.isRetryable = isRetryable;
+exports.getRetryDelay = getRetryDelay;
+exports.sleep = sleep;
+const DEFAULTS = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    retryableStatuses: [429, 500, 502, 503, 504],
+};
+exports.RETRY_DEFAULTS = DEFAULTS;
+/** Returns true if the error/status is retryable (network error or retryable HTTP status). */
+function isRetryable(error, status, opts) {
+    const statuses = opts?.retryableStatuses ?? DEFAULTS.retryableStatuses;
+    if (status && statuses.includes(status))
+        return true;
+    if (error instanceof TypeError)
+        return true; // fetch network errors
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        if (msg.includes('fetch failed') || msg.includes('econnreset') ||
+            msg.includes('econnrefused') || msg.includes('etimedout') ||
+            msg.includes('socket hang up') || msg.includes('network') ||
+            msg.includes('abort')) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Calculate delay with exponential backoff + jitter.
+ * For 429 responses, respects Retry-After header.
+ */
+function getRetryDelay(attempt, retryAfterHeader, opts) {
+    const base = opts?.baseDelayMs ?? DEFAULTS.baseDelayMs;
+    const max = opts?.maxDelayMs ?? DEFAULTS.maxDelayMs;
+    // Respect Retry-After header (in seconds)
+    if (retryAfterHeader) {
+        const seconds = parseInt(retryAfterHeader, 10);
+        if (!isNaN(seconds) && seconds > 0) {
+            return Math.min(seconds * 1000, max);
+        }
+    }
+    // Exponential backoff with jitter: base * 2^attempt * (0.5..1.5)
+    const exponential = base * Math.pow(2, attempt);
+    const jitter = 0.5 + Math.random();
+    return Math.min(exponential * jitter, max);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=retry.js.map

package/dist/scheduler.d.ts

@@ -12,6 +12,8 @@ export declare class Scheduler {
     /** Check if any routines need to run right now */
     private tick;
     private executeRoutine;
+    /** Run the agent loop for a routine — separated so it can be wrapped in Promise.race */
+    private runRoutineAgent;
     private loadRoutines;
     private saveRoutines;
 }

package/dist/scheduler.js

@@ -90,25 +90,14 @@ class Scheduler {
     }
     async executeRoutine(routine, allRoutines) {
         this.running = true;
+        const ROUTINE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes max per routine
         try {
             this.onOutput?.(`\n⏰ Running routine: ${routine.name}\n   Task: ${routine.prompt}\n`);
-            // Run the agent with the routine's prompt
-            for await (const event of this.agent.run(routine.prompt)) {
-                switch (event.type) {
-                    case 'text':
-                        this.onOutput?.(event.text || '');
-                        break;
-                    case 'tool_call':
-                        this.onOutput?.(`\n⚡ ${event.toolCall?.name}(${Object.entries(event.toolCall?.args || {}).map(([k, v]) => `${k}: ${typeof v === 'string' ? v.substring(0, 40) : v}`).join(', ')})\n`);
-                        break;
-                    case 'tool_result':
-                        this.onOutput?.(`  ✓ ${event.toolResult?.result?.substring(0, 100) || ''}\n`);
-                        break;
-                    case 'error':
-                        this.onOutput?.(`  ✗ Error: ${event.error}\n`);
-                        break;
-                }
-            }
+            // Race against a timeout so a hanging routine doesn't block the scheduler forever
+            await Promise.race([
+                this.runRoutineAgent(routine),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Routine timed out after ${ROUTINE_TIMEOUT_MS / 1000}s`)), ROUTINE_TIMEOUT_MS)),
+            ]);
             // Update last run time
             routine.lastRun = new Date().toISOString();
             this.saveRoutines(allRoutines);
@@ -122,6 +111,25 @@ class Scheduler {
             this.running = false;
         }
     }
+    /** Run the agent loop for a routine — separated so it can be wrapped in Promise.race */
+    async runRoutineAgent(routine) {
+        for await (const event of this.agent.run(routine.prompt)) {
+            switch (event.type) {
+                case 'text':
+                    this.onOutput?.(event.text || '');
+                    break;
+                case 'tool_call':
+                    this.onOutput?.(`\n⚡ ${event.toolCall?.name}(${Object.entries(event.toolCall?.args || {}).map(([k, v]) => `${k}: ${typeof v === 'string' ? v.substring(0, 40) : v}`).join(', ')})\n`);
+                    break;
+                case 'tool_result':
+                    this.onOutput?.(`  ✓ ${event.toolResult?.result?.substring(0, 100) || ''}\n`);
+                    break;
+                case 'error':
+                    this.onOutput?.(`  ✗ Error: ${event.error}\n`);
+                    break;
+            }
+        }
+    }
     loadRoutines() {
         try {
             if (fs.existsSync(ROUTINES_FILE)) {

package/dist/setup.d.ts

@@ -12,6 +12,6 @@ export declare function loadConfig(): SavedConfig;
 export declare function saveConfig(config: SavedConfig): void;
 /** Check if this is the first run (no config, no env keys) */
 export declare function isFirstRun(): boolean;
-/** Interactive setup wizard */
+/** Interactive setup wizard — model-first flow */
 export declare function runSetup(): Promise<SavedConfig>;
 //# sourceMappingURL=setup.d.ts.map

package/dist/setup.js

@@ -60,15 +60,12 @@ function loadConfig() {
 function saveConfig(config) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
     const safe = { ...config };
-    // Persist API key if user entered it during setup (convenience over env vars)
-    // The key is stored in the user's home directory with default permissions
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(safe, null, 2) + '\n');
 }
 /** Check if this is the first run (no config, no env keys) */
 function isFirstRun() {
     if (fs.existsSync(CONFIG_FILE))
         return false;
-    // Check if any provider API keys are set
     const envKeys = [
         'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY',
         'DEEPSEEK_API_KEY', 'GROQ_API_KEY', 'MISTRAL_API_KEY',
@@ -105,24 +102,7 @@ async function detectLocalServers() {
     }
     return servers;
 }
-/** Detect which cloud API keys are available */
-function detectApiKeys() {
-    return Object.entries(registry_1.PROVIDER_DEFAULTS).map(([provider, defaults]) => ({
-        provider,
-        envVar: defaults.envKey,
-        set: !!process.env[defaults.envKey],
-    }));
-}
-/** Cloud provider display info */
-const CLOUD_PROVIDERS = [
-    { provider: 'openai', name: 'OpenAI', defaultModel: 'gpt-4o', description: 'GPT-4o, GPT-4.1, o3/o4' },
-    { provider: 'anthropic', name: 'Anthropic', defaultModel: 'claude-sonnet-4-6', description: 'Claude Opus/Sonnet/Haiku' },
-    { provider: 'gemini', name: 'Google Gemini', defaultModel: 'gemini-2.5-flash', description: 'Gemini 2.5 Pro/Flash' },
-    { provider: 'deepseek', name: 'DeepSeek', defaultModel: 'deepseek-chat', description: 'DeepSeek Chat/Reasoner' },
-    { provider: 'groq', name: 'Groq', defaultModel: 'llama-3.3-70b-versatile', description: 'Fast Llama/Mixtral inference' },
-    { provider: 'mistral', name: 'Mistral', defaultModel: 'mistral-large-latest', description: 'Mistral Large, Codestral' },
-    { provider: 'xai', name: 'xAI', defaultModel: 'grok-3', description: 'Grok-3' },
-];
+// ── ANSI helpers ─────────────────────────────────────────────────────────────
 const C = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
@@ -140,131 +120,253 @@ function ask(rl, question) {
         rl.question(question, answer => resolve(answer.trim()));
     });
 }
-/** Interactive setup wizard */
+const PROVIDER_DISPLAY = {
+    anthropic: 'Anthropic',
+    openai: 'OpenAI',
+    gemini: 'Google',
+    deepseek: 'DeepSeek',
+    groq: 'Groq',
+    mistral: 'Mistral',
+    xai: 'xAI',
+};
+/** Hand-picked cloud models for the setup menu — best 2-3 from each provider */
+const CURATED_CLOUD_MODELS = [
+    // Frontier (most capable)
+    { id: 'claude-opus-4-6', displayName: 'Claude Opus 4', provider: 'anthropic', category: 'frontier', contextK: '200K' },
+    { id: 'gpt-4.1', displayName: 'GPT-4.1', provider: 'openai', category: 'frontier', contextK: '1M' },
+    { id: 'gemini-2.5-pro', displayName: 'Gemini 2.5 Pro', provider: 'gemini', category: 'frontier', contextK: '1M' },
+    { id: 'o3', displayName: 'o3', provider: 'openai', category: 'frontier', contextK: '200K' },
+    { id: 'grok-3', displayName: 'Grok-3', provider: 'xai', category: 'frontier', contextK: '131K' },
+    // Fast & efficient
+    { id: 'claude-sonnet-4-6', displayName: 'Claude Sonnet 4', provider: 'anthropic', category: 'fast', contextK: '200K' },
+    { id: 'gpt-4o', displayName: 'GPT-4o', provider: 'openai', category: 'fast', contextK: '128K' },
+    { id: 'gemini-2.5-flash', displayName: 'Gemini 2.5 Flash', provider: 'gemini', category: 'fast', contextK: '1M' },
+    { id: 'deepseek-chat', displayName: 'DeepSeek Chat', provider: 'deepseek', category: 'fast', contextK: '65K' },
+    { id: 'mistral-large-latest', displayName: 'Mistral Large', provider: 'mistral', category: 'fast', contextK: '131K' },
+    { id: 'llama-3.3-70b-versatile', displayName: 'Llama 3.3 70B', provider: 'groq', category: 'fast', contextK: '131K' },
+    { id: 'claude-haiku-4-5-20251001', displayName: 'Claude Haiku 4.5', provider: 'anthropic', category: 'fast', contextK: '200K' },
+    // Reasoning
+    { id: 'o1', displayName: 'o1', provider: 'openai', category: 'reasoning', contextK: '200K' },
+    { id: 'o4-mini', displayName: 'o4-mini', provider: 'openai', category: 'reasoning', contextK: '200K' },
+    { id: 'deepseek-reasoner', displayName: 'DeepSeek Reasoner', provider: 'deepseek', category: 'reasoning', contextK: '65K' },
+];
+/** Format context window for display: 200000 → "200K", 1048576 → "1M" */
+function formatCtx(tokens) {
+    if (tokens >= 1000000)
+        return `${Math.round(tokens / 1048576)}M`;
+    return `${Math.round(tokens / 1024)}K`;
+}
+/** Build the unified model list: local models first, then curated cloud models */
+function buildModelList(localServers, apiKeyStatus) {
+    const entries = [];
+    // Local models (cap at 8, prioritize well-known models)
+    const localPriority = ['qwen', 'deepseek', 'llama', 'phi', 'mistral', 'codellama'];
+    for (const server of localServers) {
+        const sorted = [...server.models].sort((a, b) => {
+            const ai = localPriority.findIndex(p => a.toLowerCase().includes(p));
+            const bi = localPriority.findIndex(p => b.toLowerCase().includes(p));
+            return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+        });
+        for (const model of sorted.slice(0, 8)) {
+            const info = (0, registry_1.getModelInfo)(model);
+            entries.push({
+                id: model,
+                displayName: model,
+                provider: 'local',
+                category: 'local',
+                contextK: formatCtx(info.contextWindow),
+                baseUrl: server.url,
+                needsKey: false,
+                serverName: server.name,
+            });
+        }
+    }
+    // Cloud models from curated list
+    for (const model of CURATED_CLOUD_MODELS) {
+        const defaults = registry_1.PROVIDER_DEFAULTS[model.provider];
+        entries.push({
+            ...model,
+            baseUrl: defaults?.baseUrl || '',
+            needsKey: !apiKeyStatus.get(model.provider),
+        });
+    }
+    return entries;
+}
+function renderCategoryHeader(category) {
+    const headers = {
+        local: 'LOCAL (free, private, runs on your machine)',
+        frontier: 'CLOUD \u2014 FRONTIER (most capable)',
+        fast: 'CLOUD \u2014 FAST & EFFICIENT',
+        reasoning: 'CLOUD \u2014 REASONING',
+    };
+    const title = headers[category] || category.toUpperCase();
+    console.log(`\n  ${fmt(title, 'bold')}`);
+    console.log(`  ${fmt('\u2500'.repeat(48), 'dim')}`);
+}
+function renderModelRow(index, entry) {
+    const num = fmt(String(index).padStart(3), 'cyan');
+    const name = entry.displayName.padEnd(26);
+    const prov = (entry.serverName || PROVIDER_DISPLAY[entry.provider] || entry.provider).padEnd(11);
+    const ctx = fmt((entry.contextK + ' ctx').padStart(9), 'dim');
+    let keyStatus = '';
+    if (entry.provider !== 'local') {
+        keyStatus = entry.needsKey
+            ? fmt('  needs key', 'yellow')
+            : fmt('  \u2713 key set', 'green');
+    }
+    console.log(`  ${num}  ${name}${prov}${ctx}${keyStatus}`);
+}
+/** Fuzzy match a typed model name against all known models */
+function fuzzyMatchModel(input, allModels) {
+    const lower = input.toLowerCase();
+    // Exact match
+    if (allModels.includes(input))
+        return input;
+    // Case-insensitive exact
+    const exact = allModels.find(m => m.toLowerCase() === lower);
+    if (exact)
+        return exact;
+    // Prefix match
+    const prefix = allModels.find(m => m.toLowerCase().startsWith(lower));
+    if (prefix)
+        return prefix;
+    // Substring match
+    const sub = allModels.find(m => m.toLowerCase().includes(lower));
+    if (sub)
+        return sub;
+    return undefined;
+}
+// ── Setup wizard ─────────────────────────────────────────────────────────────
+/** Interactive setup wizard — model-first flow */
 async function runSetup() {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    console.log(fmt('\n⚡ CodeBot AI — Setup', 'bold'));
+    console.log(fmt('\n\u26A1 CodeBot AI \u2014 Setup', 'bold'));
     console.log(fmt('   Let\'s get you configured.\n', 'dim'));
-    // Step 1: Detect local servers
+    // ── Phase A: Detection ──────────────────────────────────────────────────────
     console.log(fmt('Scanning for local LLM servers...', 'dim'));
     const localServers = await detectLocalServers();
-    // Step 2: Detect API keys
-    const apiKeys = detectApiKeys();
-    const availableKeys = apiKeys.filter(k => k.set);
-    // Show what was found
+    const apiKeyStatus = new Map();
+    for (const [provider, defaults] of Object.entries(registry_1.PROVIDER_DEFAULTS)) {
+        apiKeyStatus.set(provider, !!process.env[defaults.envKey]);
+    }
+    // Show detection results
     if (localServers.length > 0) {
         for (const server of localServers) {
-            console.log(fmt(`  ✓ ${server.name} detected (${server.models.length} models)`, 'green'));
+            console.log(fmt(`  \u2713 ${server.name} detected (${server.models.length} models)`, 'green'));
         }
     }
     else {
-        console.log(fmt('  No local LLM servers detected.', 'dim'));
+        console.log(fmt('  No local servers found. Start Ollama for free local models: ollama.com', 'dim'));
     }
-    if (availableKeys.length > 0) {
-        for (const key of availableKeys) {
-            console.log(fmt(`  ✓ ${key.provider} API key found (${key.envVar})`, 'green'));
-        }
+    const setKeys = [...apiKeyStatus.entries()].filter(([, set]) => set);
+    for (const [prov] of setKeys) {
+        const display = PROVIDER_DISPLAY[prov] || prov;
+        console.log(fmt(`  \u2713 ${display} API key found`, 'green'));
     }
-    // Step 3: Choose provider — show ALL options (local + cloud)
-    console.log(fmt('\nChoose your setup:', 'bold'));
-    const options = [];
-    let idx = 1;
-    // Local options first
-    for (const server of localServers) {
-        const defaultModel = server.models[0] || 'qwen2.5-coder:32b';
-        options.push({
-            label: `${server.name} (local, free)`,
-            provider: 'openai',
-            model: defaultModel,
-            baseUrl: server.url,
-            needsKey: false,
-        });
-        console.log(`  ${fmt(`${idx}`, 'cyan')} ${server.name} — ${defaultModel} ${fmt('(local, free, private)', 'green')}`);
-        idx++;
+    // ── Phase B: Build & render model list ──────────────────────────────────────
+    const modelList = buildModelList(localServers, apiKeyStatus);
+    console.log(fmt('\nChoose a model:', 'bold'));
+    let currentCategory = '';
+    modelList.forEach((entry, i) => {
+        if (entry.category !== currentCategory) {
+            currentCategory = entry.category;
+            renderCategoryHeader(currentCategory);
+        }
+        renderModelRow(i + 1, entry);
+    });
+    if (modelList.length === 0) {
+        console.log(fmt('\n  No models available. Install Ollama or set a cloud API key.', 'yellow'));
+        rl.close();
+        return {};
     }
-    // Cloud options — ALWAYS show all providers
-    for (const cloud of CLOUD_PROVIDERS) {
-        const keyInfo = apiKeys.find(k => k.provider === cloud.provider);
-        const hasKey = keyInfo?.set || false;
-        const defaults = registry_1.PROVIDER_DEFAULTS[cloud.provider];
-        const keyStatus = hasKey ? fmt('✓ key set', 'green') : fmt('enter key during setup', 'yellow');
-        options.push({
-            label: cloud.name,
-            provider: cloud.provider,
-            model: cloud.defaultModel,
-            baseUrl: defaults.baseUrl,
-            needsKey: !hasKey,
-            envVar: defaults.envKey,
-        });
-        console.log(`  ${fmt(`${idx}`, 'cyan')} ${cloud.name} — ${cloud.description} ${fmt(`(${keyStatus})`, 'dim')}`);
-        idx++;
+    // ── Phase C: Model selection ────────────────────────────────────────────────
+    const allKnownModels = [
+        ...Object.keys(registry_1.MODEL_REGISTRY),
+        ...localServers.flatMap(s => s.models),
+    ];
+    const choice = await ask(rl, fmt(`\nSelect [1-${modelList.length}] or type a model name: `, 'cyan'));
+    let selectedModel;
+    let selectedProvider;
+    let selectedBaseUrl;
+    let isLocal = false;
+    const choiceNum = parseInt(choice, 10);
+    if (choiceNum >= 1 && choiceNum <= modelList.length) {
+        // User picked by number
+        const entry = modelList[choiceNum - 1];
+        selectedModel = entry.id;
+        selectedProvider = entry.provider === 'local' ? 'openai' : entry.provider;
+        selectedBaseUrl = entry.baseUrl;
+        isLocal = entry.provider === 'local';
     }
-    const choice = await ask(rl, fmt(`\nSelect [1-${options.length}]: `, 'cyan'));
-    const selected = options[parseInt(choice, 10) - 1] || options[0];
-    // Step 4: If cloud provider needs API key, prompt for it
-    let apiKey = '';
-    if (selected.needsKey && selected.envVar) {
-        console.log(fmt(`\n  ${selected.label} requires an API key.`, 'yellow'));
-        console.log(fmt(`  Get one at: ${getKeyUrl(selected.provider)}`, 'dim'));
-        apiKey = await ask(rl, fmt(`\n  Enter your ${selected.label} API key: `, 'cyan'));
-        if (!apiKey) {
-            console.log(fmt(`\n  No key entered. You can set it later:`, 'yellow'));
-            console.log(fmt(`    export ${selected.envVar}="your-key-here"`, 'dim'));
+    else if (choice.length > 1) {
+        // User typed a model name — fuzzy match
+        const matched = fuzzyMatchModel(choice, allKnownModels);
+        selectedModel = matched || choice;
+        const detected = (0, registry_1.detectProvider)(selectedModel);
+        selectedProvider = detected || 'openai';
+        isLocal = !detected;
+        if (isLocal) {
+            const server = localServers.find(s => s.models.some(m => m.toLowerCase() === selectedModel.toLowerCase() || m.toLowerCase().includes(selectedModel.toLowerCase())));
+            selectedBaseUrl = server?.url || 'http://localhost:11434';
+        }
+        else {
+            selectedBaseUrl = registry_1.PROVIDER_DEFAULTS[selectedProvider]?.baseUrl || '';
         }
     }
-    else if (selected.envVar) {
-        // Use existing env var
-        apiKey = process.env[selected.envVar] || '';
+    else {
+        // Empty or single char — default to first entry
+        const entry = modelList[0];
+        selectedModel = entry.id;
+        selectedProvider = entry.provider === 'local' ? 'openai' : entry.provider;
+        selectedBaseUrl = entry.baseUrl;
+        isLocal = entry.provider === 'local';
     }
-    // Step 5: Show available models for chosen provider
-    const matchedServer = localServers.find(s => s.url === selected.baseUrl);
-    const providerModels = matchedServer && matchedServer.models.length > 0
-        ? matchedServer.models
-        : Object.entries(registry_1.MODEL_REGISTRY)
-            .filter(([, info]) => info.provider === selected.provider)
-            .map(([name]) => name);
-    if (providerModels.length > 1) {
-        console.log(fmt(`\nAvailable models${matchedServer ? ` on ${matchedServer.name}` : ''}:`, 'bold'));
-        providerModels.slice(0, 15).forEach((m, i) => {
-            const marker = m === selected.model ? fmt(' (default)', 'green') : '';
-            console.log(`  ${fmt(`${i + 1}`, 'cyan')} ${m}${marker}`);
-        });
-        const modelChoice = await ask(rl, fmt(`\nModel [Enter for ${selected.model}]: `, 'cyan'));
-        if (modelChoice) {
-            const modelIdx = parseInt(modelChoice, 10) - 1;
-            if (providerModels[modelIdx]) {
-                selected.model = providerModels[modelIdx];
-            }
-            else if (modelChoice.length > 2) {
-                // Treat as model name typed directly
-                selected.model = modelChoice;
+    console.log(fmt(`  \u2713 Selected: ${selectedModel}`, 'green'));
+    // ── Phase D: API key resolution ─────────────────────────────────────────────
+    let apiKey = '';
+    if (!isLocal) {
+        const defaults = registry_1.PROVIDER_DEFAULTS[selectedProvider];
+        const envKey = defaults?.envKey;
+        const existingKey = envKey ? process.env[envKey] : undefined;
+        if (existingKey) {
+            console.log(fmt(`  \u2713 Using ${envKey} from environment`, 'green'));
+            apiKey = existingKey;
+        }
+        else if (envKey) {
+            const providerName = PROVIDER_DISPLAY[selectedProvider] || selectedProvider;
+            const keyUrl = getKeyUrl(selectedProvider);
+            console.log(fmt(`\n  ${selectedModel} requires a ${providerName} API key.`, 'yellow'));
+            console.log(fmt(`  Get one at: ${keyUrl}`, 'dim'));
+            apiKey = await ask(rl, fmt('\n  Paste your API key: ', 'cyan'));
+            if (!apiKey) {
+                console.log(fmt(`\n  No key entered. Set it later:`, 'yellow'));
+                console.log(fmt(`    export ${envKey}="your-key-here"`, 'dim'));
             }
         }
     }
-    // Step 6: Auto mode?
+    // ── Phase E: Autonomous mode ────────────────────────────────────────────────
     const autoChoice = await ask(rl, fmt('\nEnable autonomous mode? (skip permission prompts) [y/N]: ', 'cyan'));
     const autoApprove = autoChoice.toLowerCase().startsWith('y');
     rl.close();
-    // Save config
+    // ── Phase F: Save config + summary ──────────────────────────────────────────
     const config = {
-        model: selected.model,
-        provider: selected.provider,
-        baseUrl: selected.baseUrl,
+        model: selectedModel,
+        provider: selectedProvider,
+        baseUrl: selectedBaseUrl,
         autoApprove,
     };
-    // Save API key if user entered one
     if (apiKey) {
         config.apiKey = apiKey;
     }
     saveConfig(config);
-    console.log(fmt('\n✓ Config saved to ~/.codebot/config.json', 'green'));
-    console.log(fmt(`  Model: ${config.model}`, 'dim'));
-    console.log(fmt(`  Provider: ${config.provider}`, 'dim'));
+    console.log(fmt('\n\u2713 Config saved to ~/.codebot/config.json', 'green'));
+    console.log(fmt(`  Model:    ${config.model}`, 'dim'));
+    console.log(fmt(`  Provider: ${selectedProvider}${isLocal ? '' : ' (auto-detected)'}`, 'dim'));
     if (apiKey) {
-        console.log(fmt(`  API Key: ${'*'.repeat(Math.min(apiKey.length, 20))}`, 'dim'));
+        console.log(fmt(`  API Key:  ${'*'.repeat(Math.min(apiKey.length, 20))}`, 'dim'));
     }
     if (autoApprove) {
-        console.log(fmt(`  Mode: AUTONOMOUS`, 'yellow'));
+        console.log(fmt(`  Mode:     AUTONOMOUS`, 'yellow'));
     }
     console.log(fmt(`\nRun ${fmt('codebot', 'bold')} to start. Run ${fmt('codebot --setup', 'bold')} to reconfigure.\n`, 'dim'));
     return config;

package/dist/tools/web-fetch.js

@@ -73,14 +73,23 @@ class WebFetchTool {
             body = args.body;
         }
         try {
+            // AbortController covers both connection AND body reading (res.text())
+            const controller = new AbortController();
+            const bodyTimeout = setTimeout(() => controller.abort(), 30_000);
             const res = await fetch(url, {
                 method,
                 headers,
                 body,
-                signal: AbortSignal.timeout(30000),
+                signal: controller.signal,
             });
             const contentType = res.headers.get('content-type') || '';
-            const responseText = await res.text();
+            let responseText;
+            try {
+                responseText = await res.text();
+            }
+            finally {
+                clearTimeout(bodyTimeout);
+            }
             // Truncate very large responses
             const maxLen = 50000;
             const truncated = responseText.length > maxLen

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codebot-ai",
-  "version": "1.2.2",
-  "description": "Local-first AI coding assistant. Zero dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, and more.",
+  "version": "1.3.0",
+  "description": "Zero-dependency autonomous AI agent. Code, browse, search, automate. Works with any LLM — Ollama, Claude, GPT, Gemini, DeepSeek, Groq, Mistral, Grok.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -17,17 +17,25 @@
   },
   "keywords": [
     "ai",
-    "coding-assistant",
-    "ollama",
-    "local-llm",
+    "ai-agent",
     "agent",
-    "cli",
+    "autonomous",
+    "agentic",
+    "coding-assistant",
     "code-generation",
+    "llm",
+    "openai",
     "claude",
     "gpt",
     "gemini",
-    "autonomous",
-    "agentic"
+    "ollama",
+    "deepseek",
+    "groq",
+    "mistral",
+    "local-llm",
+    "browser-automation",
+    "cli",
+    "web-search"
   ],
   "author": "Ascendral Software Development & Innovation",
   "license": "MIT",