gigaclaw 1.4.0 → 1.6.0

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-# Giga Bot
+# GigaClaw
 
 ### Autonomous AI Agent Platform — Powered by Gignaati
 
@@ -18,16 +18,16 @@ India-first. Edge-native. Zero vendor lock-in.
 
 ---
 
-## What is Giga Bot?
+## What is GigaClaw?
 
-Giga Bot is a self-hosted, autonomous AI agent platform. You deploy it to your own server or VPS, and it runs 24/7 — responding to messages, executing scheduled jobs, handling webhooks, writing code, managing files, and completing complex multi-step tasks.
+GigaClaw is a self-hosted, autonomous AI agent platform. You deploy it to your own server or VPS, and it runs 24/7 — responding to messages, executing scheduled jobs, handling webhooks, writing code, managing files, and completing complex multi-step tasks.
 
 It is built on a two-layer architecture:
 
 - **Event Handler** — A Next.js server that handles real-time chat (web UI + Telegram), manages your agent's configuration, and creates jobs for the agent to execute.
 - **Agent Engine** — A Docker container that runs your agent jobs using GitHub Actions or a local Docker daemon. The agent can write code, run shell commands, browse the web, and interact with GitHub.
 
-Giga Bot is the only autonomous agent platform with **native PragatiGPT support** — India's indigenous Small Language Model for edge deployment, delivering 100% data privacy and zero foreign cloud dependency.
+GigaClaw is the only autonomous agent platform with **native PragatiGPT support** — India's indigenous Small Language Model for edge deployment, delivering 100% data privacy and zero foreign cloud dependency.
 
 ---
 
@@ -45,7 +45,7 @@ irm https://raw.githubusercontent.com/gignaati/gigaclaw/main/install.ps1 | iex
 
 ### All Platforms (npm / npx)
 ```bash
-# Create a new Giga Bot project
+# Create a new GigaClaw project
 mkdir my-gigaclaw && cd my-gigaclaw
 npx gigaclaw@latest init
 
@@ -61,7 +61,7 @@ npm run setup
 
 **Step 1 — Create a new GitHub repository** for your agent (e.g., `my-gigaclaw`).
 
-**Step 2 — Install Giga Bot** into a local folder with the same name:
+**Step 2 — Install GigaClaw** into a local folder with the same name:
 ```bash
 mkdir my-gigaclaw && cd my-gigaclaw
 npx gigaclaw@latest init
@@ -72,10 +72,10 @@ npm install
 ```bash
 npm run setup
 ```
-The wizard will ask for:
-- Your GitHub Personal Access Token
-- Your public URL (domain or ngrok URL)
-- Your LLM provider and API key (Claude, GPT, Gemini, PragatiGPT, or Ollama)
+The wizard will ask for your setup mode:
+- **Hybrid** (recommended) — Cloud + Local AI with smart routing
+- **Cloud** — GitHub + ngrok + Telegram, full features
+- **Local** — Ollama only, 100% offline
 
 **Step 4 — Start your agent:**
 ```bash
@@ -88,7 +88,7 @@ docker compose up -d
 
 ## Supported LLM Providers
 
-Giga Bot supports **6 LLM providers** — more than any other self-hosted agent platform:
+GigaClaw supports **6 LLM providers** — more than any other self-hosted agent platform:
 
 | Provider | Description | Data Privacy |
 |---|---|---|
@@ -135,7 +135,8 @@ LLM_PROVIDER=custom       # Any OpenAI-compatible API
 - **Auto-merge** — Agent can merge its own PRs after review
 - **Hot reload** — Push to `main` triggers automatic rebuild and restart
 
-### Giga Bot Exclusive Features
+### GigaClaw Exclusive Features
+- **Hybrid Mode** — Cloud + Local AI with smart per-task routing (v1.6.0)
 - **PragatiGPT** — India's indigenous SLM for edge deployment
 - **Ollama** — Run any open-source model with zero cloud dependency
 - **Multi-LLM routing** — Different LLMs for chat vs. agent jobs
@@ -143,6 +144,42 @@ LLM_PROVIDER=custom       # Any OpenAI-compatible API
 
 ---
 
+## Hybrid Mode (New in v1.6.0)
+
+Run both cloud and local LLMs simultaneously. GigaClaw automatically routes each task to the best provider.
+
+```bash
+npm run setup   # Choose "Hybrid Mode" (recommended)
+```
+
+### Routing Strategies
+
+| Strategy | Best for |
+|----------|----------|
+| **Auto** | Smart routing — complex tasks go to cloud, simple ones stay local |
+| **Cost-Optimized** | Minimize API costs — local by default, cloud only when needed |
+| **Quality-First** | Best output quality — cloud by default, local for drafts |
+| **Privacy-First** | Maximum data privacy — local by default, cloud only for complex tasks |
+
+### How it works
+
+1. Setup configures a **cloud provider** (Claude, GPT, Gemini, PragatiGPT) and a **local provider** (Ollama)
+2. Each message is scored for complexity and privacy sensitivity
+3. The task router picks the optimal provider based on your chosen strategy
+4. Ollama availability is auto-detected at runtime — no reconfiguration needed
+
+```bash
+# Example .env for hybrid mode
+GIGACLAW_MODE=hybrid
+LLM_PROVIDER=anthropic           # Cloud (primary)
+LLM_MODEL=claude-sonnet-4-6
+LOCAL_LLM_PROVIDER=ollama         # Local (secondary)
+LOCAL_LLM_MODEL=llama3.2
+HYBRID_ROUTING=auto               # auto | cost-optimized | quality-first | privacy-first
+```
+
+---
+
 ## CLI Commands
 
 ```bash
