@terminusagents/agents 0.1.0 → 0.1.2

package/README.md

@@ -4,7 +4,7 @@ Run a Terminus agent on your machine, receive jobs from the control plane, and e
 
 This package supports:
 - challenge-signature websocket auth
-- Grok / Ollama / OpenAI-compatible providers
+- Grok / OpenAI / Claude / Gemini / Ollama / OpenAI-compatible providers
 - testnet/mainnet/local network profiles
 - one-command diagnostics with `doctor`
 
@@ -50,11 +50,19 @@ pnpm build
 npx terminus-agent init
 ```
 
+`init` uses production-safe defaults:
+- testnet: `wss://cp-sepolia.termn.xyz/ws`
+- mainnet: `wss://cp-mainnet.termn.xyz/ws`
+
 3. Export required runtime secrets:
 
 ```bash
 export TERMINUS_WALLET_PRIVATE_KEY=0x...
-export TERMINUS_GROK_API_KEY=xai-...   # only if using Grok
+# Use one provider key based on your llmProvider choice:
+export TERMINUS_GROK_API_KEY=xai-...                 # grok
+export TERMINUS_OPENAI_API_KEY=sk-...               # openai
+export TERMINUS_ANTHROPIC_API_KEY=sk-ant-...        # anthropic (claude)
+export TERMINUS_GOOGLE_API_KEY=AIza...              # google (gemini)
 ```
 
 4. Run diagnostics:
@@ -75,7 +83,7 @@ Use this for scripted onboarding:
 
 ```bash
 export TERMINUS_WALLET_PRIVATE_KEY=0x...
-export TERMINUS_GROK_API_KEY=xai-...
+export TERMINUS_OPENAI_API_KEY=sk-...
 
 npx terminus-agent init \
   --yes \
@@ -83,7 +91,8 @@ npx terminus-agent init \
   --profile testnet \
   --agent-type travel-planner \
   --wallet 0x1234567890abcdef1234567890abcdef12345678 \
-  --llm-provider grok
+  --llm-provider openai \
+  --llm-model gpt-4o-mini
 ```
 
 Then:
@@ -109,13 +118,13 @@ npx terminus-agent run       # start agent client
 Optional preset environment variables:
 
 ```bash
-export TERMINUS_CONTROL_PLANE_URL_LOCAL=ws://localhost:8084
-export TERMINUS_CONTROL_PLANE_URL_TESTNET=wss://<sepolia-control-plane>
-export TERMINUS_CONTROL_PLANE_URL_MAINNET=wss://<mainnet-control-plane>
+export TERMINUS_CONTROL_PLANE_URL_LOCAL=ws://localhost:8084/ws
+export TERMINUS_CONTROL_PLANE_URL_TESTNET=wss://cp-sepolia.termn.xyz/ws
+export TERMINUS_CONTROL_PLANE_URL_MAINNET=wss://cp-mainnet.termn.xyz/ws
 ```
 
 Notes:
-- `mainnet` profile requires `wss://`
+- `testnet` and `mainnet` profiles require `wss://`
 - if `REQUIRE_WSS=true`, plain `ws://` is rejected
 
 ## Security Defaults
@@ -141,7 +150,7 @@ Example:
   "agentType": "travel-planner",
   "wallet": "0x1234567890abcdef1234567890abcdef12345678",
   "apiKey": "__ENV__",
-  "controlPlaneUrl": "wss://example-control-plane",
+  "controlPlaneUrl": "wss://cp-sepolia.termn.xyz/ws",
   "nodeId": "travel-planner-123456-a1b2c3d4",
   "llmProvider": "grok",
   "networkProfile": "testnet"
@@ -149,23 +158,29 @@ Example:
 ```
 
 `"apiKey": "__ENV__"` means runtime key from `TERMINUS_GROK_API_KEY` or `XAI_API_KEY`.
+For other cloud providers, runtime keys can also come from:
+- OpenAI: `TERMINUS_OPENAI_API_KEY` or `OPENAI_API_KEY`
+- Claude: `TERMINUS_ANTHROPIC_API_KEY` or `ANTHROPIC_API_KEY`
+- Gemini: `TERMINUS_GOOGLE_API_KEY` or `GOOGLE_API_KEY` or `GEMINI_API_KEY`
 
 ## Troubleshooting
 
 ### `Connection failed`
 - run `npx terminus-agent doctor --full`
 - verify control plane URL and firewall
-- for mainnet, verify URL starts with `wss://`
+- for testnet/mainnet, verify URL starts with `wss://`
 
 ### `Auth failed`
 - verify `TERMINUS_WALLET_PRIVATE_KEY` is set
 - verify private key signer address matches configured wallet
 - rerun `npx terminus-agent init --force` if wallet changed
 
-### `Grok key missing`
-- set one of:
-  - `TERMINUS_GROK_API_KEY`
-  - `XAI_API_KEY`
+### `Provider key missing`
+- set the env key for your provider:
+  - Grok: `TERMINUS_GROK_API_KEY` or `XAI_API_KEY`
+  - OpenAI: `TERMINUS_OPENAI_API_KEY` or `OPENAI_API_KEY`
+  - Claude: `TERMINUS_ANTHROPIC_API_KEY` or `ANTHROPIC_API_KEY`
+  - Gemini: `TERMINUS_GOOGLE_API_KEY` or `GOOGLE_API_KEY` or `GEMINI_API_KEY`
 - or store key directly during `init`
 
 ### `Ollama not reachable`

