4runr-os 1.0.9 → 1.0.12

package/dist/index.js

@@ -8,6 +8,9 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { GatewayClient } from './gateway-client.js';
+import { executeLocalModel, verifyLocalModelServer } from './local-model-executor.js';
+import { checkOllamaInstallation, installOllama, startOllamaServer, downloadModel, verifyLocalExecution } from './local-setup.js';
+import { loadSession, clearSession, createSession, isSessionValid, getSessionTimeRemaining, getUserAgentsPath, getUserToolsPath } from './auth.js';
 // ANSI colors
 const colors = {
     reset: '\x1b[0m',
@@ -23,13 +26,23 @@ const colors = {
     brightGreen: '\x1b[1m\x1b[32m'
 };
 const { cyan, green, yellow, blue, magenta, red, gray, bright, reset, dim, brightGreen } = colors;
-let client;
+let client = null;
 let systemReady = false;
+let gatewayConnected = false;
+let localMode = false; // Run without gateway (local-only)
+let currentUser = null; // Current logged-in user
+let sessionCheckInterval = null; // Session expiry checker
 // Gateway URL - configurable via GATEWAY_URL environment variable or config file
-// Default: Official 4Runr server
+// Default: Official 4Runr server (but connection requires login)
 // Override: Set GATEWAY_URL environment variable
 // Local dev: Set GATEWAY_URL=http://localhost:3001
 let gatewayUrl = process.env.GATEWAY_URL || 'http://44.222.212.152';
+// Parse command line args
+const args = process.argv.slice(2);
+if (args.includes('--local')) {
+    localMode = true;
+    gatewayUrl = '';
+}
 // Chat mode state
 let chatMode = false;
 let chatAgent = null;
@@ -51,8 +64,11 @@ function getConfigDir() {
     }
     return configDir;
 }
-// Get agents file path
+// Get agents file path (user-specific if logged in)
 function getAgentsFilePath() {
+    if (currentUser) {
+        return getUserAgentsPath(currentUser.username);
+    }
     return path.join(getConfigDir(), 'agents.json');
 }
 // Load custom agents from file
@@ -82,8 +98,11 @@ function saveCustomAgents() {
         console.error(`Failed to save agents: ${error.message}`);
     }
 }
-// Get tools file path
+// Get tools file path (user-specific if logged in)
 function getToolsFilePath() {
+    if (currentUser) {
+        return getUserToolsPath(currentUser.username);
+    }
     return path.join(getConfigDir(), 'tools.json');
 }
 // Load custom tools from file
