morpheus-cli 0.2.3 → 0.2.5

package/README.md

@@ -93,17 +93,80 @@ Local React-based UI to manage recordings, chat history, and system status acros
 #### 🔒 UI Authentication
 To protect your Web UI, use the `THE_ARCHITECT_PASS` environment variable. This ensures only authorized users can access the dashboard and API.
 
+Additionally, you can use environment variables for API keys instead of storing them in the configuration file:
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `OPENAI_API_KEY` | OpenAI API key (if using GPT) | No |
+| `ANTHROPIC_API_KEY` | Anthropic API key (if using Claude) | No |
+| `GOOGLE_API_KEY` | Google AI key (for Gemini and Audio) | Yes (for audio) |
+| `OPENROUTER_API_KEY` | OpenRouter API key (if using OpenRouter) | No |
+| `THE_ARCHITECT_PASS` | Web Dashboard access password | Recommended |
+| `TELEGRAM_BOT_TOKEN` | Telegram BotFather token | No |
+
+If these environment variables are set, they will take precedence over values stored in the configuration file.
+
+The system also supports generic environment variables that apply to all providers:
+
+| Variable | Description | Applies To |
+|----------|-------------|------------|
+| `MORPHEUS_AGENT_NAME` | Name of the agent | agent.name |
+| `MORPHEUS_AGENT_PERSONALITY` | Personality of the agent | agent.personality |
+| `MORPHEUS_LLM_PROVIDER` | LLM provider to use | llm.provider |
+| `MORPHEUS_LLM_MODEL` | Model name for LLM | llm.model |
+| `MORPHEUS_LLM_TEMPERATURE` | Temperature setting for LLM | llm.temperature |
+| `MORPHEUS_LLM_MAX_TOKENS` | Maximum tokens for LLM | llm.max_tokens |
+| `MORPHEUS_LLM_CONTEXT_WINDOW` | Context window size for LLM | llm.context_window |
+| `MORPHEUS_LLM_API_KEY` | Generic API key for LLM (lower precedence than provider-specific keys) | llm.api_key |
+| `MORPHEUS_SANTI_PROVIDER` | Sati provider to use | santi.provider |
+| `MORPHEUS_SANTI_MODEL` | Model name for Sati | santi.model |
+| `MORPHEUS_SANTI_TEMPERATURE` | Temperature setting for Sati | santi.temperature |
+| `MORPHEUS_SANTI_MAX_TOKENS` | Maximum tokens for Sati | santi.max_tokens |
+| `MORPHEUS_SANTI_CONTEXT_WINDOW` | Context window size for Sati | santi.context_window |
+| `MORPHEUS_SANTI_API_KEY` | Generic API key for Sati (lower precedence than provider-specific keys) | santi.api_key |
+| `MORPHEUS_SANTI_MEMORY_LIMIT` | Memory retrieval limit for Sati | santi.memory_limit |
+| `MORPHEUS_AUDIO_MODEL` | Model name for audio processing | audio.model |
+| `MORPHEUS_AUDIO_ENABLED` | Enable/disable audio processing | audio.enabled |
+| `MORPHEUS_AUDIO_API_KEY` | Generic API key for audio (lower precedence than provider-specific keys) | audio.apiKey |
+| `MORPHEUS_AUDIO_MAX_DURATION` | Max duration for audio processing | audio.maxDurationSeconds |
+| `MORPHEUS_TELEGRAM_ENABLED` | Enable/disable Telegram channel | channels.telegram.enabled |
+| `MORPHEUS_TELEGRAM_TOKEN` | Telegram bot token | channels.telegram.token |
+| `MORPHEUS_TELEGRAM_ALLOWED_USERS` | Comma-separated list of allowed Telegram user IDs | channels.telegram.allowedUsers |
+| `MORPHEUS_UI_ENABLED` | Enable/disable Web UI | ui.enabled |
+| `MORPHEUS_UI_PORT` | Port for Web UI | ui.port |
+| `MORPHEUS_LOGGING_ENABLED` | Enable/disable logging | logging.enabled |
+| `MORPHEUS_LOGGING_LEVEL` | Logging level | logging.level |
+| `MORPHEUS_LOGGING_RETENTION` | Log retention period | logging.retention |
+
+**Precedence Order**: The system follows this order of precedence when resolving configuration values:
+1. Provider-specific environment variable (e.g., `OPENAI_API_KEY`) - Highest priority
+2. Generic environment variable (e.g., `MORPHEUS_LLM_API_KEY`) - Medium priority
+3. Configuration file value (e.g., `config.llm.api_key`) - Lower priority
+4. Default value - Lowest priority
+
+> **Note**: If `THE_ARCHITECT_PASS` is not set, the system will use the default password `iamthearchitect`. This is less secure and it's recommended to set your own password in production environments.
+
 **Option 1: Using a `.env` file**
 Create a `.env` file in the root of your project:
 
 ```env
+OPENAI_API_KEY="your-openai-api-key"
+ANTHROPIC_API_KEY="your-anthropic-api-key"
+GOOGLE_API_KEY="your-google-api-key"
 THE_ARCHITECT_PASS="your-secure-password"
+TELEGRAM_BOT_TOKEN="your-telegram-bot-token"
+OPENROUTER_API_KEY="your-openrouter-api-key"
 ```
 
 **Option 2: Using Shell export**
 
 ```bash
+export OPENAI_API_KEY="your-openai-api-key"
+export ANTHROPIC_API_KEY="your-anthropic-api-key"
+export GOOGLE_API_KEY="your-google-api-key"
+export OPENROUTER_API_KEY="your-openrouter-api-key"
 export THE_ARCHITECT_PASS="your-secure-password"
+export TELEGRAM_BOT_TOKEN="your-telegram-bot-token"
 morpheus start
 ```
 