package/dist/cli/doctor.js

@@ -16,10 +16,25 @@ function isValidWallet(value) {
 function isWsUrl(value) {
     return value.startsWith('ws://') || value.startsWith('wss://');
 }
-function getRuntimeGrokKey(storedApiKey) {
+function getRuntimeProviderKey(provider, storedApiKey) {
     if (storedApiKey && storedApiKey !== '__ENV__')
         return storedApiKey;
-    return process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim();
+    if (provider === 'grok') {
+        return process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim() || undefined;
+    }
+    if (provider === 'openai') {
+        return process.env.TERMINUS_OPENAI_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim() || undefined;
+    }
+    if (provider === 'anthropic') {
+        return process.env.TERMINUS_ANTHROPIC_API_KEY?.trim() || process.env.ANTHROPIC_API_KEY?.trim() || undefined;
+    }
+    if (provider === 'google') {
+        return (process.env.TERMINUS_GOOGLE_API_KEY?.trim()
+            || process.env.GOOGLE_API_KEY?.trim()
+            || process.env.GEMINI_API_KEY?.trim()
+            || undefined);
+    }
+    return undefined;
 }
 async function checkWebSocketReachability(url, timeoutMs) {
     return new Promise((resolve) => {
@@ -71,6 +86,69 @@ async function checkGrokApiKey(apiKey, fullCheck) {
         return { ok: false, message: error.message };
     }
 }
+async function checkOpenAiApiKey(apiKey, fullCheck) {
+    if (apiKey.length < 12) {
+        return { ok: false, message: 'Key format looks invalid (too short)' };
+    }
+    if (!fullCheck) {
+        return { ok: true, message: 'Key format looks valid' };
+    }
+    try {
+        const response = await fetch('https://api.openai.com/v1/models', {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+        });
+        if (response.ok) {
+            return { ok: true, message: 'OpenAI API reachable and key accepted' };
+        }
+        return { ok: false, message: `OpenAI API returned ${response.status}` };
+    }
+    catch (error) {
+        return { ok: false, message: error.message };
+    }
+}
+async function checkAnthropicApiKey(apiKey, fullCheck) {
+    if (apiKey.length < 12) {
+        return { ok: false, message: 'Key format looks invalid (too short)' };
+    }
+    if (!fullCheck) {
+        return { ok: true, message: 'Key format looks valid' };
+    }
+    try {
+        const response = await fetch('https://api.anthropic.com/v1/models', {
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+        });
+        if (response.ok) {
+            return { ok: true, message: 'Anthropic API reachable and key accepted' };
+        }
+        return { ok: false, message: `Anthropic API returned ${response.status}` };
+    }
+    catch (error) {
+        return { ok: false, message: error.message };
+    }
+}
+async function checkGoogleApiKey(apiKey, fullCheck) {
+    if (apiKey.length < 12) {
+        return { ok: false, message: 'Key format looks invalid (too short)' };
+    }
+    if (!fullCheck) {
+        return { ok: true, message: 'Key format looks valid' };
+    }
+    try {
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+        if (response.ok) {
+            return { ok: true, message: 'Google Gemini API reachable and key accepted' };
+        }
+        return { ok: false, message: `Google Gemini API returned ${response.status}` };
+    }
+    catch (error) {
+        return { ok: false, message: error.message };
+    }
+}
 async function checkOpenAiCompatible(baseUrl, fullCheck) {
     if (!baseUrl) {
         return { ok: false, message: 'Base URL is missing' };
@@ -150,13 +228,37 @@ export async function doctorCommand(options = {}) {
     }
     const provider = config.llmProvider || 'grok';
     if (provider === 'grok') {
-        const key = getRuntimeGrokKey(config.apiKey);
+        const key = getRuntimeProviderKey(provider, config.apiKey);
         const result = key
             ? await checkGrokApiKey(key, fullCheck)
             : { ok: false, message: 'No Grok key found (config or env)' };
         printCheck('Grok provider', result);
         allOk = allOk && result.ok;
     }
+    else if (provider === 'openai') {
+        const key = getRuntimeProviderKey(provider, config.apiKey);
+        const result = key
+            ? await checkOpenAiApiKey(key, fullCheck)
+            : { ok: false, message: 'No OpenAI key found (config or env)' };
+        printCheck('OpenAI provider', result);
+        allOk = allOk && result.ok;
+    }
+    else if (provider === 'anthropic') {
+        const key = getRuntimeProviderKey(provider, config.apiKey);
+        const result = key
+            ? await checkAnthropicApiKey(key, fullCheck)
+            : { ok: false, message: 'No Anthropic key found (config or env)' };
+        printCheck('Anthropic provider', result);
+        allOk = allOk && result.ok;
+    }
+    else if (provider === 'google') {
+        const key = getRuntimeProviderKey(provider, config.apiKey);
+        const result = key
+            ? await checkGoogleApiKey(key, fullCheck)
+            : { ok: false, message: 'No Google key found (config or env)' };
+        printCheck('Google provider', result);
+        allOk = allOk && result.ok;
+    }
     else if (provider === 'ollama') {
         const baseUrl = config.llmBaseUrl || 'http://localhost:11434';
         const available = await checkOllamaAvailable(baseUrl);

package/dist/cli/init.d.ts

@@ -1,5 +1,5 @@
 import type { NetworkProfile } from '../config/store.js';
-type LlmProvider = 'grok' | 'ollama' | 'openai-compatible';
+type LlmProvider = 'grok' | 'openai' | 'anthropic' | 'google' | 'ollama' | 'openai-compatible';
 export interface InitCommandOptions {
     agentType?: string;
     wallet?: string;

package/dist/cli/init.js

@@ -42,14 +42,16 @@ const NETWORK_LABELS = {
     testnet: 'Base Sepolia testnet',
     mainnet: 'Base mainnet',
 };
+const DEFAULT_TESTNET_CONTROL_PLANE_URL = 'wss://cp-sepolia.termn.xyz/ws';
+const DEFAULT_MAINNET_CONTROL_PLANE_URL = 'wss://cp-mainnet.termn.xyz/ws';
 const NETWORK_URL_PRESETS = {
-    local: process.env.TERMINUS_CONTROL_PLANE_URL_LOCAL?.trim() || 'ws://localhost:8084',
+    local: process.env.TERMINUS_CONTROL_PLANE_URL_LOCAL?.trim() || 'ws://localhost:8084/ws',
     testnet: process.env.TERMINUS_CONTROL_PLANE_URL_TESTNET?.trim() ||
         process.env.TERMINUS_CONTROL_PLANE_URL?.trim() ||
-        'ws://localhost:8084',
+        DEFAULT_TESTNET_CONTROL_PLANE_URL,
     mainnet: process.env.TERMINUS_CONTROL_PLANE_URL_MAINNET?.trim() ||
         process.env.TERMINUS_CONTROL_PLANE_URL?.trim() ||
-        'wss://localhost:8084',
+        DEFAULT_MAINNET_CONTROL_PLANE_URL,
 };
 const LLM_CHOICES = [
     {
@@ -57,6 +59,21 @@ const LLM_CHOICES = [
         value: 'grok',
         short: 'Grok API',
     },
+    {
+        name: `OpenAI                 ${chalk.gray('ChatGPT API')}`,
+        value: 'openai',
+        short: 'OpenAI',
+    },
+    {
+        name: `Claude                 ${chalk.gray('Anthropic API')}`,
+        value: 'anthropic',
+        short: 'Claude',
+    },
+    {
+        name: `Gemini                 ${chalk.gray('Google AI Studio API')}`,
+        value: 'google',
+        short: 'Gemini',
+    },
     {
         name: `Ollama                 ${chalk.gray('Local LLM (free)')}`,
         value: 'ollama',
@@ -87,10 +104,31 @@ function isValidWallet(input) {
 function isWsUrl(input) {
     return input.startsWith('ws://') || input.startsWith('wss://');
 }
+function normalizeControlPlaneUrl(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return trimmed;
+    try {
+        const parsed = new URL(trimmed);
+        if ((parsed.protocol === 'ws:' || parsed.protocol === 'wss:') && (parsed.pathname === '' || parsed.pathname === '/')) {
+            parsed.pathname = '/ws';
+            return parsed.toString();
+        }
+    }
+    catch {
+        // Keep original value; validation layer handles invalid URLs.
+    }
+    return trimmed;
+}
 function normalizeProvider(provider) {
     if (!provider)
         return undefined;
-    if (provider === 'grok' || provider === 'ollama' || provider === 'openai-compatible') {
+    if (provider === 'grok'
+        || provider === 'openai'
+        || provider === 'anthropic'
+        || provider === 'google'
+        || provider === 'ollama'
+        || provider === 'openai-compatible') {
         return provider;
     }
     return undefined;
@@ -103,8 +141,47 @@ function normalizeProfile(profile) {
     }
     return undefined;
 }
-function getRuntimeGrokKey() {
-    return process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim();
+function getRuntimeProviderKey(provider) {
+    if (provider === 'grok') {
+        return process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim() || undefined;
+    }
+    if (provider === 'openai') {
+        return process.env.TERMINUS_OPENAI_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim() || undefined;
+    }
+    if (provider === 'anthropic') {
+        return process.env.TERMINUS_ANTHROPIC_API_KEY?.trim() || process.env.ANTHROPIC_API_KEY?.trim() || undefined;
+    }
+    return (process.env.TERMINUS_GOOGLE_API_KEY?.trim()
+        || process.env.GOOGLE_API_KEY?.trim()
+        || process.env.GEMINI_API_KEY?.trim()
+        || undefined);
+}
+function providerEnvHint(provider) {
+    if (provider === 'grok')
+        return 'TERMINUS_GROK_API_KEY or XAI_API_KEY';
+    if (provider === 'openai')
+        return 'TERMINUS_OPENAI_API_KEY or OPENAI_API_KEY';
+    if (provider === 'anthropic')
+        return 'TERMINUS_ANTHROPIC_API_KEY or ANTHROPIC_API_KEY';
+    return 'TERMINUS_GOOGLE_API_KEY or GOOGLE_API_KEY or GEMINI_API_KEY';
+}
+function providerLabel(provider) {
+    if (provider === 'grok')
+        return 'Grok';
+    if (provider === 'openai')
+        return 'OpenAI';
+    if (provider === 'anthropic')
+        return 'Claude';
+    return 'Gemini';
+}
+function providerDefaultModel(provider) {
+    if (provider === 'grok')
+        return 'grok-4-1-fast-non-reasoning';
+    if (provider === 'openai')
+        return 'gpt-4o-mini';
+    if (provider === 'anthropic')
+        return 'claude-3-5-haiku-latest';
+    return 'gemini-2.0-flash';
 }
 async function promptForAgentType(initialValue, nonInteractive) {
     if (initialValue) {
@@ -176,48 +253,71 @@ async function promptForProvider(initialValue, nonInteractive) {
     return llmProvider;
 }
 async function configureProvider(llmProvider, options, nonInteractive, ollamaModels) {
-    if (llmProvider === 'grok') {
-        const runtimeGrokKey = getRuntimeGrokKey();
+    if (llmProvider === 'grok' || llmProvider === 'openai' || llmProvider === 'anthropic' || llmProvider === 'google') {
+        const provider = llmProvider;
+        const runtimeProviderKey = getRuntimeProviderKey(provider);
+        const defaultModel = options.llmModel || providerDefaultModel(provider);
         if (options.apiKey?.trim()) {
-            return { apiKey: options.apiKey.trim() };
+            return {
+                apiKey: options.apiKey.trim(),
+                llmModel: defaultModel,
+            };
         }
         if (nonInteractive) {
-            if (!runtimeGrokKey) {
-                throw new Error('Grok selected but no key provided. Set --apiKey or TERMINUS_GROK_API_KEY/XAI_API_KEY.');
+            if (!runtimeProviderKey) {
+                throw new Error(`${providerLabel(provider)} selected but no key provided. Set --apiKey or ${providerEnvHint(provider)}.`);
             }
-            return { apiKey: '__ENV__' };
+            return {
+                apiKey: '__ENV__',
+                llmModel: defaultModel,
+            };
         }
-        if (runtimeGrokKey) {
-            const { useRuntimeKey } = await inquirer.prompt([
+        let useRuntimeKey = false;
+        if (runtimeProviderKey) {
+            const answer = await inquirer.prompt([
                 {
                     type: 'confirm',
                     name: 'useRuntimeKey',
-                    message: 'Use Grok API key from runtime environment (recommended)?',
+                    message: `Use ${providerLabel(provider)} API key from runtime environment (recommended)?`,
                     default: true,
                 },
             ]);
-            if (useRuntimeKey) {
-                return { apiKey: '__ENV__' };
-            }
+            useRuntimeKey = Boolean(answer.useRuntimeKey);
         }
-        const { key } = await inquirer.prompt([
-            {
-                type: 'password',
-                name: 'key',
-                message: 'Grok API key (xai-...):',
-                mask: '•',
-                validate: (input) => {
-                    if (!input)
-                        return 'API key is required';
-                    if (!input.startsWith('xai-'))
-                        return 'Grok API keys start with "xai-"';
-                    if (input.length < 20)
-                        return 'API key looks too short';
-                    return true;
+        let apiKey = '__ENV__';
+        if (!useRuntimeKey) {
+            const { key } = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'key',
+                    message: `${providerLabel(provider)} API key:`,
+                    mask: '•',
+                    validate: (input) => {
+                        if (!input)
+                            return 'API key is required';
+                        if (provider === 'grok' && !input.startsWith('xai-')) {
+                            return 'Grok API keys start with \"xai-\"';
+                        }
+                        if (input.length < 12)
+                            return 'API key looks too short';
+                        return true;
+                    },
                 },
+            ]);
+            apiKey = String(key).trim();
+        }
+        const { model } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'model',
+                message: `${providerLabel(provider)} model name:`,
+                default: defaultModel,
             },
         ]);
-        return { apiKey: key.trim() };
+        return {
+            apiKey,
+            llmModel: String(model).trim(),
+        };
     }
     if (llmProvider === 'ollama') {
         const defaultBaseUrl = options.llmBaseUrl || 'http://localhost:11434';
@@ -308,13 +408,14 @@ async function selectNetworkProfile(initialValue, nonInteractive) {
     return profile;
 }
 async function selectControlPlaneUrl(profile, initialValue, nonInteractive) {
-    const defaultUrl = initialValue?.trim() || NETWORK_URL_PRESETS[profile];
+    const defaultUrl = normalizeControlPlaneUrl(initialValue?.trim() || NETWORK_URL_PRESETS[profile]);
+    const requiresSecureWs = profile !== 'local';
     if (nonInteractive) {
         if (!isWsUrl(defaultUrl)) {
             throw new Error('controlPlaneUrl must start with ws:// or wss://');
         }
-        if (profile === 'mainnet' && !defaultUrl.startsWith('wss://')) {
-            throw new Error('Mainnet profile requires wss:// control-plane URL.');
+        if (requiresSecureWs && !defaultUrl.startsWith('wss://')) {
+            throw new Error(`${NETWORK_LABELS[profile]} profile requires wss:// control-plane URL.`);
         }
         return defaultUrl;
     }
@@ -327,14 +428,14 @@ async function selectControlPlaneUrl(profile, initialValue, nonInteractive) {
             validate: (input) => {
                 if (!isWsUrl(input))
                     return 'URL must start with ws:// or wss://';
-                if (profile === 'mainnet' && !input.startsWith('wss://')) {
-                    return 'Mainnet requires wss://';
+                if (requiresSecureWs && !input.startsWith('wss://')) {
+                    return `${NETWORK_LABELS[profile]} requires wss://`;
                 }
                 return true;
             },
         },
     ]);
-    return String(controlPlaneUrl);
+    return normalizeControlPlaneUrl(String(controlPlaneUrl));
 }
 export async function initCommand(rawOptions = {}) {
     const options = {
@@ -413,8 +514,9 @@ export async function initCommand(rawOptions = {}) {
     console.log();
     console.log(chalk.yellow('Important: set TERMINUS_WALLET_PRIVATE_KEY in your shell before running.'));
     console.log(chalk.cyan('  export TERMINUS_WALLET_PRIVATE_KEY=0x...'));
-    if (llmProvider === 'grok' && providerConfig.apiKey === '__ENV__') {
-        console.log(chalk.yellow('Important: Grok key will be read from TERMINUS_GROK_API_KEY or XAI_API_KEY.'));
+    if ((llmProvider === 'grok' || llmProvider === 'openai' || llmProvider === 'anthropic' || llmProvider === 'google')
+        && providerConfig.apiKey === '__ENV__') {
+        console.log(chalk.yellow(`Important: ${providerLabel(llmProvider)} key will be read from ${providerEnvHint(llmProvider)}.`));
     }
     console.log(chalk.cyan('\nNext steps:'));
     console.log(chalk.cyan('  npx terminus-agent doctor'));

package/dist/cli/run.js

@@ -26,7 +26,7 @@ function printStartupBanner(config) {
         return;
     const emoji = AGENT_EMOJIS[config.agentType] || '🤖';
     const provider = config.llmProvider || 'grok';
-    const providerIcon = provider === 'grok' ? '🌐' : provider === 'ollama' ? '🦙' : '🔧';
+    const providerIcon = getProviderIcon(provider);
     console.log();
     console.log(chalk.cyan.bold('╔════════════════════════════════════════════════════════════╗'));
     console.log(chalk.cyan.bold('║              🚀 TERMINUS AGENT STARTING                    ║'));
@@ -41,6 +41,19 @@ function printStartupBanner(config) {
     console.log(chalk.gray('\n────────────────────────────────────────────────────────────\n'));
     console.log(chalk.yellow('   ⏳ Connecting to Control Plane...\n'));
 }
+function getProviderIcon(provider) {
+    if (provider === 'grok')
+        return '🌐';
+    if (provider === 'openai')
+        return '🧠';
+    if (provider === 'anthropic')
+        return '🧩';
+    if (provider === 'google')
+        return '🔷';
+    if (provider === 'ollama')
+        return '🦙';
+    return '🔧';
+}
 export async function runCommand() {
     if (!configExists()) {
         console.log();

package/dist/cli/status.js

@@ -55,10 +55,8 @@ export async function statusCommand() {
     // LLM Provider Info
     console.log(chalk.yellow('\n┌─ LLM Provider ─────────────────────────┐\n'));
     const provider = config.llmProvider || 'grok';
-    const providerIcon = provider === 'grok' ? '🌐' : provider === 'ollama' ? '🦙' : '🔧';
-    const providerName = provider === 'grok' ? 'Grok API (xAI Cloud)'
-        : provider === 'ollama' ? 'Ollama (Local)'
-            : 'OpenAI-Compatible';
+    const providerIcon = getProviderIcon(provider);
+    const providerName = getProviderName(provider);
     console.log(`   ${chalk.gray('Provider:')}       ${providerIcon}  ${chalk.white(providerName)}`);
     if (config.llmModel) {
         console.log(`   ${chalk.gray('Model:')}          ${chalk.white(config.llmModel)}`);
@@ -71,8 +69,8 @@ export async function statusCommand() {
         const ollamaOk = await checkOllamaAvailable(config.llmBaseUrl);
         console.log(`   ${chalk.gray('Status:')}         ${ollamaOk ? chalk.green('✓ Connected') : chalk.red('✗ Not reachable')}`);
     }
-    else if (provider === 'grok') {
-        const hasRuntimeKey = Boolean(process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim());
+    else if (provider !== 'openai-compatible') {
+        const hasRuntimeKey = hasRuntimeProviderKey(provider);
         const hasStoredKey = Boolean(config.apiKey?.trim() && config.apiKey !== '__ENV__');
         const source = hasRuntimeKey ? 'Runtime env' : hasStoredKey ? 'Config file' : 'Missing';
         console.log(`   ${chalk.gray('API Key:')}        ${hasRuntimeKey || hasStoredKey ? chalk.green(`✓ ${source}`) : chalk.red('✗ Missing')}`);
@@ -102,3 +100,46 @@ export async function statusCommand() {
     console.log(`   ${chalk.cyan('npx terminus-agent doctor')} ${chalk.gray('Run readiness checks')}`);
     console.log();
 }
+function getProviderIcon(provider) {
+    if (provider === 'grok')
+        return '🌐';
+    if (provider === 'openai')
+        return '🧠';
+    if (provider === 'anthropic')
+        return '🧩';
+    if (provider === 'google')
+        return '🔷';
+    if (provider === 'ollama')
+        return '🦙';
+    return '🔧';
+}
+function getProviderName(provider) {
+    if (provider === 'grok')
+        return 'Grok API (xAI Cloud)';
+    if (provider === 'openai')
+        return 'OpenAI API (ChatGPT)';
+    if (provider === 'anthropic')
+        return 'Claude API (Anthropic)';
+    if (provider === 'google')
+        return 'Gemini API (Google)';
+    if (provider === 'ollama')
+        return 'Ollama (Local)';
+    return 'OpenAI-Compatible';
+}
+function hasRuntimeProviderKey(provider) {
+    if (provider === 'grok') {
+        return Boolean(process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim());
+    }
+    if (provider === 'openai') {
+        return Boolean(process.env.TERMINUS_OPENAI_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim());
+    }
+    if (provider === 'anthropic') {
+        return Boolean(process.env.TERMINUS_ANTHROPIC_API_KEY?.trim() || process.env.ANTHROPIC_API_KEY?.trim());
+    }
+    if (provider === 'google') {
+        return Boolean(process.env.TERMINUS_GOOGLE_API_KEY?.trim()
+            || process.env.GOOGLE_API_KEY?.trim()
+            || process.env.GEMINI_API_KEY?.trim());
+    }
+    return false;
+}

package/dist/config/store.d.ts

@@ -1,4 +1,5 @@
 export type NetworkProfile = 'local' | 'testnet' | 'mainnet';
+export type LlmProvider = 'grok' | 'openai' | 'anthropic' | 'google' | 'ollama' | 'openai-compatible';
 export interface AgentConfig {
     agentType: string;
     wallet: string;
@@ -6,7 +7,7 @@ export interface AgentConfig {
     apiKey: string;
     controlPlaneUrl: string;
     nodeId: string;
-    llmProvider?: 'grok' | 'ollama' | 'openai-compatible';
+    llmProvider?: LlmProvider;
     llmBaseUrl?: string;
     llmModel?: string;
     networkProfile?: NetworkProfile;

package/dist/config/store.js

@@ -50,11 +50,11 @@ export function validateConfig(config) {
         errors.push('nodeId is required');
     }
     const provider = config.llmProvider || 'grok';
-    if (provider === 'grok') {
+    if (requiresApiKey(provider)) {
         const hasStoredKey = typeof config.apiKey === 'string' && config.apiKey.length > 0 && config.apiKey !== '__ENV__';
-        const hasRuntimeKey = Boolean(process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim());
+        const hasRuntimeKey = hasRuntimeProviderKey(provider);
         if (!hasStoredKey && !hasRuntimeKey) {
-            errors.push('grok provider requires apiKey in config or TERMINUS_GROK_API_KEY/XAI_API_KEY env');
+            errors.push(`${provider} provider requires apiKey in config or runtime env`);
         }
     }
     if (provider === 'openai-compatible' && !config.llmBaseUrl) {
@@ -71,7 +71,7 @@ export function saveConfig(config) {
     }
     securePermissions(CONFIG_DIR, DIR_MODE);
     const provider = config.llmProvider || 'grok';
-    const normalizedApiKey = provider === 'grok'
+    const normalizedApiKey = requiresApiKey(provider)
         ? (config.apiKey || '__ENV__')
         : (config.apiKey || '');
     const normalizedProfile = normalizeNetworkProfile(config.networkProfile);
@@ -105,7 +105,12 @@ function normalizeConfig(raw) {
         return null;
     const value = raw;
     const llmProvider = value.llmProvider;
-    const provider = llmProvider === 'ollama' || llmProvider === 'openai-compatible' || llmProvider === 'grok'
+    const provider = llmProvider === 'grok'
+        || llmProvider === 'openai'
+        || llmProvider === 'anthropic'
+        || llmProvider === 'google'
+        || llmProvider === 'ollama'
+        || llmProvider === 'openai-compatible'
         ? llmProvider
         : 'grok';
     const networkProfile = normalizeNetworkProfile(value.networkProfile);
@@ -146,3 +151,23 @@ function normalizeNetworkProfile(value) {
         return value;
     return 'local';
 }
+function requiresApiKey(provider) {
+    return provider === 'grok' || provider === 'openai' || provider === 'anthropic' || provider === 'google';
+}
+function hasRuntimeProviderKey(provider) {
+    if (provider === 'grok') {
+        return Boolean(process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim());
+    }
+    if (provider === 'openai') {
+        return Boolean(process.env.TERMINUS_OPENAI_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim());
+    }
+    if (provider === 'anthropic') {
+        return Boolean(process.env.TERMINUS_ANTHROPIC_API_KEY?.trim() || process.env.ANTHROPIC_API_KEY?.trim());
+    }
+    if (provider === 'google') {
+        return Boolean(process.env.TERMINUS_GOOGLE_API_KEY?.trim()
+            || process.env.GOOGLE_API_KEY?.trim()
+            || process.env.GEMINI_API_KEY?.trim());
+    }
+    return false;
+}

package/dist/index.js

@@ -25,7 +25,7 @@ program
     .description('Initialize agent configuration')
     .option('--agent-type <id>', 'Agent type id (example: travel-planner)')
     .option('--wallet <address>', 'Wallet address for payouts')
-    .option('--llm-provider <provider>', 'grok | ollama | openai-compatible')
+    .option('--llm-provider <provider>', 'grok | openai | anthropic | google | ollama | openai-compatible')
     .option('--api-key <key>', 'API key for provider')
     .option('--llm-base-url <url>', 'Provider base URL')
     .option('--llm-model <name>', 'LLM model name')

package/dist/llm/provider.d.ts

@@ -7,8 +7,9 @@ export interface LLMResponse {
     model: string;
     tokensUsed?: number;
 }
+export type LLMProviderType = 'grok' | 'openai' | 'anthropic' | 'google' | 'ollama' | 'openai-compatible';
 export interface LLMProviderConfig {
-    provider: 'grok' | 'ollama' | 'openai-compatible';
+    provider: LLMProviderType;
     apiKey?: string;
     baseUrl?: string;
     model?: string;
@@ -30,6 +31,36 @@ export declare class GrokProvider implements LLMProvider {
         temperature?: number;
     }): Promise<LLMResponse>;
 }
+export declare class OpenAIProvider implements LLMProvider {
+    name: string;
+    private apiKey;
+    private model;
+    constructor(apiKey: string, model?: string);
+    chat(messages: LLMMessage[], options?: {
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<LLMResponse>;
+}
+export declare class AnthropicProvider implements LLMProvider {
+    name: string;
+    private apiKey;
+    private model;
+    constructor(apiKey: string, model?: string);
+    chat(messages: LLMMessage[], options?: {
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<LLMResponse>;
+}
+export declare class GoogleProvider implements LLMProvider {
+    name: string;
+    private apiKey;
+    private model;
+    constructor(apiKey: string, model?: string);
+    chat(messages: LLMMessage[], options?: {
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<LLMResponse>;
+}
 export declare class OllamaProvider implements LLMProvider {
     name: string;
     private baseUrl;

package/dist/llm/provider.js

@@ -2,7 +2,8 @@
 // TERMINUS AGENT - LLM Provider Interface
 // =============================================================================
 // Abstraction layer for different LLM backends.
-// Supports: xAI Grok (API), Ollama (local), OpenAI-compatible (local/cloud)
+// Supports: xAI Grok, OpenAI, Anthropic Claude, Google Gemini, Ollama,
+// and OpenAI-compatible endpoints.
 // =============================================================================
 // =============================================================================
 // xAI Grok Provider
@@ -20,7 +21,7 @@ export class GrokProvider {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${this.apiKey}`,
             },
             body: JSON.stringify({
                 model: this.model,
@@ -42,6 +43,139 @@ export class GrokProvider {
     }
 }
 // =============================================================================
+// OpenAI Provider
+// =============================================================================
+export class OpenAIProvider {
+    name = 'openai';
+    apiKey;
+    model;
+    constructor(apiKey, model = 'gpt-4o-mini') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async chat(messages, options) {
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages,
+                max_tokens: options?.maxTokens ?? 1024,
+                temperature: options?.temperature ?? 0.7,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+            content: extractOpenAIContent(data.choices[0]?.message?.content),
+            model: this.model,
+            tokensUsed: data.usage?.total_tokens,
+        };
+    }
+}
+// =============================================================================
+// Anthropic Claude Provider
+// =============================================================================
+export class AnthropicProvider {
+    name = 'anthropic';
+    apiKey;
+    model;
+    constructor(apiKey, model = 'claude-3-5-haiku-latest') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async chat(messages, options) {
+        const normalized = toAnthropicMessages(messages);
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: this.model,
+                max_tokens: options?.maxTokens ?? 1024,
+                temperature: options?.temperature ?? 0.7,
+                system: normalized.systemPrompt || undefined,
+                messages: normalized.messages,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.content
+            .filter((part) => part.type === 'text' && typeof part.text === 'string')
+            .map((part) => part.text)
+            .join('\n')
+            .trim();
+        const inputTokens = data.usage?.input_tokens ?? 0;
+        const outputTokens = data.usage?.output_tokens ?? 0;
+        return {
+            content,
+            model: this.model,
+            tokensUsed: inputTokens + outputTokens,
+        };
+    }
+}
+// =============================================================================
+// Google Gemini Provider
+// =============================================================================
+export class GoogleProvider {
+    name = 'google';
+    apiKey;
+    model;
+    constructor(apiKey, model = 'gemini-2.0-flash') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async chat(messages, options) {
+        const normalized = toGoogleMessages(messages);
+        const encodedModel = encodeURIComponent(this.model);
+        const payload = {
+            contents: normalized.messages,
+            generationConfig: {
+                maxOutputTokens: options?.maxTokens ?? 1024,
+                temperature: options?.temperature ?? 0.7,
+            },
+        };
+        if (normalized.systemPrompt) {
+            payload.systemInstruction = {
+                parts: [{ text: normalized.systemPrompt }],
+            };
+        }
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${encodedModel}:generateContent?key=${this.apiKey}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Google Gemini API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.candidates?.[0]?.content?.parts
+            ?.map((part) => part.text || '')
+            .join('\n')
+            .trim() || '';
+        return {
+            content,
+            model: this.model,
+            tokensUsed: data.usageMetadata?.totalTokenCount,
+        };
+    }
+}
+// =============================================================================
 // Ollama Provider (Local LLM)
 // =============================================================================
 export class OllamaProvider {
@@ -49,11 +183,10 @@ export class OllamaProvider {
     baseUrl;
     model;
     constructor(baseUrl = 'http://localhost:11434', model = 'llama3') {
-        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.baseUrl = baseUrl.replace(/\/$/, '');
         this.model = model;
     }
     async chat(messages, options) {
-        // Ollama uses /api/chat endpoint
         const response = await fetch(`${this.baseUrl}/api/chat`, {
             method: 'POST',
             headers: {
@@ -129,14 +262,34 @@ export class OpenAICompatibleProvider {
 // =============================================================================
 export function createLLMProvider(config) {
     switch (config.provider) {
-        case 'grok':
-            {
-                const apiKey = resolveGrokApiKey(config.apiKey);
-                if (!apiKey) {
-                    throw new Error('Grok provider requires a key in config or TERMINUS_GROK_API_KEY/XAI_API_KEY env');
-                }
-                return new GrokProvider(apiKey, config.model);
+        case 'grok': {
+            const apiKey = resolveProviderApiKey('grok', config.apiKey);
+            if (!apiKey) {
+                throw new Error('Grok provider requires a key in config or TERMINUS_GROK_API_KEY/XAI_API_KEY env');
+            }
+            return new GrokProvider(apiKey, config.model);
+        }
+        case 'openai': {
+            const apiKey = resolveProviderApiKey('openai', config.apiKey);
+            if (!apiKey) {
+                throw new Error('OpenAI provider requires a key in config or TERMINUS_OPENAI_API_KEY/OPENAI_API_KEY env');
             }
+            return new OpenAIProvider(apiKey, config.model || 'gpt-4o-mini');
+        }
+        case 'anthropic': {
+            const apiKey = resolveProviderApiKey('anthropic', config.apiKey);
+            if (!apiKey) {
+                throw new Error('Anthropic provider requires a key in config or TERMINUS_ANTHROPIC_API_KEY/ANTHROPIC_API_KEY env');
+            }
+            return new AnthropicProvider(apiKey, config.model || 'claude-3-5-haiku-latest');
+        }
+        case 'google': {
+            const apiKey = resolveProviderApiKey('google', config.apiKey);
+            if (!apiKey) {
+                throw new Error('Google provider requires a key in config or TERMINUS_GOOGLE_API_KEY/GOOGLE_API_KEY/GEMINI_API_KEY env');
+            }
+            return new GoogleProvider(apiKey, config.model || 'gemini-2.0-flash');
+        }
         case 'ollama':
             return new OllamaProvider(config.baseUrl || 'http://localhost:11434', config.model || 'llama3');
         case 'openai-compatible':
@@ -149,7 +302,7 @@ export function createLLMProvider(config) {
     }
 }
 // =============================================================================
-// Helper to detect Ollama availability
+// Provider helpers
 // =============================================================================
 export async function checkOllamaAvailable(baseUrl = 'http://localhost:11434') {
     try {
@@ -166,16 +319,80 @@ export async function listOllamaModels(baseUrl = 'http://localhost:11434') {
         if (!response.ok)
             return [];
         const data = await response.json();
-        return data.models?.map(m => m.name) || [];
+        return data.models?.map((m) => m.name) || [];
     }
     catch {
         return [];
     }
 }
-function resolveGrokApiKey(configApiKey) {
+function resolveProviderApiKey(provider, configApiKey) {
     const key = configApiKey?.trim();
     if (key && key !== '__ENV__')
         return key;
-    const runtimeKey = process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim();
-    return runtimeKey || undefined;
+    if (provider === 'grok') {
+        return process.env.TERMINUS_GROK_API_KEY?.trim() || process.env.XAI_API_KEY?.trim() || undefined;
+    }
+    if (provider === 'openai') {
+        return process.env.TERMINUS_OPENAI_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim() || undefined;
+    }
+    if (provider === 'anthropic') {
+        return process.env.TERMINUS_ANTHROPIC_API_KEY?.trim() || process.env.ANTHROPIC_API_KEY?.trim() || undefined;
+    }
+    return (process.env.TERMINUS_GOOGLE_API_KEY?.trim()
+        || process.env.GOOGLE_API_KEY?.trim()
+        || process.env.GEMINI_API_KEY?.trim()
+        || undefined);
+}
+function extractOpenAIContent(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    return content
+        .filter((part) => part.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join('\n')
+        .trim();
+}
+function toAnthropicMessages(messages) {
+    const systemChunks = [];
+    const converted = [];
+    for (const message of messages) {
+        if (message.role === 'system') {
+            systemChunks.push(message.content);
+            continue;
+        }
+        converted.push({
+            role: message.role,
+            content: message.content,
+        });
+    }
+    if (converted.length === 0) {
+        converted.push({ role: 'user', content: 'Continue.' });
+    }
+    return {
+        systemPrompt: systemChunks.join('\n\n').trim(),
+        messages: converted,
+    };
+}
+function toGoogleMessages(messages) {
+    const systemChunks = [];
+    const converted = [];
+    for (const message of messages) {
+        if (message.role === 'system') {
+            systemChunks.push(message.content);
+            continue;
+        }
+        converted.push({
+            role: message.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: message.content }],
+        });
+    }
+    if (converted.length === 0) {
+        converted.push({ role: 'user', parts: [{ text: 'Continue.' }] });
+    }
+    return {
+        systemPrompt: systemChunks.join('\n\n').trim(),
+        messages: converted,
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@terminusagents/agents",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "description": "Standalone agent runner for Terminus network",
     "type": "module",
     "main": "dist/index.js",