kernelbot 1.0.24 → 1.0.25

package/.env.example

@@ -1,5 +1,13 @@
+# AI provider API keys (only the one matching your brain.provider is required)
 ANTHROPIC_API_KEY=sk-ant-...
+OPENAI_API_KEY=sk-...
+GOOGLE_API_KEY=AIza...
+GROQ_API_KEY=gsk_...
+
+# Required
 TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
+
+# Optional
 GITHUB_TOKEN=ghp_...
 JIRA_BASE_URL=https://yourcompany.atlassian.net
 JIRA_EMAIL=you@company.com

package/README.md

@@ -1,13 +1,14 @@
 # KernelBot
 
-[kernelbot.io](https://kernelbot.io) | [npm](https://www.npmjs.com/package/kernelbot) | [GitHub](https://github.com/KernelCode/KERNEL)
+[kernelbot.io](https://kernelbot.io) | [npm](https://www.npmjs.com/package/kernelbot) | [GitHub](https://github.com/KernelCode/kernelbot)
 
-AI engineering agent — a Telegram bot backed by Claude with full OS control via tool use.
+AI engineering agent — a Telegram bot backed by Claude, GPT, Gemini, or Groq with full OS control via tool use.
 
 Send a message in Telegram, and KernelBot will read files, write code, run commands, browse the web, manage infrastructure, and respond with the results. It's your personal engineering assistant with direct access to your machine.
 
 ## Features
 
+- **Multi-model support** — choose your AI brain: Anthropic (Claude), OpenAI (GPT), Google (Gemini), or Groq (Llama/Mixtral). Switch models anytime from the CLI menu
 - **Autonomous agent loop** — send one message and KernelBot chains tool calls until the task is done, no hand-holding needed
 - **Full shell access** — run any command, install packages, build projects, run tests
 - **File management** — read, write, and create files with automatic directory creation
@@ -30,14 +31,14 @@ Send a message in Telegram, and KernelBot will read files, write code, run comma
 ## How It Works
 
 ```text
-You (Telegram) → KernelBot → Claude (Anthropic API)
+You (Telegram) → KernelBot → AI Brain (Claude / GPT / Gemini / Groq)
                                    ↕
                       Tools (shell, files, git, docker, browser, etc.)
                                    ↕
                       Claude Code CLI (coding tasks)
 ```
 
-KernelBot runs a **tool-use loop**: Claude decides which tools to call, KernelBot executes them on your OS, feeds results back, and Claude continues until the task is done. One message can trigger dozens of tool calls autonomously.
+KernelBot runs a **tool-use loop**: the AI decides which tools to call, KernelBot executes them on your OS, feeds results back, and the AI continues until the task is done. One message can trigger dozens of tool calls autonomously.
 
 For complex coding tasks, KernelBot can spawn **Claude Code CLI** as a sub-agent — giving it a dedicated coding environment with its own tool loop for writing, editing, and debugging code.
 
@@ -45,85 +46,85 @@ For complex coding tasks, KernelBot can spawn **Claude Code CLI** as a sub-agent
 
 ### File System & Shell
 
-| Tool | Description |
-| --- | --- |
-| `execute_command` | Run any shell command (git, npm, python, etc.) |
-| `read_file` | Read file contents with optional line limits |
-| `write_file` | Write/create files, auto-creates parent directories |
-| `list_directory` | List directory contents, optionally recursive |
+| Tool              | Description                                         |
+| ----------------- | --------------------------------------------------- |
+| `execute_command` | Run any shell command (git, npm, python, etc.)      |
+| `read_file`       | Read file contents with optional line limits        |
+| `write_file`      | Write/create files, auto-creates parent directories |
+| `list_directory`  | List directory contents, optionally recursive       |
 
 ### Git & GitHub
 
-| Tool | Description |
-| --- | --- |
-| `git_clone` | Clone a repo (`org/repo` shorthand or full URL) |
-| `git_checkout` | Checkout or create branches |
-| `git_commit` | Stage all changes and commit |
-| `git_push` | Push current branch to remote |
-| `git_diff` | Show uncommitted changes |
-| `github_create_pr` | Create a pull request |
-| `github_get_pr_diff` | Get the diff of a PR |
-| `github_post_review` | Post a review on a PR |
-| `github_create_repo` | Create a new GitHub repository |
-| `github_list_prs` | List pull requests for a repo |
+| Tool                 | Description                                     |
+| -------------------- | ----------------------------------------------- |
+| `git_clone`          | Clone a repo (`org/repo` shorthand or full URL) |
+| `git_checkout`       | Checkout or create branches                     |
+| `git_commit`         | Stage all changes and commit                    |
+| `git_push`           | Push current branch to remote                   |
+| `git_diff`           | Show uncommitted changes                        |
+| `github_create_pr`   | Create a pull request                           |
+| `github_get_pr_diff` | Get the diff of a PR                            |
+| `github_post_review` | Post a review on a PR                           |
+| `github_create_repo` | Create a new GitHub repository                  |
+| `github_list_prs`    | List pull requests for a repo                   |
 
 ### Web Browsing
 
-| Tool | Description |
-| --- | --- |
-| `browse_website` | Navigate to a URL and extract page content (title, headings, text, links) |
-| `screenshot_website` | Take a screenshot of a website, supports full-page and element capture |
-| `extract_content` | Extract specific content using CSS selectors |
-| `interact_with_page` | Click, type, scroll, and run JS on a webpage |
-| `send_image` | Send an image/screenshot directly to the Telegram chat |
+| Tool                 | Description                                                               |
+| -------------------- | ------------------------------------------------------------------------- |
+| `browse_website`     | Navigate to a URL and extract page content (title, headings, text, links) |
+| `screenshot_website` | Take a screenshot of a website, supports full-page and element capture    |
+| `extract_content`    | Extract specific content using CSS selectors                              |
+| `interact_with_page` | Click, type, scroll, and run JS on a webpage                              |
+| `send_image`         | Send an image/screenshot directly to the Telegram chat                    |
 
 ### JIRA
 
-| Tool | Description |
-| --- | --- |
-| `jira_get_ticket` | Get details of a specific JIRA ticket |
-| `jira_search_tickets` | Search tickets using JQL queries |
-| `jira_list_my_tickets` | List tickets assigned to the current user |
-| `jira_get_project_tickets` | Get tickets from a specific JIRA project |
+| Tool                       | Description                               |
+| -------------------------- | ----------------------------------------- |
+| `jira_get_ticket`          | Get details of a specific JIRA ticket     |
+| `jira_search_tickets`      | Search tickets using JQL queries          |
+| `jira_list_my_tickets`     | List tickets assigned to the current user |
+| `jira_get_project_tickets` | Get tickets from a specific JIRA project  |
 
 ### Docker
 
-| Tool | Description |
-| --- | --- |
-| `docker_ps` | List containers |
-| `docker_logs` | Get container logs |
-| `docker_exec` | Execute a command inside a running container |
-| `docker_compose` | Run docker compose commands |
+| Tool             | Description                                  |
+| ---------------- | -------------------------------------------- |
+| `docker_ps`      | List containers                              |
+| `docker_logs`    | Get container logs                           |
+| `docker_exec`    | Execute a command inside a running container |
+| `docker_compose` | Run docker compose commands                  |
 
 ### Process & System
 
-| Tool | Description |
-| --- | --- |
-| `process_list` | List running processes, optionally filter by name |
-| `kill_process` | Kill a process by PID or name |
+| Tool              | Description                                            |
+| ----------------- | ------------------------------------------------------ |
+| `process_list`    | List running processes, optionally filter by name      |
+| `kill_process`    | Kill a process by PID or name                          |
 | `service_control` | Manage systemd services (start, stop, restart, status) |
 
 ### Monitoring
 
-| Tool | Description |
-| --- | --- |
-| `disk_usage` | Show disk space usage |
-| `memory_usage` | Show RAM usage |
-| `cpu_usage` | Show CPU load |
-| `system_logs` | Read system or application logs |
+| Tool           | Description                     |
+| -------------- | ------------------------------- |
+| `disk_usage`   | Show disk space usage           |
+| `memory_usage` | Show RAM usage                  |
+| `cpu_usage`    | Show CPU load                   |
+| `system_logs`  | Read system or application logs |
 
 ### Networking
 
-| Tool | Description |
-| --- | --- |
-| `check_port` | Check if a port is open and listening |
-| `curl_url` | Make HTTP requests and return the response |
-| `nginx_reload` | Test nginx config and reload if valid |
+| Tool           | Description                                |
+| -------------- | ------------------------------------------ |
+| `check_port`   | Check if a port is open and listening      |
+| `curl_url`     | Make HTTP requests and return the response |
+| `nginx_reload` | Test nginx config and reload if valid      |
 
 ### Coding
 
-| Tool | Description |
-| --- | --- |
+| Tool                | Description                                                                               |
+| ------------------- | ----------------------------------------------------------------------------------------- |
 | `spawn_claude_code` | Spawn Claude Code CLI for coding tasks — writing, fixing, reviewing, and scaffolding code |
 
 ## Disclaimer
@@ -144,10 +145,13 @@ kernelbot
 
 That's it. On first run, KernelBot will:
 
-1. Detect missing credentials and prompt for them
-2. Save them to `~/.kernelbot/.env`
-3. Verify API connections
-4. Launch the Telegram bot
+1. Prompt you to select an AI provider and model
+2. Ask for your API key and Telegram bot token
+3. Save credentials to `~/.kernelbot/.env`
+4. Verify API connections
+5. Launch the Telegram bot
+
+You can change your AI provider/model anytime from the CLI menu (option 5).
 
 ## Configuration
 
@@ -158,7 +162,12 @@ KernelBot auto-detects config from the current directory or `~/.kernelbot/`. Eve
 Set these in `.env` or as system environment variables:
 
 ```text
-ANTHROPIC_API_KEY=sk-ant-...
+# AI provider key (only the one matching your provider is required)
+ANTHROPIC_API_KEY=sk-ant-...     # for Anthropic (Claude)
+OPENAI_API_KEY=sk-...            # for OpenAI (GPT)
+GOOGLE_API_KEY=AIza...           # for Google (Gemini)
+GROQ_API_KEY=gsk_...             # for Groq (Llama/Mixtral)
+
 TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
 GITHUB_TOKEN=ghp_...                           # optional, for GitHub tools
 JIRA_BASE_URL=https://yourcompany.atlassian.net # optional, for JIRA tools
@@ -174,7 +183,8 @@ Drop a `config.yaml` in your working directory or `~/.kernelbot/` to customize b
 bot:
   name: KernelBot
 
-anthropic:
+brain:
+  provider: anthropic    # anthropic | openai | google | groq
   model: claude-sonnet-4-20250514
   max_tokens: 8192
   temperature: 0.3
@@ -209,11 +219,11 @@ conversation:
 
 ## Telegram Commands
 
-| Command | Description |
-| --- | --- |
-| `/clean` | Clear conversation and start fresh |
-| `/history` | Show message count in memory |
-| `/help` | Show help message |
+| Command    | Description                        |
+| ---------- | ---------------------------------- |
+| `/clean`   | Clear conversation and start fresh |
+| `/history` | Show message count in memory       |
+| `/help`    | Show help message                  |
 
 ## Security
 
@@ -256,12 +266,18 @@ KernelBot/
 ├── bin/
 │   └── kernel.js              # Entry point + CLI menu
 ├── src/
-│   ├── agent.js               # Claude tool-use loop
+│   ├── agent.js               # AI tool-use loop (provider-agnostic)
 │   ├── bot.js                 # Telegram bot (polling, auth, message handling)
 │   ├── coder.js               # Claude Code CLI spawner + smart output
 │   ├── conversation.js        # Per-chat conversation history
 │   ├── prompts/
 │   │   └── system.js          # System prompt
+│   ├── providers/
+│   │   ├── models.js          # Provider & model catalog
+│   │   ├── base.js            # Abstract provider interface
+│   │   ├── anthropic.js       # Anthropic (Claude) provider
+│   │   ├── openai-compat.js   # OpenAI / Gemini / Groq provider
+│   │   └── index.js           # Provider factory
 │   ├── security/
 │   │   ├── auth.js            # User allowlist
 │   │   ├── audit.js           # Tool call audit logging
@@ -290,7 +306,11 @@ KernelBot/
 ## Requirements
 
 - Node.js 18+
-- [Anthropic API key](https://console.anthropic.com/)
+- AI provider API key (one of):
+  - [Anthropic API key](https://console.anthropic.com/) (Claude)
+  - [OpenAI API key](https://platform.openai.com/api-keys) (GPT)
+  - [Google AI API key](https://aistudio.google.com/apikey) (Gemini)
+  - [Groq API key](https://console.groq.com/keys) (Llama/Mixtral)
 - [Telegram Bot Token](https://t.me/BotFather)
 - Chromium/Chrome (for browser tools — installed automatically by Puppeteer)
 - [GitHub Token](https://github.com/settings/tokens) (optional, for GitHub tools)

package/bin/kernel.js

@@ -9,7 +9,7 @@ import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import chalk from 'chalk';
-import { loadConfig, loadConfigInteractive } from '../src/utils/config.js';
+import { loadConfig, loadConfigInteractive, changeBrainModel } from '../src/utils/config.js';
 import { createLogger, getLogger } from '../src/utils/logger.js';
 import {
   showLogo,
@@ -21,16 +21,23 @@ import { createAuditLogger } from '../src/security/audit.js';
 import { ConversationManager } from '../src/conversation.js';
 import { Agent } from '../src/agent.js';
 import { startBot } from '../src/bot.js';
-import Anthropic from '@anthropic-ai/sdk';
+import { createProvider, PROVIDERS } from '../src/providers/index.js';
 
-function showMenu() {
+function showMenu(config) {
+  const providerDef = PROVIDERS[config.brain.provider];
+  const providerName = providerDef ? providerDef.name : config.brain.provider;
+  const modelId = config.brain.model;
+
+  console.log('');
+  console.log(chalk.dim(`  Current brain: ${providerName} / ${modelId}`));
   console.log('');
   console.log(chalk.bold('  What would you like to do?\n'));
   console.log(`  ${chalk.cyan('1.')} Start bot`);
   console.log(`  ${chalk.cyan('2.')} Check connections`);
   console.log(`  ${chalk.cyan('3.')} View logs`);
   console.log(`  ${chalk.cyan('4.')} View audit logs`);
-  console.log(`  ${chalk.cyan('5.')} Exit`);
+  console.log(`  ${chalk.cyan('5.')} Change brain model`);
+  console.log(`  ${chalk.cyan('6.')} Exit`);
   console.log('');
 }
 
@@ -70,21 +77,21 @@ function viewLog(filename) {
 }
 
 async function runCheck(config) {
-  await showStartupCheck('ANTHROPIC_API_KEY', async () => {
-    if (!config.anthropic.api_key) throw new Error('Not set');
+  const providerDef = PROVIDERS[config.brain.provider];
+  const providerLabel = providerDef ? providerDef.name : config.brain.provider;
+  const envKeyLabel = providerDef ? providerDef.envKey : 'API_KEY';
+
+  await showStartupCheck(envKeyLabel, async () => {
+    if (!config.brain.api_key) throw new Error('Not set');
   });
 
   await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
     if (!config.telegram.bot_token) throw new Error('Not set');
   });
 
-  await showStartupCheck('Anthropic API connection', async () => {
-    const client = new Anthropic({ apiKey: config.anthropic.api_key });
-    await client.messages.create({
-      model: config.anthropic.model,
-      max_tokens: 16,
-      messages: [{ role: 'user', content: 'ping' }],
-    });
+  await showStartupCheck(`${providerLabel} API connection`, async () => {
+    const provider = createProvider(config);
+    await provider.ping();
   });
 
   await showStartupCheck('Telegram Bot API', async () => {
@@ -102,16 +109,15 @@ async function startBotFlow(config) {
   createAuditLogger();
   const logger = getLogger();
 
+  const providerDef = PROVIDERS[config.brain.provider];
+  const providerLabel = providerDef ? providerDef.name : config.brain.provider;
+
   const checks = [];
 
   checks.push(
-    await showStartupCheck('Anthropic API', async () => {
-      const client = new Anthropic({ apiKey: config.anthropic.api_key });
-      await client.messages.create({
-        model: config.anthropic.model,
-        max_tokens: 16,
-        messages: [{ role: 'user', content: 'ping' }],
-      });
+    await showStartupCheck(`${providerLabel} API`, async () => {
+      const provider = createProvider(config);
+      await provider.ping();
     }),
   );
 
@@ -148,7 +154,7 @@ async function main() {
 
   let running = true;
   while (running) {
-    showMenu();
+    showMenu(config);
     const choice = await ask(rl, chalk.cyan('  > '));
 
     switch (choice.trim()) {
@@ -168,6 +174,9 @@ async function main() {
         viewLog('kernel-audit.log');
         break;
       case '5':
+        await changeBrainModel(config, rl);
+        break;
+      case '6':
         running = false;
         break;
       default:

package/config.example.yaml

@@ -5,7 +5,8 @@ bot:
   name: KernelBot
   description: AI engineering agent with full OS control
 
-anthropic:
+brain:
+  provider: anthropic    # anthropic | openai | google | groq
   model: claude-sonnet-4-20250514
   max_tokens: 8192
   temperature: 0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",
@@ -15,6 +15,9 @@
     "agent",
     "telegram",
     "anthropic",
+    "openai",
+    "gemini",
+    "groq",
     "tools"
   ],
   "repository": {
@@ -37,6 +40,7 @@
     "gradient-string": "^3.0.0",
     "js-yaml": "^4.1.0",
     "node-telegram-bot-api": "^0.66.0",
+    "openai": "^4.82.0",
     "ora": "^8.1.1",
     "puppeteer": "^24.37.3",
     "simple-git": "^3.31.1",

package/src/agent.js

@@ -1,4 +1,4 @@
-import Anthropic from '@anthropic-ai/sdk';
+import { createProvider } from './providers/index.js';
 import { toolDefinitions, executeTool, checkConfirmation } from './tools/index.js';
 import { getSystemPrompt } from './prompts/system.js';
 import { getLogger } from './utils/logger.js';
@@ -8,7 +8,7 @@ export class Agent {
   constructor({ config, conversationManager }) {
     this.config = config;
     this.conversationManager = conversationManager;
-    this.client = new Anthropic({ apiKey: config.anthropic.api_key });
+    this.provider = createProvider(config);
     this.systemPrompt = getSystemPrompt(config);
     this._pending = new Map(); // chatId -> pending state
   }
@@ -33,7 +33,7 @@ export class Agent {
       }
     }
 
-    const { max_tool_depth } = this.config.anthropic;
+    const { max_tool_depth } = this.config.brain;
 
     // Add user message to persistent history
     this.conversationManager.addMessage(chatId, 'user', userMessage);
@@ -160,7 +160,7 @@ export class Agent {
     }
 
     pending.messages.push({ role: 'user', content: pending.toolResults });
-    const { max_tool_depth } = this.config.anthropic;
+    const { max_tool_depth } = this.config.brain;
     return await this._runLoop(chatId, pending.messages, user, 0, max_tool_depth);
   }
 
@@ -203,56 +203,44 @@ export class Agent {
 
   async _runLoop(chatId, messages, user, startDepth, maxDepth) {
     const logger = getLogger();
-    const { model, max_tokens, temperature } = this.config.anthropic;
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
       logger.debug(`Agent loop iteration ${depth + 1}/${maxDepth}`);
 
-      const response = await this.client.messages.create({
-        model,
-        max_tokens,
-        temperature,
+      const response = await this.provider.chat({
         system: this.systemPrompt,
-        tools: toolDefinitions,
         messages,
+        tools: toolDefinitions,
       });
 
-      if (response.stop_reason === 'end_turn') {
-        const textBlocks = response.content
-          .filter((b) => b.type === 'text')
-          .map((b) => b.text);
-        const reply = textBlocks.join('\n');
-
+      if (response.stopReason === 'end_turn') {
+        const reply = response.text || '';
         this.conversationManager.addMessage(chatId, 'assistant', reply);
         return reply;
       }
 
-      if (response.stop_reason === 'tool_use') {
-        messages.push({ role: 'assistant', content: response.content });
+      if (response.stopReason === 'tool_use') {
+        messages.push({ role: 'assistant', content: response.rawContent });
 
-        // Send Claude's thinking text to the user
-        const thinkingBlocks = response.content.filter((b) => b.type === 'text' && b.text.trim());
-        if (thinkingBlocks.length > 0) {
-          const thinking = thinkingBlocks.map((b) => b.text).join('\n');
-          logger.info(`Agent thinking: ${thinking.slice(0, 200)}`);
-          await this._sendUpdate(`💭 ${thinking}`);
+        // Send thinking text to the user
+        if (response.text && response.text.trim()) {
+          logger.info(`Agent thinking: ${response.text.slice(0, 200)}`);
+          await this._sendUpdate(`💭 ${response.text}`);
         }
 
-        const toolUseBlocks = response.content.filter((b) => b.type === 'tool_use');
         const toolResults = [];
 
-        for (let i = 0; i < toolUseBlocks.length; i++) {
-          const block = toolUseBlocks[i];
+        for (let i = 0; i < response.toolCalls.length; i++) {
+          const block = response.toolCalls[i];
+
+          // Build a block-like object for _checkPause (needs .type for remainingBlocks filter)
+          const blockObj = { type: 'tool_use', id: block.id, name: block.name, input: block.input };
 
           // Check if we need to pause (missing cred or dangerous action)
-          const pauseMsg = this._checkPause(
-            chatId,
-            block,
-            user,
-            toolResults,
-            toolUseBlocks.slice(i + 1),
-            messages,
-          );
+          const remaining = response.toolCalls.slice(i + 1).map((tc) => ({
+            type: 'tool_use', id: tc.id, name: tc.name, input: tc.input,
+          }));
+          const pauseMsg = this._checkPause(chatId, blockObj, user, toolResults, remaining, messages);
           if (pauseMsg) return pauseMsg;
 
           const summary = this._formatToolSummary(block.name, block.input);
@@ -278,14 +266,10 @@ export class Agent {
       }
 
       // Unexpected stop reason
-      logger.warn(`Unexpected stop_reason: ${response.stop_reason}`);
-      const fallbackText = response.content
-        .filter((b) => b.type === 'text')
-        .map((b) => b.text)
-        .join('\n');
-      if (fallbackText) {
-        this.conversationManager.addMessage(chatId, 'assistant', fallbackText);
-        return fallbackText;
+      logger.warn(`Unexpected stopReason: ${response.stopReason}`);
+      if (response.text) {
+        this.conversationManager.addMessage(chatId, 'assistant', response.text);
+        return response.text;
       }
       return 'Something went wrong — unexpected response from the model.';
     }

package/src/providers/anthropic.js

@@ -0,0 +1,44 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { BaseProvider } from './base.js';
+
+export class AnthropicProvider extends BaseProvider {
+  constructor(opts) {
+    super(opts);
+    this.client = new Anthropic({ apiKey: this.apiKey });
+  }
+
+  async chat({ system, messages, tools }) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature,
+      system,
+      tools,
+      messages,
+    });
+
+    const stopReason = response.stop_reason === 'end_turn' ? 'end_turn' : 'tool_use';
+
+    const textBlocks = response.content.filter((b) => b.type === 'text');
+    const text = textBlocks.map((b) => b.text).join('\n');
+
+    const toolCalls = response.content
+      .filter((b) => b.type === 'tool_use')
+      .map((b) => ({ id: b.id, name: b.name, input: b.input }));
+
+    return {
+      stopReason,
+      text,
+      toolCalls,
+      rawContent: response.content,
+    };
+  }
+
+  async ping() {
+    await this.client.messages.create({
+      model: this.model,
+      max_tokens: 16,
+      messages: [{ role: 'user', content: 'ping' }],
+    });
+  }
+}

package/src/providers/base.js

@@ -0,0 +1,30 @@
+/**
+ * Abstract provider interface.
+ * Every provider must implement chat() and ping().
+ */
+
+export class BaseProvider {
+  constructor({ model, maxTokens, temperature, apiKey }) {
+    this.model = model;
+    this.maxTokens = maxTokens;
+    this.temperature = temperature;
+    this.apiKey = apiKey;
+  }
+
+  /**
+   * Send a chat completion request.
+   * @param {object} opts
+   * @param {string} opts.system - System prompt
+   * @param {Array} opts.messages - Anthropic-format messages
+   * @param {Array} opts.tools - Anthropic-format tool definitions
+   * @returns {Promise<{stopReason: 'end_turn'|'tool_use', text: string, toolCalls: Array<{id,name,input}>, rawContent: Array}>}
+   */
+  async chat({ system, messages, tools }) {
+    throw new Error('chat() not implemented');
+  }
+
+  /** Quick connectivity test — throws on failure. */
+  async ping() {
+    throw new Error('ping() not implemented');
+  }
+}

package/src/providers/index.js

@@ -0,0 +1,36 @@
+import { AnthropicProvider } from './anthropic.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+import { PROVIDERS } from './models.js';
+
+export { PROVIDERS } from './models.js';
+
+/**
+ * Create the right provider based on config.brain.
+ * @param {object} config - Full app config (must have config.brain)
+ * @returns {BaseProvider}
+ */
+export function createProvider(config) {
+  const { provider, model, max_tokens, temperature, api_key } = config.brain;
+
+  const providerDef = PROVIDERS[provider];
+  if (!providerDef) {
+    throw new Error(`Unknown provider: ${provider}. Valid: ${Object.keys(PROVIDERS).join(', ')}`);
+  }
+
+  const opts = {
+    model,
+    maxTokens: max_tokens,
+    temperature,
+    apiKey: api_key,
+  };
+
+  if (provider === 'anthropic') {
+    return new AnthropicProvider(opts);
+  }
+
+  // OpenAI, Google, Groq — all use OpenAI-compatible API
+  return new OpenAICompatProvider({
+    ...opts,
+    baseUrl: providerDef.baseUrl || undefined,
+  });
+}

package/src/providers/models.js

@@ -0,0 +1,54 @@
+/**
+ * Provider & model catalog — single source of truth.
+ */
+
+export const PROVIDERS = {
+  anthropic: {
+    name: 'Anthropic (Claude)',
+    envKey: 'ANTHROPIC_API_KEY',
+    models: [
+      { id: 'claude-sonnet-4-20250514', label: 'Claude Sonnet 4' },
+      { id: 'claude-opus-4-20250514', label: 'Claude Opus 4' },
+      { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5' },
+    ],
+  },
+  openai: {
+    name: 'OpenAI (GPT)',
+    envKey: 'OPENAI_API_KEY',
+    models: [
+      { id: 'gpt-4o', label: 'GPT-4o' },
+      { id: 'gpt-4o-mini', label: 'GPT-4o Mini' },
+      { id: 'o1', label: 'o1' },
+      { id: 'o3-mini', label: 'o3-mini' },
+    ],
+  },
+  google: {
+    name: 'Google (Gemini)',
+    envKey: 'GOOGLE_API_KEY',
+    baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    models: [
+      { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' },
+      { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+    ],
+  },
+  groq: {
+    name: 'Groq',
+    envKey: 'GROQ_API_KEY',
+    baseUrl: 'https://api.groq.com/openai/v1',
+    models: [
+      { id: 'llama-3.3-70b-versatile', label: 'Llama 3.3 70B' },
+      { id: 'llama-3.1-8b-instant', label: 'Llama 3.1 8B' },
+      { id: 'mixtral-8x7b-32768', label: 'Mixtral 8x7B' },
+    ],
+  },
+};
+
+/** Models that don't support system prompts or temperature (reasoning models). */
+export const REASONING_MODELS = new Set(['o1', 'o3-mini']);
+
+export function getProviderForModel(modelId) {
+  for (const [key, provider] of Object.entries(PROVIDERS)) {
+    if (provider.models.some((m) => m.id === modelId)) return key;
+  }
+  return null;
+}

package/src/providers/openai-compat.js

@@ -0,0 +1,163 @@
+import OpenAI from 'openai';
+import { BaseProvider } from './base.js';
+import { REASONING_MODELS } from './models.js';
+
+/**
+ * OpenAI-compatible provider — works with OpenAI, Groq, and Google Gemini
+ * via configurable baseURL.
+ */
+export class OpenAICompatProvider extends BaseProvider {
+  constructor(opts) {
+    super(opts);
+    this.client = new OpenAI({
+      apiKey: this.apiKey,
+      ...(opts.baseUrl && { baseURL: opts.baseUrl }),
+    });
+    this.isReasoningModel = REASONING_MODELS.has(this.model);
+  }
+
+  // ── Format conversion helpers ──
+
+  /** Anthropic tool defs → OpenAI function tool defs */
+  _convertTools(tools) {
+    if (!tools || tools.length === 0) return undefined;
+    return tools.map((t) => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema,
+      },
+    }));
+  }
+
+  /** Anthropic messages → OpenAI messages */
+  _convertMessages(system, messages) {
+    const out = [];
+
+    // System prompt as first message (skip for reasoning models)
+    if (system && !this.isReasoningModel) {
+      const systemText = Array.isArray(system)
+        ? system.map((b) => b.text).join('\n')
+        : system;
+      out.push({ role: 'system', content: systemText });
+    }
+
+    for (const msg of messages) {
+      if (msg.role === 'user') {
+        // Could be a string, content blocks, or tool_result array
+        if (typeof msg.content === 'string') {
+          out.push({ role: 'user', content: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          // Check if it's tool results
+          if (msg.content[0]?.type === 'tool_result') {
+            for (const tr of msg.content) {
+              out.push({
+                role: 'tool',
+                tool_call_id: tr.tool_use_id,
+                content: typeof tr.content === 'string' ? tr.content : JSON.stringify(tr.content),
+              });
+            }
+          } else {
+            // Text content blocks
+            const text = msg.content
+              .filter((b) => b.type === 'text')
+              .map((b) => b.text)
+              .join('\n');
+            out.push({ role: 'user', content: text || '' });
+          }
+        }
+      } else if (msg.role === 'assistant') {
+        // Convert Anthropic content blocks → OpenAI format
+        if (typeof msg.content === 'string') {
+          out.push({ role: 'assistant', content: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          const textParts = msg.content.filter((b) => b.type === 'text');
+          const toolParts = msg.content.filter((b) => b.type === 'tool_use');
+
+          const assistantMsg = {
+            role: 'assistant',
+            content: textParts.map((b) => b.text).join('\n') || null,
+          };
+
+          if (toolParts.length > 0) {
+            assistantMsg.tool_calls = toolParts.map((b) => ({
+              id: b.id,
+              type: 'function',
+              function: {
+                name: b.name,
+                arguments: JSON.stringify(b.input),
+              },
+            }));
+          }
+
+          out.push(assistantMsg);
+        }
+      }
+    }
+
+    return out;
+  }
+
+  /** OpenAI response → normalized format with rawContent in Anthropic format */
+  _normalizeResponse(response) {
+    const choice = response.choices[0];
+    const finishReason = choice.finish_reason;
+
+    const stopReason = finishReason === 'tool_calls' ? 'tool_use' : 'end_turn';
+
+    const text = choice.message.content || '';
+
+    const toolCalls = (choice.message.tool_calls || []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      input: JSON.parse(tc.function.arguments),
+    }));
+
+    // Build rawContent in Anthropic format for message history consistency
+    const rawContent = [];
+    if (text) {
+      rawContent.push({ type: 'text', text });
+    }
+    for (const tc of toolCalls) {
+      rawContent.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input });
+    }
+
+    return { stopReason, text, toolCalls, rawContent };
+  }
+
+  // ── Public API ──
+
+  async chat({ system, messages, tools }) {
+    const params = {
+      model: this.model,
+      messages: this._convertMessages(system, messages),
+    };
+
+    if (!this.isReasoningModel) {
+      params.temperature = this.temperature;
+    }
+
+    params.max_tokens = this.maxTokens;
+
+    const convertedTools = this._convertTools(tools);
+    if (convertedTools) {
+      params.tools = convertedTools;
+    }
+
+    const response = await this.client.chat.completions.create(params);
+    return this._normalizeResponse(response);
+  }
+
+  async ping() {
+    const params = {
+      model: this.model,
+      max_tokens: 16,
+      messages: [{ role: 'user', content: 'ping' }],
+    };
+    if (!this.isReasoningModel) {
+      params.temperature = 0;
+    }
+    await this.client.chat.completions.create(params);
+  }
+}

package/src/utils/config.js

@@ -5,13 +5,15 @@ import { createInterface } from 'readline';
 import yaml from 'js-yaml';
 import dotenv from 'dotenv';
 import chalk from 'chalk';
+import { PROVIDERS } from '../providers/models.js';
 
 const DEFAULTS = {
   bot: {
     name: 'KernelBot',
     description: 'AI engineering agent with full OS control',
   },
-  anthropic: {
+  brain: {
+    provider: 'anthropic',
     model: 'claude-sonnet-4-20250514',
     max_tokens: 8192,
     temperature: 0.3,
@@ -90,9 +92,126 @@ function ask(rl, question) {
   return new Promise((res) => rl.question(question, res));
 }
 
+/**
+ * Migrate legacy `anthropic` config section → `brain` section.
+ */
+function migrateAnthropicConfig(config) {
+  if (config.anthropic && !config.brain) {
+    config.brain = {
+      provider: 'anthropic',
+      model: config.anthropic.model || DEFAULTS.brain.model,
+      max_tokens: config.anthropic.max_tokens || DEFAULTS.brain.max_tokens,
+      temperature: config.anthropic.temperature ?? DEFAULTS.brain.temperature,
+      max_tool_depth: config.anthropic.max_tool_depth || DEFAULTS.brain.max_tool_depth,
+    };
+    if (config.anthropic.api_key) {
+      config.brain.api_key = config.anthropic.api_key;
+    }
+  }
+  return config;
+}
+
+/**
+ * Interactive provider → model picker.
+ */
+export async function promptProviderSelection(rl) {
+  const providerKeys = Object.keys(PROVIDERS);
+
+  console.log(chalk.bold('\n  Select AI provider:\n'));
+  providerKeys.forEach((key, i) => {
+    console.log(`  ${chalk.cyan(`${i + 1}.`)} ${PROVIDERS[key].name}`);
+  });
+  console.log('');
+
+  let providerIdx;
+  while (true) {
+    const input = await ask(rl, chalk.cyan('  Provider (number): '));
+    providerIdx = parseInt(input.trim(), 10) - 1;
+    if (providerIdx >= 0 && providerIdx < providerKeys.length) break;
+    console.log(chalk.dim('  Invalid choice, try again.'));
+  }
+
+  const providerKey = providerKeys[providerIdx];
+  const provider = PROVIDERS[providerKey];
+
+  console.log(chalk.bold(`\n  Select model for ${provider.name}:\n`));
+  provider.models.forEach((m, i) => {
+    console.log(`  ${chalk.cyan(`${i + 1}.`)} ${m.label} (${m.id})`);
+  });
+  console.log('');
+
+  let modelIdx;
+  while (true) {
+    const input = await ask(rl, chalk.cyan('  Model (number): '));
+    modelIdx = parseInt(input.trim(), 10) - 1;
+    if (modelIdx >= 0 && modelIdx < provider.models.length) break;
+    console.log(chalk.dim('  Invalid choice, try again.'));
+  }
+
+  const model = provider.models[modelIdx];
+  return { providerKey, modelId: model.id };
+}
+
+/**
+ * Save provider and model to config.yaml.
+ */
+export function saveProviderToYaml(providerKey, modelId) {
+  const configDir = getConfigDir();
+  mkdirSync(configDir, { recursive: true });
+  const configPath = join(configDir, 'config.yaml');
+
+  let existing = {};
+  if (existsSync(configPath)) {
+    existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
+  }
+
+  existing.brain = {
+    ...(existing.brain || {}),
+    provider: providerKey,
+    model: modelId,
+  };
+
+  // Remove legacy anthropic section if migrating
+  delete existing.anthropic;
+
+  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
+  return configPath;
+}
+
+/**
+ * Full interactive flow: change brain model + optionally enter API key.
+ */
+export async function changeBrainModel(config, rl) {
+  const { providerKey, modelId } = await promptProviderSelection(rl);
+
+  const providerDef = PROVIDERS[providerKey];
+  const savedPath = saveProviderToYaml(providerKey, modelId);
+  console.log(chalk.dim(`\n  Saved to ${savedPath}`));
+
+  // Update live config
+  config.brain.provider = providerKey;
+  config.brain.model = modelId;
+
+  // Check if we have the API key for this provider
+  const envKey = providerDef.envKey;
+  const currentKey = process.env[envKey];
+  if (!currentKey) {
+    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key (${envKey}): `));
+    if (key.trim()) {
+      saveCredential(config, envKey, key.trim());
+      config.brain.api_key = key.trim();
+      console.log(chalk.dim('  Saved.\n'));
+    }
+  } else {
+    config.brain.api_key = currentKey;
+  }
+
+  return config;
+}
+
 async function promptForMissing(config) {
   const missing = [];
-  if (!config.anthropic.api_key) missing.push('ANTHROPIC_API_KEY');
+  if (!config.brain.api_key) missing.push('brain_api_key');
   if (!config.telegram.bot_token) missing.push('TELEGRAM_BOT_TOKEN');
 
   if (missing.length === 0) return config;
@@ -110,10 +229,19 @@ async function promptForMissing(config) {
     existingEnv = readFileSync(envPath, 'utf-8');
   }
 
-  if (!mutableConfig.anthropic.api_key) {
-    const key = await ask(rl, chalk.cyan('  Anthropic API key: '));
-    mutableConfig.anthropic.api_key = key.trim();
-    envLines.push(`ANTHROPIC_API_KEY=${key.trim()}`);
+  if (!mutableConfig.brain.api_key) {
+    // Run provider selection flow
+    const { providerKey, modelId } = await promptProviderSelection(rl);
+    mutableConfig.brain.provider = providerKey;
+    mutableConfig.brain.model = modelId;
+    saveProviderToYaml(providerKey, modelId);
+
+    const providerDef = PROVIDERS[providerKey];
+    const envKey = providerDef.envKey;
+
+    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key: `));
+    mutableConfig.brain.api_key = key.trim();
+    envLines.push(`${envKey}=${key.trim()}`);
   }
 
   if (!mutableConfig.telegram.bot_token) {
@@ -164,12 +292,21 @@ export function loadConfig() {
     fileConfig = yaml.load(raw) || {};
   }
 
+  // Backward compat: migrate anthropic → brain
+  migrateAnthropicConfig(fileConfig);
+
   const config = deepMerge(DEFAULTS, fileConfig);
 
-  // Overlay env vars for secrets
-  if (process.env.ANTHROPIC_API_KEY) {
-    config.anthropic.api_key = process.env.ANTHROPIC_API_KEY;
+  // Overlay env vars for brain API key based on provider
+  const providerDef = PROVIDERS[config.brain.provider];
+  if (providerDef && process.env[providerDef.envKey]) {
+    config.brain.api_key = process.env[providerDef.envKey];
   }
+  // Legacy fallback: ANTHROPIC_API_KEY for anthropic provider
+  if (config.brain.provider === 'anthropic' && !config.brain.api_key && process.env.ANTHROPIC_API_KEY) {
+    config.brain.api_key = process.env.ANTHROPIC_API_KEY;
+  }
+
   if (process.env.TELEGRAM_BOT_TOKEN) {
     config.telegram.bot_token = process.env.TELEGRAM_BOT_TOKEN;
   }
@@ -221,7 +358,16 @@ export function saveCredential(config, envKey, value) {
       config.github.token = value;
       break;
     case 'ANTHROPIC_API_KEY':
-      config.anthropic.api_key = value;
+      if (config.brain.provider === 'anthropic') config.brain.api_key = value;
+      break;
+    case 'OPENAI_API_KEY':
+      if (config.brain.provider === 'openai') config.brain.api_key = value;
+      break;
+    case 'GOOGLE_API_KEY':
+      if (config.brain.provider === 'google') config.brain.api_key = value;
+      break;
+    case 'GROQ_API_KEY':
+      if (config.brain.provider === 'groq') config.brain.api_key = value;
       break;
     case 'TELEGRAM_BOT_TOKEN':
       config.telegram.bot_token = value;