@@ -162,7 +199,7 @@ npx gigaclaw set-var <KEY> [VALUE]            # Set GitHub repository variable
 
 ## Configuration Files
 
-These files in `config/` define your agent's personality and behavior. They are **yours to customize** — Giga Bot will never overwrite them:
+These files in `config/` define your agent's personality and behavior. They are **yours to customize** — GigaClaw will never overwrite them:
 
 | File | Purpose |
 |---|---|
@@ -187,7 +224,7 @@ npx gigaclaw upgrade 1.2.72   # Specific version
 
 ## Deployment
 
-Giga Bot runs on any Linux server with Docker. Recommended:
+GigaClaw runs on any Linux server with Docker. Recommended:
 
 | Provider | Spec | Monthly Cost |
 |---|---|---|

package/api/index.js

@@ -7,6 +7,7 @@ import { chat, summarizeJob } from '../lib/ai/index.js';
 import { createNotification } from '../lib/db/notifications.js';
 import { loadTriggers } from '../lib/triggers.js';
 import { verifyApiKey } from '../lib/db/api-keys.js';
+import { logAction } from '../lib/db/audit-log.js';
 
 // Bot token from env, can be overridden by /telegram/register
 let telegramBotToken = null;
@@ -88,6 +89,18 @@ async function handleWebhook(request) {
 
   try {
     const result = await createJob(job);
+    // Audit log: record job creation via webhook
+    logAction({
+      actionType: 'job_create',
+      actor: 'api:webhook',
+      target: `job:${result.job_id || 'unknown'}`,
+      summary: `Job created via webhook — ${String(job).slice(0, 80)}`,
+      metadata: {
+        job_id: result.job_id,
+        title: result.title,
+        source: 'webhook',
+      },
+    });
     return Response.json(result);
   } catch (err) {
     console.error(err);

package/bin/cli.js

@@ -25,6 +25,9 @@ if (command === '--version' || command === '-v') {
 const MANAGED_PATHS = [
   '.github/workflows/',
   'docker/event-handler/',
+  'docker/claude-code-job/',
+  'docker/claude-code-workspace/',
+  'docker/pi-coding-agent-job/',
   'docker-compose.yml',
   'docker-compose.local.yml',
   '.dockerignore',
@@ -136,7 +139,7 @@ async function init() {
         if (deps.gigaclaw || devDeps.gigaclaw) {
           isExistingProject = true;
         }
-      } catch {}
+      } catch (e) { console.warn('  Warning: could not parse existing package.json:', e.message); }
     }
 
     if (!isExistingProject) {
@@ -339,7 +342,7 @@ GIGACLAW_VERSION=${version}
       }
       fs.writeFileSync(envPath, envContent);
       console.log(`  Updated GIGACLAW_VERSION to ${version}`);
-    } catch {}
+    } catch (e) { console.warn('  Warning: could not update GIGACLAW_VERSION in .env:', e.message); }
   }
 
   console.log('\nDone! Run: npm run setup\n');