@@ -143,41 +162,90 @@ ${reset}`);
     await progress(['gateway', 'sentinel', 'shield', 'devkit', 'metrics', 'ai-providers']);
     console.log(`${gray}[BOOT] Starting services...${reset}`);
     await sleep(200);
-    // Check gateway connection
-    process.stdout.write(`${gray}[BOOT] Connecting to gateway (${gatewayUrl})... ${reset}`);
-    try {
-        client = new GatewayClient({ gatewayUrl });
-        const health = await client.health();
-        console.log(`${green}✓${reset}`);
-        // Check database
-        process.stdout.write(`${gray}[BOOT] Connecting to database... ${reset}`);
-        await sleep(200);
-        console.log(`${green}✓${reset} ${gray}(${health.persistence})${reset}`);
-        // Check Redis
-        process.stdout.write(`${gray}[BOOT] Connecting to cache... ${reset}`);
-        await sleep(200);
-        console.log(`${green}✓${reset} ${gray}(redis)${reset}`);
-        // Check Sentinel
-        process.stdout.write(`${gray}[BOOT] Starting Sentinel monitor... ${reset}`);
-        try {
-            const sentinelRes = await fetch(`${gatewayUrl}/sentinel/health`);
-            const sentinel = await sentinelRes.json();
-            console.log(`${green}✓${reset} ${gray}(${sentinel?.status || 'unknown'})${reset}`);
+    // Check for existing session
+    const savedSession = loadSession();
+    if (savedSession && isSessionValid(savedSession)) {
+        currentUser = savedSession;
+        console.log(`${dim}[BOOT] Session restored: ${green}${savedSession.username}${reset}${dim} (${getSessionTimeRemaining(savedSession)}m remaining)${reset}`);
+        // Try to reconnect to gateway
+        if (!localMode && (savedSession.gatewayUrl || gatewayUrl)) {
+            const urlToUse = savedSession.gatewayUrl || gatewayUrl;
+            process.stdout.write(`${gray}[BOOT] Reconnecting to gateway... ${reset}`);
+            try {
+                client = new GatewayClient({ gatewayUrl: urlToUse });
+                const health = await client.health();
+                console.log(`${green}✓${reset}`);
+                gatewayConnected = true;
+                gatewayUrl = urlToUse;
+            }
+            catch (error) {
+                console.log(`${yellow}✗${reset} ${dim}(offline)${reset}`);
+                gatewayConnected = false;
+            }
+        }
+    }
+    else {
+        // No session - user needs to login
+        if (localMode) {
+            console.log(`${dim}[BOOT] Mode: ${green}Local-only${reset} ${dim}(no login required)${reset}`);
         }
-        catch {
-            console.log(`${yellow}⚠${reset} ${gray}(not available)${reset}`);
+        else {
+            console.log(`${dim}[BOOT] Not connected${reset}`);
+            console.log(`${dim}Use ${bright}connect <username>${reset}${dim} to access mainframe${reset}`);
+            console.log(`${dim}Or run in ${bright}--local${reset}${dim} mode for offline use${reset}`);
         }
-        await sleep(300);
-        console.log(`\n${green}${bright}[READY] 4Runr OS is ready!${reset}\n`);
-        systemReady = true;
     }
-    catch (error) {
-        console.log(`${red}✗${reset}`);
-        console.log(`${red}[ERROR] Failed to connect to gateway at ${gatewayUrl}${reset}`);
-        console.log(`${yellow}Make sure the gateway is running on the Ubuntu server${reset}`);
-        process.exit(1);
+    await sleep(300);
+    console.log(`\n${green}${bright}[READY] 4Runr OS is ready!${reset}`);
+    if (currentUser) {
+        console.log(`${dim}Connected as: ${green}${currentUser.username}${reset}${dim} | Session: ${getSessionTimeRemaining(currentUser)}m${reset}`);
+    }
+    else if (!localMode) {
+        console.log(`${dim}Mode: ${yellow}Not connected${reset} ${dim}(local mode only)${reset}`);
+        console.log(`${dim}Type ${bright}connect <username>${reset}${dim} to access mainframe${reset}`);
+    }
+    else {
+        console.log(`${dim}Mode: ${green}Local-only${reset} ${dim}(no remote features)${reset}`);
+    }
+    console.log();
+    systemReady = true;
+    // Start session expiry checker
+    if (currentUser && !localMode) {
+        startSessionChecker();
     }
 }
+/**
+ * Start session expiry checker
+ */
+function startSessionChecker() {
+    // Check every 5 minutes
+    sessionCheckInterval = setInterval(() => {
+        if (currentUser && !isSessionValid(currentUser)) {
+            console.log(`\n${yellow}[ ${brightGreen}SESSION${reset}${yellow} ] Link expired${reset}`);
+            console.log(`${dim}Reconnect: ${bright}connect <username>${reset}\n`);
+            handleLogout();
+        }
+    }, 5 * 60 * 1000);
+}
+/**
+ * Stop session checker
+ */
+function stopSessionChecker() {
+    if (sessionCheckInterval) {
+        clearInterval(sessionCheckInterval);
+        sessionCheckInterval = null;
+    }
+}
+/**
+ * Handle logout
+ */
+function handleLogout() {
+    stopSessionChecker();
+    clearSession();
+    currentUser = null;
+    gatewayConnected = false;
+    client = null;
+}
 async function progress(items) {
     for (const item of items) {
         process.stdout.write(`${gray}  - ${item}${reset}`);
@@ -255,8 +323,14 @@ const commands = {
                 console.log(`  ${cyan}get${reset}          Get run details`);
                 console.log(`  ${cyan}list${reset}         List all runs`);
                 console.log();
+                console.log(`${magenta}Connection:${reset}`);
+                console.log(`  ${cyan}connect${reset}      Connect to mainframe (required for remote features)`);
+                console.log(`  ${cyan}disconnect${reset}   Disconnect from mainframe`);
+                console.log(`  ${cyan}whoami${reset}       Show current connection and session info`);
+                console.log();
                 console.log(`${magenta}System:${reset}`);
                 console.log(`  ${cyan}status${reset}       Show system status`);
+                console.log(`  ${cyan}gateway${reset}      Manage gateway connection (connect/disconnect/status)`);
                 console.log(`  ${cyan}sentinel${reset}     Show Sentinel monitoring`);
                 console.log(`  ${cyan}metrics${reset}      Show system metrics`);
                 console.log(`  ${cyan}clear${reset}        Clear the screen`);
@@ -497,11 +571,96 @@ const commands = {
                     console.log(`${red}Invalid choice${reset}\n`);
                     return;
                 }
-                localModelName = await prompt(rl, `${cyan}Model name (e.g., llama2, mistral, gpt-3.5-turbo):${reset} `);
+                // Integrated setup - automatically install and configure
+                console.log(`\n${bright}Setting up local model environment...${reset}`);
+                if (localModelProvider === 'ollama') {
+                    // Check if Ollama is installed
+                    const ollamaCheck = await checkOllamaInstallation();
+                    if (!ollamaCheck.ollamaInstalled) {
+                        console.log(`${yellow}Ollama not found. Installing automatically...${reset}`);
+                        const installResult = await installOllama();
+                        if (!installResult.success) {
+                            console.log(`${red}✗ ${installResult.message}${reset}\n`);
+                            const continueChoice = await prompt(rl, `${yellow}Continue anyway? (y/n):${reset} `);
+                            if (continueChoice?.toLowerCase() !== 'y') {
+                                console.log(`${gray}Agent creation cancelled${reset}\n`);
+                                return;
+                            }
+                        }
+                        else {
+                            console.log(`${green}✓ ${installResult.message}${reset}`);
+                        }
+                    }
+                    // Start server if not running
+                    const serverCheck = await checkOllamaInstallation();
+                    if (!serverCheck.success) {
+                        console.log(`${dim}Starting Ollama server...${reset}`);
+                        const startResult = await startOllamaServer();
+                        if (startResult.success) {
+                            console.log(`${green}✓ ${startResult.message}${reset}`);
+                        }
+                        else {
+                            console.log(`${yellow}⚠ ${startResult.message}${reset}`);
+                        }
+                    }
+                    // Get available models
+                    const finalCheck = await checkOllamaInstallation();
+                    if (finalCheck.modelsAvailable && finalCheck.modelsAvailable.length > 0) {
+                        console.log(`${green}✓ Ollama is ready${reset}`);
+                        console.log(`${dim}Available models: ${finalCheck.modelsAvailable.join(', ')}${reset}`);
+                    }
+                    else {
+                        console.log(`${yellow}⚠ No models installed yet${reset}`);
+                    }
+                }
+                else if (localModelProvider === 'lm-studio') {
+                    // LM Studio - check if running
+                    const verification = await verifyLocalModelServer('lm-studio', localModelUrl);
+                    if (!verification.available) {
+                        console.log(`${yellow}⚠ LM Studio server not running${reset}`);
+                        console.log(`${dim}Please start LM Studio and click "Start Server" in the Chat tab${reset}`);
+                        const continueChoice = await prompt(rl, `${yellow}Continue anyway? (y/n):${reset} `);
+                        if (continueChoice?.toLowerCase() !== 'y') {
+                            console.log(`${gray}Agent creation cancelled${reset}\n`);
+                            return;
+                        }
+                    }
+                    else {
+                        console.log(`${green}✓ LM Studio server is running${reset}`);
+                        if (verification.models && verification.models.length > 0) {
+                            console.log(`${dim}Available models: ${verification.models.join(', ')}${reset}`);
+                        }
+                    }
+                }
+                // Get model name
+                localModelName = await prompt(rl, `\n${cyan}Model name (e.g., llama2, mistral, gpt-3.5-turbo):${reset} `);
                 if (!localModelName) {
                     console.log(`${red}Model name required${reset}\n`);
                     return;
                 }
+                // Auto-download model if using Ollama and model not found
+                if (localModelProvider === 'ollama') {
+                    const finalCheck = await checkOllamaInstallation();
+                    if (finalCheck.modelsAvailable && !finalCheck.modelsAvailable.includes(localModelName)) {
+                        console.log(`\n${yellow}Model '${localModelName}' not found${reset}`);
+                        const downloadChoice = await prompt(rl, `${cyan}Download it now? (y/n):${reset} `);
+                        if (downloadChoice?.toLowerCase() === 'y') {
+                            console.log(`\n${dim}Downloading model (this may take several minutes)...${reset}`);
+                            const downloadResult = await downloadModel(localModelName);
+                            if (downloadResult.success) {
+                                console.log(`${green}✓ ${downloadResult.message}${reset}`);
+                            }
+                            else {
+                                console.log(`${red}✗ ${downloadResult.message}${reset}`);
+                                const continueChoice = await prompt(rl, `${yellow}Continue anyway? (y/n):${reset} `);
+                                if (continueChoice?.toLowerCase() !== 'y') {
+                                    console.log(`${gray}Agent creation cancelled${reset}\n`);
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
                 baseAgent = `local:${localModelProvider}:${localModelName}`;
             }
             else {
@@ -718,7 +877,13 @@ const commands = {
             let agentConfig = null;
             if (customAgent) {
                 // Use custom agent
-                actualAgentId = customAgent.baseAgent;
+                // For local models, use gpt-3.5-turbo as the base executor (gateway handles local models)
+                if (customAgent.useLocalModel) {
+                    actualAgentId = 'gpt-3.5-turbo';
+                }
+                else {
+                    actualAgentId = customAgent.baseAgent;
+                }
                 agentConfig = customAgent;
             }
             else {
@@ -760,6 +925,23 @@ const commands = {
         usage: 'status',
         handler: async () => {
             console.log(`\n${bright}System Status:${reset}`);
+            // Connection status
+            if (currentUser) {
+                console.log(`  ${green}Link:${reset}         Connected as ${currentUser.username}`);
+                console.log(`  ${green}Session:${reset}      ${getSessionTimeRemaining(currentUser)}m remaining`);
+            }
+            else {
+                console.log(`  ${yellow}Link:${reset}         Not connected`);
+            }
+            // Gateway status
+            if (!client || !gatewayConnected) {
+                console.log(`  ${yellow}Mainframe:${reset}    Offline`);
+                if (!currentUser && !localMode) {
+                    console.log(`  ${dim}Use ${bright}connect <username>${reset}${dim} to access mainframe${reset}`);
+                }
+                console.log();
+                return;
+            }
             const health = await client.health();
             console.log(`  Gateway:      ${green}✓${reset} alive`);
             console.log(`  Database:     ${green}✓${reset} ${health.persistence}`);
@@ -780,6 +962,10 @@ const commands = {
         description: 'Create a new run',
         usage: 'create <name> [agent-id]',
         handler: async (args) => {
+            if (!client || !gatewayConnected) {
+                console.log(`${red}Gateway not connected. Use ${bright}gateway connect${reset}${red} first.${reset}\n`);
+                return;
+            }
             if (args.length === 0) {
                 console.log(`${red}Usage: create <name> [agent-id]${reset}\n`);
                 return;
@@ -806,6 +992,10 @@ const commands = {
         description: 'Start a run',
         usage: 'start <run-id>',
         handler: async (args) => {
+            if (!client || !gatewayConnected) {
+                console.log(`${red}Gateway not connected. Use ${bright}gateway connect${reset}${red} first.${reset}\n`);
+                return;
+            }
             if (args.length === 0) {
                 console.log(`${red}Usage: start <run-id>${reset}\n`);
                 return;
@@ -826,6 +1016,10 @@ const commands = {
         description: 'Get run details',
         usage: 'get <run-id>',
         handler: async (args) => {
+            if (!client || !gatewayConnected) {
+                console.log(`${red}Gateway not connected. Use ${bright}gateway connect${reset}${red} first.${reset}\n`);
+                return;
+            }
             if (args.length === 0) {
                 console.log(`${red}Usage: get <run-id>${reset}\n`);
                 return;
@@ -851,6 +1045,10 @@ const commands = {
         description: 'List all runs',
         usage: 'list [limit]',
         handler: async (args) => {
+            if (!client || !gatewayConnected) {
+                console.log(`${red}Gateway not connected. Use ${bright}gateway connect${reset}${red} first.${reset}\n`);
+                return;
+            }
             const limit = args[0] ? parseInt(args[0]) : 10;
             const runs = await client.runs.list({ limit });
             if (runs.length === 0) {
@@ -895,6 +1093,10 @@ const commands = {
         description: 'Show system metrics',
         usage: 'metrics',
         handler: async () => {
+            if (!client || !gatewayConnected) {
+                console.log(`${red}Gateway not connected. Use ${bright}gateway connect${reset}${red} first.${reset}\n`);
+                return;
+            }
             console.log(`${gray}Fetching metrics...${reset}\n`);
             try {
                 const metrics = await client.metrics();
@@ -925,6 +1127,147 @@ const commands = {
             process.exit(0);
         }
     },
+    connect: {
+        description: 'Connect to mainframe (required for remote features)',
+        usage: 'connect <username>',
+        handler: async (args, rl) => {
+            if (localMode) {
+                console.log(`${yellow}Cannot connect in local-only mode${reset}\n`);
+                return;
+            }
+            if (currentUser) {
+                console.log(`${yellow}Already connected as ${currentUser.username}${reset}`);
+                console.log(`${dim}Use ${bright}disconnect${reset}${dim} first to switch users${reset}\n`);
+                return;
+            }
+            if (args.length === 0) {
+                console.log(`${red}Usage: connect <username>${reset}\n`);
+                return;
+            }
+            const username = args.join(' ').trim();
+            console.log(`\n${dim}[ ${brightGreen}CONNECT${reset}${dim} ] Establishing link to mainframe...${reset}`);
+            await sleep(500);
+            console.log(`${dim}[ ${brightGreen}AUTH${reset}${dim} ] Authenticating ${cyan}${username}${reset}${dim}...${reset}`);
+            await sleep(300);
+            // Create session
+            currentUser = createSession(username, gatewayUrl);
+            // Load user-specific data
+            loadCustomAgents();
+            loadCustomTools();
+            // Try to connect to gateway
+            if (gatewayUrl) {
+                try {
+                    client = new GatewayClient({ gatewayUrl });
+                    const health = await client.health();
+                    gatewayConnected = true;
+                    console.log(`${green}[ ${brightGreen}CONNECTED${reset}${green} ] Link established${reset}`);
+                    console.log(`${dim}User: ${green}${username}${reset}${dim} | Session: ${getSessionTimeRemaining(currentUser)}m${reset}\n`);
+                    // Start session checker
+                    startSessionChecker();
+                }
+                catch (error) {
+                    console.log(`${yellow}[ ${brightGreen}PARTIAL${reset}${yellow} ] Connected, but mainframe unavailable${reset}`);
+                    console.log(`${dim}Local features only${reset}\n`);
+                    gatewayConnected = false;
+                }
+            }
+            else {
+                console.log(`${green}[ ${brightGreen}CONNECTED${reset}${green} ] Local mode${reset}\n`);
+            }
+        }
+    },
+    disconnect: {
+        description: 'Disconnect from mainframe',
+        usage: 'disconnect',
+        handler: async () => {
+            if (!currentUser) {
+                console.log(`${yellow}Not connected${reset}\n`);
+                return;
+            }
+            const username = currentUser.username;
+            console.log(`\n${dim}[ ${brightGreen}DISCONNECT${reset}${dim} ] Terminating link for ${cyan}${username}${reset}${dim}...${reset}`);
+            await sleep(300);
+            handleLogout();
+            console.log(`${green}[ ${brightGreen}DISCONNECTED${reset}${green} ] Link terminated${reset}`);
+            console.log(`${dim}Use ${bright}connect <username>${reset}${dim} to reconnect${reset}\n`);
+        }
+    },
+    whoami: {
+        description: 'Show current connection and session info',
+        usage: 'whoami',
+        handler: async () => {
+            console.log(`\n${bright}Connection Status:${reset}`);
+            if (currentUser) {
+                console.log(`  ${green}User:${reset}         ${currentUser.username}`);
+                console.log(`  ${green}Link:${reset}         Connected`);
+                console.log(`  ${green}Session:${reset}      ${getSessionTimeRemaining(currentUser)}m remaining`);
+                console.log(`  ${green}Mainframe:${reset}    ${gatewayConnected ? 'Online' : 'Offline'}`);
+            }
+            else {
+                console.log(`  ${yellow}Link:${reset}         Not connected`);
+                console.log(`  ${yellow}Mode:${reset}         ${localMode ? 'Local-only' : 'Offline'}`);
+            }
+            console.log();
+        }
+    },
+    gateway: {
+        description: 'Manage gateway connection',
+        usage: 'gateway [connect|disconnect|status] [url]',
+        handler: async (args, rl) => {
+            const action = args[0] || 'status';
+            if (action === 'status') {
+                console.log(`\n${bright}Gateway Status:${reset}`);
+                if (localMode) {
+                    console.log(`  ${yellow}Mode: Local-only (gateway disabled)${reset}`);
+                }
+                else if (gatewayConnected && client) {
+                    console.log(`  ${green}Status: Connected${reset}`);
+                    console.log(`  ${dim}URL: ${gatewayUrl}${reset}`);
+                    try {
+                        const health = await client.health();
+                        console.log(`  ${green}✓ Gateway is responding${reset}`);
+                    }
+                    catch (e) {
+                        console.log(`  ${red}✗ Gateway not responding${reset}`);
+                        gatewayConnected = false;
+                    }
+                }
+                else {
+                    console.log(`  ${yellow}Status: Disconnected (offline mode)${reset}`);
+                    console.log(`  ${dim}Use ${bright}gateway connect${reset}${dim} to connect${reset}`);
+                }
+                console.log();
+            }
+            else if (action === 'connect') {
+                const url = args[1] || gatewayUrl || 'http://44.222.212.152';
+                console.log(`\n${dim}Connecting to gateway at ${url}...${reset}`);
+                try {
+                    gatewayUrl = url;
+                    client = new GatewayClient({ gatewayUrl: url });
+                    const health = await client.health();
+                    console.log(`${green}✓ Connected to gateway${reset}`);
+                    console.log(`${dim}URL: ${url}${reset}\n`);
+                    gatewayConnected = true;
+                    localMode = false;
+                }
+                catch (error) {
+                    console.log(`${red}✗ Failed to connect: ${error.message}${reset}`);
+                    console.log(`${dim}Staying in offline mode${reset}\n`);
+                    gatewayConnected = false;
+                }
+            }
+            else if (action === 'disconnect') {
+                console.log(`\n${dim}Disconnecting from gateway...${reset}`);
+                gatewayConnected = false;
+                client = null;
+                console.log(`${green}✓ Disconnected (offline mode active)${reset}\n`);
+            }
+            else {
+                console.log(`${red}Unknown action: ${action}${reset}`);
+                console.log(`${dim}Usage: gateway [connect|disconnect|status]${reset}\n`);
+            }
+        }
+    },
     tools: {
         description: 'Manage tools for agents',
         usage: 'tools [list|create|edit|delete|test] [tool-name]',
@@ -1206,50 +1549,109 @@ async function startREPL() {
             try {
                 // Get custom agent config if available
                 const agentConfig = rl.chatAgentConfig;
-                // Create and execute run
-                const run = await client.runs.create({
-                    name: `${chatAgent}: ${message.substring(0, 50)}...`,
-                    input: {
-                        agent_id: chatAgent,
-                        data: {
-                            prompt: message,
-                            // Include custom agent settings
-                            ...(agentConfig?.systemPrompt && { systemPrompt: agentConfig.systemPrompt }),
-                            ...(agentConfig?.temperature !== undefined && { temperature: agentConfig.temperature }),
-                            ...(agentConfig?.maxTokens !== undefined && { maxTokens: agentConfig.maxTokens }),
-                            ...(conversationHistory.length > 0 && { conversationHistory })
-                        }
+                // Check if this is a local model agent - execute directly (bypass gateway)
+                if (agentConfig?.useLocalModel && agentConfig.localModelProvider && agentConfig.localModelName) {
+                    // Execute locally - this is the REAL local execution
+                    const messages = [];
+                    // Add system prompt
+                    if (agentConfig.systemPrompt) {
+                        messages.push({ role: 'system', content: agentConfig.systemPrompt });
                     }
-                });
-                await client.runs.start(run.id);
-                // Monitor execution
-                let status = await client.runs.get(run.id);
-                while (status.status === 'running' || status.status === 'queued') {
-                    await sleep(500);
-                    status = await client.runs.get(run.id);
-                }
-                // Clear thinking indicator
-                process.stdout.write(`\r${' '.repeat(20)}\r`);
-                if (status.output) {
-                    const output = status.output;
-                    const response = output.result || output.message || JSON.stringify(output, null, 2);
+                    // Add conversation history
+                    if (conversationHistory.length > 0) {
+                        messages.push(...conversationHistory);
+                    }
+                    // Add current message
+                    messages.push({ role: 'user', content: message });
+                    // Execute local model directly
+                    const localConfig = {
+                        provider: agentConfig.localModelProvider,
+                        model: agentConfig.localModelName,
+                        baseUrl: agentConfig.localModelUrl,
+                        temperature: agentConfig.temperature,
+                        maxTokens: agentConfig.maxTokens,
+                        topP: agentConfig.topP,
+                        frequencyPenalty: agentConfig.frequencyPenalty,
+                        presencePenalty: agentConfig.presencePenalty,
+                    };
+                    // PROOF: Verify execution is truly local before executing
+                    const localProof = await verifyLocalExecution();
+                    if (!localProof.isLocal) {
+                        console.log(`${red}⚠ WARNING: Local execution verification failed!${reset}`);
+                        console.log(`${yellow}This may indicate the request is going through a remote server.${reset}\n`);
+                    }
+                    const result = await executeLocalModel(localConfig, messages);
+                    // Clear thinking indicator
+                    process.stdout.write(`\r${' '.repeat(20)}\r`);
                     // Update conversation history
                     conversationHistory.push({ role: 'user', content: message });
-                    conversationHistory.push({ role: 'assistant', content: response });
-                    // Show response with friendly name
-                    const agentConfig = rl.chatAgentConfig;
-                    const friendlyName = agentConfig ? agentConfig.name :
-                        chatAgent === 'gpt-3.5-turbo' ? 'Assistant' :
-                            chatAgent === 'gpt-4' ? 'GPT-4' :
-                                chatAgent;
-                    console.log(`${green}${friendlyName}:${reset} ${response}\n`);
-                    // Show usage if available
-                    if (output.usage) {
-                        console.log(`${gray}Tokens: ${output.usage.totalTokens || 'N/A'} | Cost: $${(output.cost || 0).toFixed(6)}${reset}\n`);
+                    conversationHistory.push({ role: 'assistant', content: result.result });
+                    // Show response with proof it's local
+                    console.log(`${green}${agentConfig.name}:${reset} ${result.result}\n`);
+                    // Show usage and proof
+                    if (result.usage) {
+                        console.log(`${gray}Tokens: ${result.usage.totalTokens || 'N/A'} | Model: ${result.model} | Cost: $0.000000 (local)${reset}`);
+                        console.log(`${dim}✓ Executed locally (${localProof.proof.executionPath}) | Response time: ${localProof.proof.responseTime}ms${reset}\n`);
                     }
                 }
                 else {
-                    console.log(`${yellow}No response received${reset}\n`);
+                    // Remote model - execute through gateway
+                    if (!client || !gatewayConnected) {
+                        console.log(`${red}Mainframe not connected. Use ${bright}connect <username>${reset}${red} for remote agents.${reset}\n`);
+                        rl.prompt();
+                        return;
+                    }
+                    const run = await client.runs.create({
+                        name: `${chatAgent}: ${message.substring(0, 50)}...`,
+                        input: {
+                            agent_id: chatAgent,
+                            data: {
+                                prompt: message,
+                                // Include custom agent settings
+                                ...(agentConfig?.systemPrompt && { systemPrompt: agentConfig.systemPrompt }),
+                                ...(agentConfig?.temperature !== undefined && { temperature: agentConfig.temperature }),
+                                ...(agentConfig?.maxTokens !== undefined && { maxTokens: agentConfig.maxTokens }),
+                                // Advanced parameters
+                                ...(agentConfig?.topP !== undefined && { topP: agentConfig.topP }),
+                                ...(agentConfig?.frequencyPenalty !== undefined && { frequencyPenalty: agentConfig.frequencyPenalty }),
+                                ...(agentConfig?.presencePenalty !== undefined && { presencePenalty: agentConfig.presencePenalty }),
+                                // Tools
+                                ...(agentConfig?.tools && agentConfig.tools.length > 0 && { tools: agentConfig.tools }),
+                                // Always include conversation history for context
+                                conversationHistory: conversationHistory.length > 0 ? conversationHistory : []
+                            }
+                        }
+                    });
+                    await client.runs.start(run.id);
+                    // Monitor execution
+                    let status = await client.runs.get(run.id);
+                    while (status.status === 'running' || status.status === 'queued') {
+                        await sleep(500);
+                        status = await client.runs.get(run.id);
+                    }
+                    // Clear thinking indicator
+                    process.stdout.write(`\r${' '.repeat(20)}\r`);
+                    if (status.output) {
+                        const output = status.output;
+                        const response = output.result || output.message || JSON.stringify(output, null, 2);
+                        // Update conversation history
+                        conversationHistory.push({ role: 'user', content: message });
+                        conversationHistory.push({ role: 'assistant', content: response });
+                        // Show response with friendly name
+                        const agentConfig = rl.chatAgentConfig;
+                        const friendlyName = agentConfig ? agentConfig.name :
+                            chatAgent === 'gpt-3.5-turbo' ? 'Assistant' :
+                                chatAgent === 'gpt-4' ? 'GPT-4' :
+                                    chatAgent;
+                        console.log(`${green}${friendlyName}:${reset} ${response}\n`);
+                        // Show usage if available
+                        if (output.usage) {
+                            console.log(`${gray}Tokens: ${output.usage.totalTokens || 'N/A'} | Cost: $${(output.cost || 0).toFixed(6)}${reset}\n`);
+                        }
+                    }
+                    else {
+                        console.log(`${yellow}No response received${reset}\n`);
+                    }
                 }
             }
             catch (error) {