@terminusagents/agents 0.1.1 → 0.1.3

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`
 
@@ -53,12 +53,18 @@ npx terminus-agent init
 `init` uses production-safe defaults:
 - testnet: `wss://cp-sepolia.termn.xyz/ws`
 - mainnet: `wss://cp-mainnet.termn.xyz/ws`
+- if `TERMINUS_WALLET_PRIVATE_KEY` is set, wallet is derived automatically
+- if your wallet already has a Terminus identity NFT, agent type is auto-detected from chain
 
 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:
@@ -79,15 +85,14 @@ 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 \
   --force \
   --profile testnet \
-  --agent-type travel-planner \
-  --wallet 0x1234567890abcdef1234567890abcdef12345678 \
-  --llm-provider grok
+  --llm-provider openai \
+  --llm-model gpt-4o-mini
 ```
 
 Then:
@@ -153,6 +158,10 @@ 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
 
@@ -166,10 +175,12 @@ Example:
 - 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

@@ -3,6 +3,7 @@
 // =============================================================================
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import { ethers } from 'ethers';
 import { saveConfig, generateNodeId, getConfigPath, configExists, loadConfig } from '../config/store.js';
 import { checkOllamaAvailable, listOllamaModels } from '../llm/provider.js';
 import { AGENTS } from '../agents/index.js';
@@ -44,6 +45,15 @@ const NETWORK_LABELS = {
 };
 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 DEFAULT_TESTNET_REGISTRY_CONTRACT = '0x1439F2c1Fb1B3F99efe2aB02A90B377BaE5D2B02';
+const DEFAULT_TESTNET_RPC_URL = 'https://sepolia.base.org';
+const DEFAULT_MAINNET_RPC_URL = 'https://mainnet.base.org';
+const AGENT_IDENTITY_REGISTRY_ABI = [
+    'function balanceOf(address owner) view returns (uint256)',
+    'function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)',
+    'function getAgentType(uint256 tokenId) view returns (string)',
+    'function getCollectionTokenId(uint256 tokenId) view returns (uint256)',
+];
 const NETWORK_URL_PRESETS = {
     local: process.env.TERMINUS_CONTROL_PLANE_URL_LOCAL?.trim() || 'ws://localhost:8084/ws',
     testnet: process.env.TERMINUS_CONTROL_PLANE_URL_TESTNET?.trim() ||
@@ -59,6 +69,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',
@@ -108,7 +133,12 @@ function normalizeControlPlaneUrl(input) {
 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;
@@ -121,8 +151,186 @@ 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';
+}
+function getWalletFromRuntimePrivateKey() {
+    const privateKey = process.env.TERMINUS_WALLET_PRIVATE_KEY?.trim();
+    if (!privateKey)
+        return undefined;
+    try {
+        const normalizedPk = privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`;
+        return new ethers.Wallet(normalizedPk).address;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveRegistryAddress(profile) {
+    if (profile === 'testnet') {
+        const candidate = (process.env.TERMINUS_AGENT_IDENTITY_REGISTRY_CONTRACT_TESTNET?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT_TESTNET?.trim()
+            || process.env.NEXT_PUBLIC_SEPOLIA_REGISTRY_CONTRACT?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT?.trim()
+            || DEFAULT_TESTNET_REGISTRY_CONTRACT);
+        return isValidWallet(candidate) ? candidate : undefined;
+    }
+    if (profile === 'mainnet') {
+        const candidate = (process.env.TERMINUS_AGENT_IDENTITY_REGISTRY_CONTRACT_MAINNET?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT_MAINNET?.trim()
+            || process.env.NEXT_PUBLIC_MAINNET_REGISTRY_CONTRACT?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT?.trim());
+        return candidate && isValidWallet(candidate) ? candidate : undefined;
+    }
+    return undefined;
+}
+function resolveRpcUrl(profile) {
+    if (profile === 'testnet') {
+        return (process.env.TERMINUS_BASE_SEPOLIA_RPC?.trim()
+            || process.env.BASE_SEPOLIA_RPC?.trim()
+            || DEFAULT_TESTNET_RPC_URL);
+    }
+    if (profile === 'mainnet') {
+        return (process.env.TERMINUS_BASE_MAINNET_RPC?.trim()
+            || process.env.BASE_MAINNET_RPC?.trim()
+            || DEFAULT_MAINNET_RPC_URL);
+    }
+    return undefined;
+}
+function resolveRequiredCollectionTokenId(profile) {
+    if (profile === 'testnet') {
+        return (process.env.TERMINUS_COLLECTION_TOKEN_ID_TESTNET?.trim()
+            || process.env.NEXT_PUBLIC_SEPOLIA_COLLECTION_TOKEN_ID?.trim()
+            || process.env.TERMINUS_COLLECTION_TOKEN_ID?.trim()
+            || undefined);
+    }
+    if (profile === 'mainnet') {
+        return (process.env.TERMINUS_COLLECTION_TOKEN_ID_MAINNET?.trim()
+            || process.env.NEXT_PUBLIC_MAINNET_COLLECTION_TOKEN_ID?.trim()
+            || process.env.TERMINUS_COLLECTION_TOKEN_ID?.trim()
+            || undefined);
+    }
+    return undefined;
+}
+async function detectAgentIdentitiesFromChain(profile, wallet) {
+    const registryAddress = resolveRegistryAddress(profile);
+    const rpcUrl = resolveRpcUrl(profile);
+    if (!registryAddress || !rpcUrl || profile === 'local') {
+        return { identities: [], registryAddress, rpcUrl };
+    }
+    const requiredCollectionTokenId = resolveRequiredCollectionTokenId(profile);
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    const contract = new ethers.Contract(registryAddress, AGENT_IDENTITY_REGISTRY_ABI, provider);
+    const balance = await contract.balanceOf(wallet);
+    if (balance === 0n) {
+        return { identities: [], registryAddress, rpcUrl };
+    }
+    const identities = [];
+    for (let i = 0n; i < balance; i++) {
+        const tokenId = await contract.tokenOfOwnerByIndex(wallet, i);
+        const agentTypeRaw = await contract.getAgentType(tokenId);
+        const agentType = agentTypeRaw.trim();
+        if (!AGENTS.some((agent) => agent.id === agentType)) {
+            continue;
+        }
+        let collectionTokenId;
+        try {
+            const rawCollectionTokenId = await contract.getCollectionTokenId(tokenId);
+            collectionTokenId = rawCollectionTokenId.toString();
+        }
+        catch {
+            collectionTokenId = undefined;
+        }
+        if (requiredCollectionTokenId && collectionTokenId && collectionTokenId !== requiredCollectionTokenId) {
+            continue;
+        }
+        identities.push({
+            tokenId: tokenId.toString(),
+            agentType,
+            collectionTokenId,
+        });
+    }
+    identities.sort((a, b) => {
+        const tokenA = BigInt(a.tokenId);
+        const tokenB = BigInt(b.tokenId);
+        if (tokenA < tokenB)
+            return -1;
+        if (tokenA > tokenB)
+            return 1;
+        return 0;
+    });
+    return { identities, registryAddress, rpcUrl };
+}
+async function autoSelectAgentType(profile, wallet, nonInteractive) {
+    if (profile === 'local') {
+        return {};
+    }
+    try {
+        const { identities } = await detectAgentIdentitiesFromChain(profile, wallet);
+        if (identities.length === 0) {
+            return {};
+        }
+        if (identities.length === 1 || nonInteractive) {
+            return { agentType: identities[0].agentType, identity: identities[0] };
+        }
+        const { selectedTokenId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedTokenId',
+                message: 'Multiple agent identities detected. Select one:',
+                choices: identities.map((item) => ({
+                    name: `${item.agentType} ${chalk.gray(`(tokenId=${item.tokenId}${item.collectionTokenId ? `, collection=${item.collectionTokenId}` : ''})`)}`,
+                    value: item.tokenId,
+                })),
+                loop: false,
+            },
+        ]);
+        const selected = identities.find((item) => item.tokenId === selectedTokenId) || identities[0];
+        return { agentType: selected.agentType, identity: selected };
+    }
+    catch (error) {
+        console.log(chalk.yellow(`⚠ Could not auto-detect agent identity: ${error.message}`));
+        return {};
+    }
 }
 async function promptForAgentType(initialValue, nonInteractive) {
     if (initialValue) {
@@ -194,48 +402,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';
@@ -398,11 +629,25 @@ export async function initCommand(rawOptions = {}) {
         console.log(chalk.gray('○ Ollama not detected'));
     }
     console.log();
-    const agentType = await promptForAgentType(options.agentType, nonInteractive);
-    const wallet = await promptForWallet(options.wallet, nonInteractive);
+    const profile = await selectNetworkProfile(options.profile, nonInteractive);
+    const derivedWallet = getWalletFromRuntimePrivateKey();
+    const wallet = await promptForWallet(options.wallet || derivedWallet, nonInteractive);
+    if (!options.wallet && derivedWallet) {
+        console.log(chalk.green(`✓ Wallet auto-detected from TERMINUS_WALLET_PRIVATE_KEY: ${wallet}`));
+    }
+    let detectedIdentity;
+    let selectedAgentType = options.agentType;
+    if (!selectedAgentType) {
+        const detection = await autoSelectAgentType(profile, wallet, nonInteractive);
+        if (detection.agentType) {
+            selectedAgentType = detection.agentType;
+            detectedIdentity = detection.identity;
+            console.log(chalk.green(`✓ Agent type auto-detected: ${selectedAgentType}${detectedIdentity ? ` (tokenId=${detectedIdentity.tokenId})` : ''}`));
+        }
+    }
+    const agentType = await promptForAgentType(selectedAgentType, nonInteractive);
     const llmProvider = await promptForProvider(options.llmProvider, nonInteractive);
     const providerConfig = await configureProvider(llmProvider, options, nonInteractive, ollamaModels);
-    const profile = await selectNetworkProfile(options.profile, nonInteractive);
     const controlPlaneUrl = await selectControlPlaneUrl(profile, options.controlPlaneUrl, nonInteractive);
     const nodeId = generateNodeId(agentType, wallet);
     const config = {
@@ -420,6 +665,12 @@ export async function initCommand(rawOptions = {}) {
     const selectedAgent = AGENTS.find((item) => item.id === agentType);
     console.log(chalk.green.bold('\nSetup complete.\n'));
     printInfo('Agent', `${AGENT_EMOJIS[agentType] || '🤖'} ${selectedAgent?.name || agentType}`);
+    if (detectedIdentity) {
+        printInfo('Identity Token', detectedIdentity.tokenId);
+        if (detectedIdentity.collectionTokenId) {
+            printInfo('Collection Token', detectedIdentity.collectionTokenId);
+        }
+    }
     printInfo('Node ID', nodeId);
     printInfo('Wallet', `${wallet.slice(0, 10)}...${wallet.slice(-8)}`);
     printInfo('Provider', llmProvider);
@@ -432,8 +683,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();
@@ -67,10 +80,14 @@ export async function runCommand() {
         console.log(chalk.cyan('   npx terminus-agent init --profile mainnet\n'));
         process.exit(1);
     }
-    printStartupBanner(config);
-    if (!process.env.TERMINUS_WALLET_PRIVATE_KEY) {
-        console.log(chalk.yellow('   ⚠ TERMINUS_WALLET_PRIVATE_KEY is not set. Challenge-signature auth will fail in strict remote mode.\n'));
+    const runtimePrivateKey = process.env.TERMINUS_WALLET_PRIVATE_KEY?.trim();
+    if ((config.networkProfile === 'testnet' || config.networkProfile === 'mainnet') && !runtimePrivateKey) {
+        console.log(chalk.red('\n   ❌ TERMINUS_WALLET_PRIVATE_KEY is required for testnet/mainnet challenge-signature auth.\n'));
+        console.log(chalk.gray('   Set it and retry:'));
+        console.log(chalk.cyan('   export TERMINUS_WALLET_PRIVATE_KEY=0x...\n'));
+        process.exit(1);
     }
+    printStartupBanner(config);
     const client = new AgentClient(config);
     // Handle graceful shutdown
     process.on('SIGINT', () => {

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

@@ -19,13 +19,13 @@ async function withCliErrorHandling(task) {
 program
     .name('terminus-agent')
     .description('Standalone agent runner for Terminus network')
-    .version('0.1.0');
+    .version('0.1.3');
 program
     .command('init')
     .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.1",
+    "version": "0.1.3",
     "description": "Standalone agent runner for Terminus network",
     "type": "module",
     "main": "dist/index.js",