@@ -438,7 +441,7 @@ function diff(filePath) {
 
   try {
     // Use git diff for nice colored output, fall back to plain diff
-    execSync(`git diff --no-index -- "${dest}" "${src}"`, { stdio: 'inherit', shell: true });
+    execFileSync('git', ['diff', '--no-index', '--', dest, src], { stdio: 'inherit' });
     console.log('\nFiles are identical.\n');
   } catch (e) {
     // git diff exits with 1 when files differ (output already printed)
@@ -470,7 +473,8 @@ function setup() {
   const setupScript = path.join(__dirname, '..', 'setup', 'setup.mjs');
   try {
     execFileSync(process.execPath, [setupScript], { stdio: 'inherit', cwd: process.cwd() });
-  } catch {
+  } catch (e) {
+    console.error(e.message);
     process.exit(1);
   }
 }
@@ -479,7 +483,8 @@ function setupTelegram() {
   const setupScript = path.join(__dirname, '..', 'setup', 'setup-telegram.mjs');
   try {
     execFileSync(process.execPath, [setupScript], { stdio: 'inherit', cwd: process.cwd() });
-  } catch {
+  } catch (e) {
+    console.error(e.message);
     process.exit(1);
   }
 }
@@ -505,6 +510,13 @@ async function resetAuth() {
 async function upgrade() {
   const cwd = process.cwd();
   const tag = parseUpgradeTarget(args[0]);
+
+  // Validate tag to prevent shell injection
+  if (!/^[a-zA-Z0-9._-]+$/.test(tag)) {
+    console.error(`\n  Invalid version or tag: ${args[0]}\n`);
+    process.exit(1);
+  }
+
   const { confirm, isCancel } = await import('@clack/prompts');
 
   // --- Pre-flight: verify this is a gigaclaw project ---
@@ -553,7 +565,7 @@ async function upgrade() {
       execSync('git add -A && git commit -m "save local changes before gigaclaw upgrade"', { stdio: 'inherit', cwd, shell: true });
     } catch {
       console.error('\n  Could not save your local changes. Please try again.\n');
-      return;
+      process.exit(1);
     }
   }
 
@@ -569,7 +581,7 @@ async function upgrade() {
     console.error('    2. Edit each file to keep the version you want');
     console.error('    3. Run: git add -A && git rebase --continue');
     console.error('    4. Then run the upgrade again\n');
-    return;
+    process.exit(1);
   }
 
   // --- Install ---

package/drizzle/0004_trust_ledger_audit_log.sql

@@ -0,0 +1,15 @@
+CREATE TABLE `audit_log` (
+	`id` text PRIMARY KEY NOT NULL,
+	`timestamp` integer NOT NULL,
+	`action_type` text NOT NULL,
+	`actor` text NOT NULL,
+	`target` text NOT NULL,
+	`summary` text NOT NULL,
+	`metadata` text NOT NULL DEFAULT '{}',
+	`prev_hash` text NOT NULL,
+	`entry_hash` text NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `audit_log_timestamp_idx` ON `audit_log` (`timestamp`);
+--> statement-breakpoint
+CREATE INDEX `audit_log_action_type_idx` ON `audit_log` (`action_type`);

package/drizzle/meta/_journal.json

@@ -29,6 +29,13 @@
       "when": 1772486536207,
       "tag": "0003_rename_code_workspaces",
       "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1742500800000,
+      "tag": "0004_trust_ledger_audit_log",
+      "breakpoints": true
     }
   ]
-}
+}

package/lib/ai/agent.js

@@ -7,16 +7,33 @@ import { jobPlanningMd, codePlanningMd, gigaclawDb } from '../paths.js';
 import { render_md } from '../utils/render-md.js';
 import { createWebSearchTool, getProvider } from './web-search.js';
 
-let _agent = null;
+/** Cache agents by provider:model key so each combo is created once */
+const _agentCache = new Map();
 
 /**
- * Get or create the LangGraph job agent singleton.
- * Uses createReactAgent which handles the tool loop automatically.
- * Prompt is a function so {{datetime}} resolves fresh each invocation.
+ * Build a cache key from provider overrides (falls back to env defaults).
  */