@@ -333,6 +396,90 @@ npm run test:watch
 - [ ] **Discord Adapter**: Support for Discord interactions.
 - [ ] **Plugin System**: Extend functionality via external modules.
 
+## 🕵️ Privacy Protection
+
+The Web UI includes privacy protection headers to prevent indexing by search engines:
+- HTML meta tags: `<meta name="robots" content="noindex, nofollow">`
+- HTTP header: `X-Robots-Tag: noindex, nofollow`
+
+This ensures that your private agent dashboard remains private and is not discoverable by search engines.
+
+## 🐳 Running with Docker
+
+Morpheus can be easily deployed using Docker and Docker Compose. The container supports all environment variables for configuration.
+
+### Prerequisites
+
+- Docker Engine
+- Docker Compose
+
+### Quick Start
+
+1. Create a `.env` file with your configuration:
+
+```bash
+cp .env.example .env
+# Edit .env with your actual API keys and settings
+```
+
+2. Build and start the container:
+
+```bash
+docker-compose up -d
+```
+
+3. Access the Web UI at `http://localhost:3333`
+
+### Using Docker Directly
+
+```bash
+# Build the image
+docker build -t morpheus .
+
+# Run with environment variables
+docker run -d \
+  --name morpheus-agent \
+  -p 3333:3333 \
+  -v morpheus_data:/root/.morpheus \
+  -e MORPHEUS_LLM_PROVIDER=openai \
+  -e OPENAI_API_KEY=your-api-key-here \
+  -e THE_ARCHITECT_PASS=your-password \
+  morpheus
+```
+
+### Environment Variables in Docker
+
+All environment variables described above work in Docker. The precedence order remains the same:
+1. Container environment variables
+2. Configuration file values
+3. Default values
+
+### Persistent Data
+
+The container stores configuration and data in `/root/.morpheus`. Mount a volume to persist data between container restarts:
+
+```yaml
+volumes:
+  - morpheus_data:/root/.morpheus  # Recommended for persistence
+```
+
+### Health Check
+
+The container includes a health check that verifies the health endpoint is accessible. The application exposes a public `/health` endpoint that doesn't require authentication:
+
+```bash
+curl http://localhost:3333/health
+```
+
+Response:
+```json
+{
+  "status": "healthy",
+  "timestamp": "2026-02-05T21:30:00.000Z",
+  "uptime": 123.45
+}
+```
+
 ## Contributing
 
 1.  Fork the repository.

package/dist/channels/telegram.js

@@ -105,7 +105,7 @@ export class TelegramAdapter {
                     await ctx.reply(`🎤 *Transcription*: _"${text}"_`, { parse_mode: 'Markdown' });
                     await ctx.sendChatAction('typing');
                     // Process with Agent
-                    const response = await this.oracle.chat(text, usage);
+                    const response = await this.oracle.chat(text, usage, true);
                     // if (listeningMsg) {
                     //   try {
                     //     await ctx.telegram.deleteMessage(ctx.chat.id, listeningMsg.message_id);

package/dist/cli/commands/doctor.js

@@ -47,6 +47,68 @@ export const doctorCommand = new Command('doctor')
             else if (deprecatedLimit !== undefined && contextWindow !== undefined) {
                 console.log(chalk.yellow('⚠') + ' Found both \'memory.limit\' and \'llm.context_window\'. Remove \'memory.limit\' from config.');
             }
+            // Check API keys availability for active providers
+            const llmProvider = config.llm?.provider;
+            const santiProvider = config.santi?.provider;
+            // Check LLM provider API key
+            if (llmProvider && llmProvider !== 'ollama') {
+                const hasLlmApiKey = config.llm?.api_key ||
+                    (llmProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (llmProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (llmProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (llmProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasLlmApiKey) {
+                    console.log(chalk.green('✓') + ` LLM API key available for ${llmProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` LLM API key missing for ${llmProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
+            // Check Santi provider API key
+            if (santiProvider && santiProvider !== 'ollama') {
+                const hasSantiApiKey = config.santi?.api_key ||
+                    (santiProvider === 'openai' && process.env.OPENAI_API_KEY) ||
+                    (santiProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
+                    (santiProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
+                    (santiProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
+                if (hasSantiApiKey) {
+                    console.log(chalk.green('✓') + ` Santi API key available for ${santiProvider}`);
+                }
+                else {
+                    console.log(chalk.red('✗') + ` Santi API key missing for ${santiProvider}. Either set in config or define environment variable.`);
+                    allPassed = false;
+                }
+            }
+            // Check audio API key if enabled
+            if (config.audio?.enabled && config.llm?.provider !== 'gemini') {
+                const hasAudioApiKey = config.audio?.apiKey || process.env.GOOGLE_API_KEY;
+                if (hasAudioApiKey) {
+                    console.log(chalk.green('✓') + ' Audio API key available for transcription');
+                }
+                else {
+                    console.log(chalk.red('✗') + ' Audio API key missing. Either set in config or define GOOGLE_API_KEY environment variable.');
+                    allPassed = false;
+                }
+            }
+            // Check Telegram token if enabled
+            if (config.channels?.telegram?.enabled) {
+                const hasTelegramToken = config.channels.telegram?.token || process.env.TELEGRAM_BOT_TOKEN;
+                if (hasTelegramToken) {
+                    console.log(chalk.green('✓') + ' Telegram bot token available');
+                }
+                else {
+                    console.log(chalk.red('✗') + ' Telegram bot token missing. Either set in config or define TELEGRAM_BOT_TOKEN environment variable.');
+                    allPassed = false;
+                }
+            }
+            // Check if default password is being used for dashboard
+            if (!process.env.THE_ARCHITECT_PASS) {
+                console.log(chalk.yellow('⚠') + ' Using default password for dashboard (iamthearchitect). For security, set THE_ARCHITECT_PASS environment variable.');
+            }
+            else {
+                console.log(chalk.green('✓') + ' Custom dashboard password set');
+            }
         }
         else {
             console.log(chalk.yellow('!') + ' Configuration: Missing (will be created on start)');

package/dist/cli/commands/init.js

@@ -30,6 +30,7 @@ export const initCommand = new Command('init')
             choices: [
                 { name: 'OpenAI', value: 'openai' },
                 { name: 'Anthropic', value: 'anthropic' },
+                { name: 'OpenRouter', value: 'openrouter' },
                 { name: 'Ollama', value: 'ollama' },
                 { name: 'Google Gemini', value: 'gemini' },
             ],
@@ -43,6 +44,9 @@ export const initCommand = new Command('init')
             case 'anthropic':
                 defaultModel = 'claude-3-5-sonnet-20240620';
                 break;
+            case 'openrouter':
+                defaultModel = 'openrouter/auto';
+                break;
             case 'ollama':
                 defaultModel = 'llama3';
                 break;
@@ -59,10 +63,23 @@ export const initCommand = new Command('init')
         });
         let apiKey;
         const hasExistingKey = !!currentConfig.llm.api_key;
-        const apiKeyMessage = hasExistingKey
+        let apiKeyMessage = hasExistingKey
             ? 'Enter API Key (leave empty to preserve existing, or if using env vars):'
             : 'Enter API Key (leave empty if using env vars):';
-        if (provider !== 'ollama') {
+        // Add info about environment variables to the message
+        if (provider === 'openai') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: OPENAI_API_KEY)`;
+        }
+        else if (provider === 'anthropic') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: ANTHROPIC_API_KEY)`;
+        }
+        else if (provider === 'gemini') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: GOOGLE_API_KEY)`;
+        }
+        else if (provider === 'openrouter') {
+            apiKeyMessage = `${apiKeyMessage} (Env var: OPENROUTER_API_KEY)`;
+        }
+        if (provider !== 'ollama' && provider !== 'openrouter') {
             apiKey = await password({
                 message: apiKeyMessage,
             });
@@ -75,6 +92,14 @@ export const initCommand = new Command('init')
         if (apiKey) {
             await configManager.set('llm.api_key', apiKey);
         }
+        // Base URL Configuration for OpenRouter
+        if (provider === 'openrouter') {
+            const baseUrl = await input({
+                message: 'Enter OpenRouter Base URL:',
+                default: currentConfig.llm.base_url || 'https://openrouter.ai/api/v1',
+            });
+            await configManager.set('llm.base_url', baseUrl);
+        }
         // Context Window Configuration
         const contextWindow = await input({
             message: 'Context Window Size (number of messages to send to LLM):',
@@ -105,6 +130,7 @@ export const initCommand = new Command('init')
                 choices: [
                     { name: 'OpenAI', value: 'openai' },
                     { name: 'Anthropic', value: 'anthropic' },
+                    { name: 'OpenRouter', value: 'openrouter' },
                     { name: 'Ollama', value: 'ollama' },
                     { name: 'Google Gemini', value: 'gemini' },
                 ],
@@ -118,6 +144,9 @@ export const initCommand = new Command('init')
                 case 'anthropic':
                     defaultSatiModel = 'claude-3-5-sonnet-20240620';
                     break;
+                case 'openrouter':
+                    defaultSatiModel = 'openrouter/auto';
+                    break;
                 case 'ollama':
                     defaultSatiModel = 'llama3';
                     break;
@@ -133,9 +162,22 @@ export const initCommand = new Command('init')
                 default: defaultSatiModel,
             });
             const hasExistingSatiKey = !!currentConfig.santi?.api_key;
-            const santiKeyMsg = hasExistingSatiKey
-                ? 'Enter Sati API Key (leave empty to preserve existing):'
-                : 'Enter Sati API Key:';
+            let santiKeyMsg = hasExistingSatiKey
+                ? 'Enter Sati API Key (leave empty to preserve existing, or if using env vars):'
+                : 'Enter Sati API Key (leave empty if using env vars):';
+            // Add info about environment variables to the message
+            if (santiProvider === 'openai') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: OPENAI_API_KEY)`;
+            }
+            else if (santiProvider === 'anthropic') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: ANTHROPIC_API_KEY)`;
+            }
+            else if (santiProvider === 'gemini') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: GOOGLE_API_KEY)`;
+            }
+            else if (santiProvider === 'openrouter') {
+                santiKeyMsg = `${santiKeyMsg} (Env var: OPENROUTER_API_KEY)`;
+            }
             const keyInput = await password({ message: santiKeyMsg });
             if (keyInput) {
                 santiApiKey = keyInput;
@@ -146,6 +188,14 @@ export const initCommand = new Command('init')
             else {
                 santiApiKey = undefined; // Ensure we don't accidentally carry over invalid state
             }
+            // Base URL Configuration for Sati OpenRouter
+            if (santiProvider === 'openrouter') {
+                const satiBaseUrl = await input({
+                    message: 'Enter Sati OpenRouter Base URL:',
+                    default: currentConfig.santi?.base_url || 'https://openrouter.ai/api/v1',
+                });
+                await configManager.set('santi.base_url', satiBaseUrl);
+            }
         }
         const memoryLimit = await input({
             message: 'Sati Memory Retrieval Limit (messages):',
@@ -171,9 +221,11 @@ export const initCommand = new Command('init')
             }
             else {
                 const hasExistingAudioKey = !!currentConfig.audio?.apiKey;
-                const audioKeyMessage = hasExistingAudioKey
-                    ? 'Enter Gemini API Key for Audio (leave empty to preserve existing):'
-                    : 'Enter Gemini API Key for Audio:';
+                let audioKeyMessage = hasExistingAudioKey
+                    ? 'Enter Gemini API Key for Audio (leave empty to preserve existing, or if using env vars):'
+                    : 'Enter Gemini API Key for Audio (leave empty if using env vars):';
+                // Add info about environment variables to the message
+                audioKeyMessage = `${audioKeyMessage} (Env var: GOOGLE_API_KEY)`;
                 audioKey = await password({
                     message: audioKeyMessage,
                 });
@@ -210,10 +262,13 @@ export const initCommand = new Command('init')
                 display.log(chalk.gray('1. Create a bot via @BotFather to get your token.'));
                 display.log(chalk.gray('2. Get your User ID via @userinfobot.\n'));
                 const hasExistingToken = !!currentConfig.channels.telegram?.token;
+                let telegramTokenMessage = hasExistingToken
+                    ? 'Enter Telegram Bot Token (leave empty to preserve existing, or if using env vars):'
+                    : 'Enter Telegram Bot Token (leave empty if using env vars):';
+                // Add info about environment variables to the message
+                telegramTokenMessage = `${telegramTokenMessage} (Env var: TELEGRAM_BOT_TOKEN)`;
                 const token = await password({
-                    message: hasExistingToken
-                        ? 'Enter Telegram Bot Token (leave empty to preserve existing):'
-                        : 'Enter Telegram Bot Token:',
+                    message: telegramTokenMessage,
                     validate: (value) => {
                         if (value.length > 0)
                             return true;

package/dist/config/manager.js

@@ -5,6 +5,7 @@ import { PATHS } from './paths.js';
 import { setByPath } from './utils.js';
 import { ConfigSchema } from './schemas.js';
 import { migrateConfigFile } from '../runtime/migration.js';
+import { resolveApiKey, resolveModel, resolveNumeric, resolveString, resolveBoolean, resolveProvider, resolveStringArray } from './precedence.js';
 export class ConfigManager {
     static instance;
     config = DEFAULT_CONFIG;
@@ -18,16 +19,15 @@ export class ConfigManager {
     async load() {
         try {
             await migrateConfigFile();
+            let rawConfig = DEFAULT_CONFIG;
             if (await fs.pathExists(PATHS.config)) {
                 const raw = await fs.readFile(PATHS.config, 'utf8');
                 const parsed = yaml.load(raw);
                 // Validate and merge with defaults via Zod
-                this.config = ConfigSchema.parse(parsed);
-            }
-            else {
-                // File doesn't exist, use defaults
-                this.config = DEFAULT_CONFIG;
+                rawConfig = ConfigSchema.parse(parsed);
             }
+            // Apply environment variable precedence to the loaded config
+            this.config = this.applyEnvironmentVariablePrecedence(rawConfig);
         }
         catch (error) {
             console.error('Failed to load configuration:', error);
@@ -36,6 +36,85 @@ export class ConfigManager {
         }
         return this.config;
     }
+    applyEnvironmentVariablePrecedence(config) {
+        // Apply precedence to agent config
+        const agentConfig = {
+            name: resolveString('MORPHEUS_AGENT_NAME', config.agent.name, DEFAULT_CONFIG.agent.name),
+            personality: resolveString('MORPHEUS_AGENT_PERSONALITY', config.agent.personality, DEFAULT_CONFIG.agent.personality)
+        };
+        // Apply precedence to LLM config
+        const llmProvider = resolveProvider('MORPHEUS_LLM_PROVIDER', config.llm.provider, DEFAULT_CONFIG.llm.provider);
+        const llmConfig = {
+            provider: llmProvider,
+            model: resolveModel(llmProvider, 'MORPHEUS_LLM_MODEL', config.llm.model),
+            temperature: resolveNumeric('MORPHEUS_LLM_TEMPERATURE', config.llm.temperature, DEFAULT_CONFIG.llm.temperature),
+            max_tokens: config.llm.max_tokens !== undefined ? resolveNumeric('MORPHEUS_LLM_MAX_TOKENS', config.llm.max_tokens, config.llm.max_tokens) : undefined,
+            api_key: resolveApiKey(llmProvider, 'MORPHEUS_LLM_API_KEY', config.llm.api_key),
+            base_url: config.llm.base_url, // base_url doesn't have environment variable precedence for now
+            context_window: config.llm.context_window !== undefined ? resolveNumeric('MORPHEUS_LLM_CONTEXT_WINDOW', config.llm.context_window, DEFAULT_CONFIG.llm.context_window) : undefined
+        };
+        // Apply precedence to Sati config
+        let santiConfig;
+        if (config.santi) {
+            const santiProvider = resolveProvider('MORPHEUS_SANTI_PROVIDER', config.santi.provider, llmConfig.provider);
+            santiConfig = {
+                provider: santiProvider,
+                model: resolveModel(santiProvider, 'MORPHEUS_SANTI_MODEL', config.santi.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_SANTI_TEMPERATURE', config.santi.temperature, llmConfig.temperature),
+                max_tokens: config.santi.max_tokens !== undefined ? resolveNumeric('MORPHEUS_SANTI_MAX_TOKENS', config.santi.max_tokens, config.santi.max_tokens) : llmConfig.max_tokens,
+                api_key: resolveApiKey(santiProvider, 'MORPHEUS_SANTI_API_KEY', config.santi.api_key || llmConfig.api_key),
+                base_url: config.santi.base_url || config.llm.base_url,
+                context_window: config.santi.context_window !== undefined ? resolveNumeric('MORPHEUS_SANTI_CONTEXT_WINDOW', config.santi.context_window, config.santi.context_window) : llmConfig.context_window,
+                memory_limit: config.santi.memory_limit !== undefined ? resolveNumeric('MORPHEUS_SANTI_MEMORY_LIMIT', config.santi.memory_limit, config.santi.memory_limit) : undefined
+            };
+        }
+        // Apply precedence to audio config
+        const audioConfig = {
+            provider: config.audio.provider, // Audio provider is fixed as 'google'
+            model: resolveString('MORPHEUS_AUDIO_MODEL', config.audio.model, DEFAULT_CONFIG.audio.model),
+            enabled: resolveBoolean('MORPHEUS_AUDIO_ENABLED', config.audio.enabled, DEFAULT_CONFIG.audio.enabled),
+            apiKey: resolveApiKey('gemini', 'MORPHEUS_AUDIO_API_KEY', config.audio.apiKey),
+            maxDurationSeconds: resolveNumeric('MORPHEUS_AUDIO_MAX_DURATION', config.audio.maxDurationSeconds, DEFAULT_CONFIG.audio.maxDurationSeconds),
+            supportedMimeTypes: config.audio.supportedMimeTypes
+        };
+        // Apply precedence to channel configs
+        const channelsConfig = {
+            telegram: {
+                enabled: resolveBoolean('MORPHEUS_TELEGRAM_ENABLED', config.channels.telegram.enabled, DEFAULT_CONFIG.channels.telegram.enabled),
+                token: resolveString('MORPHEUS_TELEGRAM_TOKEN', config.channels.telegram.token, config.channels.telegram.token || ''),
+                allowedUsers: resolveStringArray('MORPHEUS_TELEGRAM_ALLOWED_USERS', config.channels.telegram.allowedUsers, DEFAULT_CONFIG.channels.telegram.allowedUsers)
+            },
+            discord: {
+                enabled: config.channels.discord.enabled, // Discord doesn't have env var precedence for now
+                token: config.channels.discord.token
+            }
+        };
+        // Apply precedence to UI config
+        const uiConfig = {
+            enabled: resolveBoolean('MORPHEUS_UI_ENABLED', config.ui.enabled, DEFAULT_CONFIG.ui.enabled),
+            port: resolveNumeric('MORPHEUS_UI_PORT', config.ui.port, DEFAULT_CONFIG.ui.port)
+        };
+        // Apply precedence to logging config
+        const loggingConfig = {
+            enabled: resolveBoolean('MORPHEUS_LOGGING_ENABLED', config.logging.enabled, DEFAULT_CONFIG.logging.enabled),
+            level: resolveString('MORPHEUS_LOGGING_LEVEL', config.logging.level, DEFAULT_CONFIG.logging.level),
+            retention: resolveString('MORPHEUS_LOGGING_RETENTION', config.logging.retention, DEFAULT_CONFIG.logging.retention)
+        };
+        // Memory config (deprecated, but keeping for backward compatibility)
+        const memoryConfig = {
+            limit: config.memory.limit // Not applying env var precedence to deprecated field
+        };
+        return {
+            agent: agentConfig,
+            llm: llmConfig,
+            santi: santiConfig,
+            audio: audioConfig,
+            channels: channelsConfig,
+            ui: uiConfig,
+            logging: loggingConfig,
+            memory: memoryConfig
+        };
+    }
     get() {
         return this.config;
     }

package/dist/config/precedence.js

@@ -0,0 +1,138 @@
+/**
+ * Functions to resolve configuration values with precedence:
+ * 1. Provider-specific environment variable (e.g., OPENAI_API_KEY)
+ * 2. Generic environment variable (e.g., MORPHEUS_LLM_API_KEY)
+ * 3. Configuration file value
+ * 4. Default value
+ */
+/**
+ * Resolve an API key with provider-specific precedence
+ * @param provider The current provider
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @returns The resolved API key value
+ */
+export function resolveApiKey(provider, genericEnvVar, configFileValue) {
+    // Map provider to its specific environment variable
+    const providerSpecificVars = {
+        'openai': 'OPENAI_API_KEY',
+        'anthropic': 'ANTHROPIC_API_KEY',
+        'openrouter': 'OPENROUTER_API_KEY',
+        'ollama': '', // Ollama typically doesn't need an API key
+        'gemini': 'GOOGLE_API_KEY'
+    };
+    const providerSpecificVar = providerSpecificVars[provider];
+    // Check provider-specific variable first, then generic, then config file
+    if (providerSpecificVar && process.env[providerSpecificVar]) {
+        return process.env[providerSpecificVar];
+    }
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    return configFileValue;
+}
+/**
+ * Resolve a model name with provider-specific precedence
+ * @param provider The current provider
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @returns The resolved model name value
+ */
+export function resolveModel(provider, genericEnvVar, configFileValue) {
+    // For now, we don't have provider-specific model variables, but we could add them later
+    // Check generic variable first, then config file
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    return configFileValue;
+}
+/**
+ * Resolve a numeric configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved numeric value
+ */
+export function resolveNumeric(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar] !== undefined && process.env[genericEnvVar] !== '') {
+        const envValue = Number(process.env[genericEnvVar]);
+        if (!isNaN(envValue)) {
+            return envValue;
+        }
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve a string configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved string value
+ */
+export function resolveString(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve a boolean configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved boolean value
+ */
+export function resolveBoolean(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar] !== undefined) {
+        const envValue = process.env[genericEnvVar]?.toLowerCase();
+        if (envValue === 'true' || envValue === '1') {
+            return true;
+        }
+        else if (envValue === 'false' || envValue === '0') {
+            return false;
+        }
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve an array of string configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved array of strings value
+ */
+export function resolveStringArray(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar]) {
+        // Split the environment variable by commas and trim whitespace
+        return process.env[genericEnvVar].split(',').map(item => item.trim()).filter(item => item.length > 0);
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}
+/**
+ * Resolve a provider configuration value
+ * @param genericEnvVar The generic environment variable name
+ * @param configFileValue The value from the config file
+ * @param defaultValue The default value to use if none is found
+ * @returns The resolved provider value
+ */
+export function resolveProvider(genericEnvVar, configFileValue, defaultValue) {
+    if (process.env[genericEnvVar]) {
+        return process.env[genericEnvVar];
+    }
+    if (configFileValue !== undefined) {
+        return configFileValue;
+    }
+    return defaultValue;
+}

package/dist/config/schemas.js

@@ -2,17 +2,19 @@ import { z } from 'zod';
 import { DEFAULT_CONFIG } from '../types/config.js';
 export const AudioConfigSchema = z.object({
     provider: z.enum(['google']).default(DEFAULT_CONFIG.audio.provider),
+    model: z.string().min(1).default(DEFAULT_CONFIG.audio.model),
     enabled: z.boolean().default(DEFAULT_CONFIG.audio.enabled),
     apiKey: z.string().optional(),
     maxDurationSeconds: z.number().default(DEFAULT_CONFIG.audio.maxDurationSeconds),
     supportedMimeTypes: z.array(z.string()).default(DEFAULT_CONFIG.audio.supportedMimeTypes),
 });
 export const LLMConfigSchema = z.object({
-    provider: z.enum(['openai', 'anthropic', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
+    provider: z.enum(['openai', 'anthropic', 'openrouter', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
     model: z.string().min(1).default(DEFAULT_CONFIG.llm.model),
     temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
     max_tokens: z.number().int().positive().optional(),
     api_key: z.string().optional(),
+    base_url: z.string().optional(),
     context_window: z.number().int().positive().optional(),
 });
 export const SatiConfigSchema = LLMConfigSchema.extend({