-export async function getJobAgent() {
-  if (!_agent) {
-    const model = await createModel();
+function agentCacheKey(options = {}) {
+  const p = options.providerOverride || process.env.LLM_PROVIDER || 'anthropic';
+  const m = options.modelOverride || process.env.LLM_MODEL || 'default';
+  return `${p}:${m}`;
+}
+
+/**
+ * Get or create a LangGraph job agent.
+ * Supports per-request provider/model overrides for hybrid mode.
+ * Agents are cached by provider:model key.
+ *
+ * @param {object} [options]
+ * @param {string} [options.providerOverride] - LLM provider override
+ * @param {string} [options.modelOverride] - LLM model override
+ * @returns {Promise<object>} LangGraph agent
+ */
+export async function getJobAgent(options = {}) {
+  const key = agentCacheKey(options);
+
+  if (!_agentCache.has(key)) {
+    const model = await createModel(options);
     const tools = [createJobTool, getJobStatusTool, getSystemTechnicalSpecsTool, getSkillBuildingGuideTool, getSkillDetailsTool];
 
     const webSearchTool = await createWebSearchTool();
@@ -27,21 +44,23 @@ export async function getJobAgent() {
 
     const checkpointer = SqliteSaver.fromConnString(gigaclawDb);
 
-    _agent = createReactAgent({
+    const agent = createReactAgent({
       llm: model,
       tools,
       checkpointSaver: checkpointer,
       prompt: (state) => [new SystemMessage(render_md(jobPlanningMd)), ...state.messages],
     });
+
+    _agentCache.set(key, agent);
   }
-  return _agent;
+  return _agentCache.get(key);
 }
 
 /**
- * Reset the agent singleton (e.g., when config changes).
+ * Reset all cached agents (e.g., when config changes).
  */
 export function resetAgent() {
-  _agent = null;
+  _agentCache.clear();
 }
 
 const _codeAgents = new Map();
@@ -49,19 +68,24 @@ const _codeAgents = new Map();
 /**
  * Get or create a code agent for a specific chat/workspace.
  * Each code chat gets its own agent with unique start_coding tool bindings.
+ * Supports per-request provider/model overrides for hybrid mode.
+ *
  * @param {object} context
  * @param {string} context.repo - GitHub repo
  * @param {string} context.branch - Git branch
  * @param {string} context.workspaceId - Pre-created workspace row ID
  * @param {string} context.chatId - Chat thread ID
+ * @param {string} [context.providerOverride] - LLM provider override
+ * @param {string} [context.modelOverride] - LLM model override
  * @returns {Promise<object>} LangGraph agent
  */
-export async function getCodeAgent({ repo, branch, workspaceId, chatId }) {
-  if (_codeAgents.has(chatId)) {
-    return _codeAgents.get(chatId);
+export async function getCodeAgent({ repo, branch, workspaceId, chatId, providerOverride, modelOverride }) {
+  const cacheKey = `${chatId}:${providerOverride || 'default'}:${modelOverride || 'default'}`;
+  if (_codeAgents.has(cacheKey)) {
+    return _codeAgents.get(cacheKey);
   }
 
-  const model = await createModel();
+  const model = await createModel({ providerOverride, modelOverride });
   const startCodingTool = createStartCodingTool({ repo, branch, workspaceId });
   const getRepoDetailsTool = createGetRepositoryDetailsTool({ repo, branch });
   const tools = [startCodingTool, getRepoDetailsTool];
@@ -81,6 +105,6 @@ export async function getCodeAgent({ repo, branch, workspaceId, chatId }) {
     prompt: (state) => [new SystemMessage(render_md(codePlanningMd)), ...state.messages],
   });
 
-  _codeAgents.set(chatId, agent);
+  _codeAgents.set(cacheKey, agent);
   return agent;
 }

package/lib/ai/index.js

@@ -2,9 +2,23 @@ import { HumanMessage, AIMessage } from '@langchain/core/messages';
 import { z } from 'zod';
 import { getJobAgent, getCodeAgent } from './agent.js';
 import { createModel } from './model.js';
+import { routeTask } from './task-router.js';
 import { jobSummaryMd } from '../paths.js';
 import { render_md } from '../utils/render-md.js';
 import { getChatById, createChat, saveMessage, updateChatTitle, linkChatToWorkspace } from '../db/chats.js';
+import { logAction } from '../db/audit-log.js';
+
+/** Providers that run 100% locally — no data leaves the machine */
+const LOCAL_PROVIDERS = new Set(['ollama', 'pragatigpt']);
+
+/**
+ * Estimate token count from text length (rough approximation: 1 token ≈ 4 chars).
+ * Used when the LLM response does not include usage metadata.
+ */
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
 
 /**
  * Ensure a chat exists in the DB and save a message.
@@ -38,7 +52,17 @@ function persistMessage(threadId, role, text, options = {}) {
  * @returns {Promise<string>} AI response text
  */
 async function chat(threadId, message, attachments = [], options = {}) {
-  const agent = await getJobAgent();
+  // Hybrid routing: resolve provider/model if not explicitly set
+  if (!options.llmProvider && process.env.GIGACLAW_MODE === 'hybrid') {
+    const route = await routeTask(message, { explicitProvider: options.llmProvider });
+    options.llmProvider = route.provider;
+    options.llmModel = route.model;
+    console.log(`[hybrid] chat routed to ${route.provider}:${route.model} — ${route.reason}`);
+  }
+  const agentOptions = {};
+  if (options.llmProvider) agentOptions.providerOverride = options.llmProvider;
+  if (options.llmModel) agentOptions.modelOverride = options.llmModel;
+  const agent = await getJobAgent(agentOptions);
 
   // Save user message to DB
   persistMessage(threadId, 'user', message || '[attachment]', options);
@@ -88,6 +112,26 @@ async function chat(threadId, message, attachments = [], options = {}) {
   // Save assistant response to DB
   persistMessage(threadId, 'assistant', response, options);
 
+  // Audit log: record this LLM call
+  const provider = options.llmProvider || process.env.LLM_PROVIDER || 'anthropic';
+  const tokensIn = estimateTokens(message);
+  const tokensOut = estimateTokens(response);
+  logAction({
+    actionType: 'llm_call',
+    actor: options.userId ? `user:${options.userId}` : 'user:unknown',
+    target: `provider:${provider}`,
+    summary: `Chat message — ${tokensIn} tokens in, ${tokensOut} tokens out via ${provider}`,
+    metadata: {
+      provider,
+      model: options.llmModel || process.env.LLM_MODEL || 'default',
+      tokens_in: tokensIn,
+      tokens_out: tokensOut,
+      is_local: LOCAL_PROVIDERS.has(provider),
+      thread_id: threadId,
+      call_type: 'chat',
+    },
+  });
+
   // Auto-generate title for new chats
   if (options.userId && message) {
     autoTitle(threadId, message).catch(() => {});
@@ -107,6 +151,14 @@ async function chat(threadId, message, attachments = [], options = {}) {
  * @returns {AsyncIterableIterator<string>} Stream of text chunks
  */
 async function* chatStream(threadId, message, attachments = [], options = {}) {
+  // Hybrid routing: resolve provider/model if not explicitly set
+  if (!options.llmProvider && process.env.GIGACLAW_MODE === 'hybrid') {
+    const route = await routeTask(message, { explicitProvider: options.llmProvider });
+    options.llmProvider = route.provider;
+    options.llmModel = route.model;
+    console.log(`[hybrid] chatStream routed to ${route.provider}:${route.model} — ${route.reason}`);
+  }
+
   let agent;
 
   // Code mode: set up workspace + code agent
@@ -133,9 +185,14 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
       branch: options.branch,
       workspaceId,
       chatId: threadId,
+      providerOverride: options.llmProvider,
+      modelOverride: options.llmModel,
     });
   } else {
-    agent = await getJobAgent();
+    const agentOpts = {};
+    if (options.llmProvider) agentOpts.providerOverride = options.llmProvider;
+    if (options.llmModel) agentOpts.modelOverride = options.llmModel;
+    agent = await getJobAgent(agentOpts);
   }
 
   // Save user message to DB (skip on regeneration — message already exists)
@@ -235,6 +292,28 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
       persistMessage(threadId, 'assistant', fullText, options);
     }
 
+    // Audit log: record this streaming LLM call
+    if (fullText) {
+      const streamProvider = options.llmProvider || process.env.LLM_PROVIDER || 'anthropic';
+      const streamTokensIn = estimateTokens(message);
+      const streamTokensOut = estimateTokens(fullText);
+      logAction({
+        actionType: 'llm_call',
+        actor: options.userId ? `user:${options.userId}` : 'user:unknown',
+        target: `provider:${streamProvider}`,
+        summary: `Chat stream — ${streamTokensIn} tokens in, ${streamTokensOut} tokens out via ${streamProvider}`,
+        metadata: {
+          provider: streamProvider,
+          model: options.llmModel || process.env.LLM_MODEL || 'default',
+          tokens_in: streamTokensIn,
+          tokens_out: streamTokensOut,
+          is_local: LOCAL_PROVIDERS.has(streamProvider),
+          thread_id: threadId,
+          call_type: 'chat_stream',
+        },
+      });
+    }
+
     // Auto-generate title for new chats
     if (options.userId && message) {
       autoTitle(threadId, message).catch(() => {});
@@ -276,6 +355,7 @@ async function autoTitle(threadId, firstMessage) {
  */
 async function summarizeJob(results) {
   try {
+    const provider = process.env.LLM_PROVIDER || 'anthropic';
     const model = await createModel({ maxTokens: 1024 });
     const systemPrompt = render_md(jobSummaryMd);
 
@@ -313,6 +393,24 @@ async function summarizeJob(results) {
 
     console.log(`[summarizeJob] Result: ${text.length} chars — ${text.slice(0, 200)}`);
 
+    // Audit log: record this LLM call
+    const tokensIn = estimateTokens(systemPrompt) + estimateTokens(userMessage);
+    const tokensOut = estimateTokens(text);
+    logAction({
+      actionType: 'llm_call',
+      actor: 'agent:job-summary',
+      target: `provider:${provider}`,
+      summary: `Job summary — ${tokensIn} tokens in, ${tokensOut} tokens out via ${provider}`,
+      metadata: {
+        provider,
+        model: process.env.LLM_MODEL || 'default',
+        tokens_in: tokensIn,
+        tokens_out: tokensOut,
+        is_local: LOCAL_PROVIDERS.has(provider),
+        call_type: 'job_summary',
+      },
+    });
+
     return text.trim() || 'Job finished.';
   } catch (err) {
     console.error('[summarizeJob] Failed to summarize job:', err);

package/lib/ai/provider-health.js

@@ -0,0 +1,96 @@
+/**
+ * Provider health checking for hybrid mode.
+ * Detects whether local (Ollama) and cloud providers are available at runtime.
+ */
+
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+
+/** Cache health check results for a short TTL to avoid hammering endpoints */
+const _cache = new Map();
+const CACHE_TTL_MS = 30_000; // 30 seconds
+
+/**
+ * Check if Ollama is running and reachable.
+ * @returns {Promise<{ available: boolean, models?: string[], error?: string }>}
+ */
+export async function checkOllamaHealth() {
+  const cached = _cache.get('ollama');
+  if (cached && Date.now() - cached.ts < CACHE_TTL_MS) return cached.result;
+
+  try {
+    const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) {
+      const result = { available: false, error: `Ollama returned ${res.status}` };
+      _cache.set('ollama', { ts: Date.now(), result });
+      return result;
+    }
+    const data = await res.json();
+    const models = (data.models || []).map((m) => m.name);
+    const result = { available: true, models };
+    _cache.set('ollama', { ts: Date.now(), result });
+    return result;
+  } catch (err) {
+    const result = { available: false, error: err.message };
+    _cache.set('ollama', { ts: Date.now(), result });
+    return result;
+  }
+}
+
+/**
+ * Check if a cloud provider's API key is configured.
+ * Does NOT make a network call — just checks env vars.
+ * @param {string} provider - Provider name (anthropic, openai, google, pragatigpt, custom)
+ * @returns {{ available: boolean, error?: string }}
+ */
+export function checkCloudProviderConfig(provider) {
+  const keyMap = {
+    anthropic: 'ANTHROPIC_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    google: 'GOOGLE_API_KEY',
+    pragatigpt: 'PRAGATIGPT_API_KEY',
+    custom: 'CUSTOM_API_KEY',
+  };
+
+  if (provider === 'ollama') {
+    return { available: true }; // Ollama doesn't need an API key
+  }
+
+  const envKey = keyMap[provider];
+  if (!envKey) return { available: false, error: `Unknown provider: ${provider}` };
+
+  return process.env[envKey]
+    ? { available: true }
+    : { available: false, error: `${envKey} is not set` };
+}
+
+/**
+ * Get the availability status of all configured providers.
+ * @returns {Promise<Record<string, { available: boolean, type: 'local'|'cloud', error?: string }>>}
+ */
+export async function getAllProviderStatus() {
+  const LOCAL_PROVIDERS = new Set(['ollama', 'pragatigpt']);
+  const providers = ['anthropic', 'openai', 'google', 'pragatigpt', 'ollama', 'custom'];
+  const status = {};
+
+  for (const p of providers) {
+    const type = LOCAL_PROVIDERS.has(p) ? 'local' : 'cloud';
+    if (p === 'ollama') {
+      const health = await checkOllamaHealth();
+      status[p] = { ...health, type };
+    } else {
+      const config = checkCloudProviderConfig(p);
+      status[p] = { ...config, type };
+    }
+  }
+
+  return status;
+}
+
+/**
+ * Clear the health check cache (e.g., after config changes).
+ */
+export function clearHealthCache() {
+  _cache.clear();
+}