4runr-os 1.0.6 → 1.0.10

package/dist/index.js

@@ -8,6 +8,8 @@ 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';
 // ANSI colors
 const colors = {
     reset: '\x1b[0m',
@@ -34,7 +36,13 @@ let gatewayUrl = process.env.GATEWAY_URL || 'http://44.222.212.152';
 let chatMode = false;
 let chatAgent = null;
 let conversationHistory = [];
+// Multiline input state
+let multilineMode = false;
+let multilineResolver = null;
+let multilineLines = [];
+let multilineEndMarker = 'END';
 const customAgents = new Map();
+const customTools = new Map();
 // Get config directory path
 function getConfigDir() {
     const homeDir = os.homedir();
@@ -76,6 +84,37 @@ function saveCustomAgents() {
         console.error(`Failed to save agents: ${error.message}`);
     }
 }
+// Get tools file path
+function getToolsFilePath() {
+    return path.join(getConfigDir(), 'tools.json');
+}
+// Load custom tools from file
+function loadCustomTools() {
+    try {
+        const filePath = getToolsFilePath();
+        if (fs.existsSync(filePath)) {
+            const data = fs.readFileSync(filePath, 'utf-8');
+            const tools = JSON.parse(data);
+            tools.forEach(tool => {
+                customTools.set(tool.name.toLowerCase(), tool);
+            });
+        }
+    }
+    catch (error) {
+        // Silently fail - file might not exist yet
+    }
+}
+// Save custom tools to file
+function saveCustomTools() {
+    try {
+        const filePath = getToolsFilePath();
+        const tools = Array.from(customTools.values());
+        fs.writeFileSync(filePath, JSON.stringify(tools, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error(`Failed to save tools: ${error.message}`);
+    }
+}
 const aiConfig = {
     provider: null,
     model: null,
@@ -173,26 +212,14 @@ function promptMultiline(rl, question, endMarker = 'END') {
     return new Promise((resolve) => {
         console.log(question);
         console.log(`${gray}Enter your text. Type '${endMarker}' on a new line when finished:${reset}\n`);
-        const lines = [];
-        let collecting = true;
-        const lineHandler = (line) => {
-            if (!collecting)
-                return;
-            const trimmed = line.trim();
-            // Check for end marker
-            if (trimmed === endMarker || trimmed === endMarker.toUpperCase()) {
-                collecting = false;
-                rl.removeListener('line', lineHandler);
-                rl.setPrompt(`${cyan}4runr>${reset} `);
-                resolve(lines.join('\n').trim());
-                return;
-            }
-            lines.push(line);
-        };
-        // Temporarily change prompt
+        // Set up multiline mode
+        multilineMode = true;
+        multilineResolver = resolve;
+        multilineLines = [];
+        multilineEndMarker = endMarker;
+        // Change prompt to indicate multiline mode
         rl.setPrompt(`${gray}  >${reset} `);
         rl.prompt();
-        rl.on('line', lineHandler);
     });
 }
 // Command handlers
@@ -472,11 +499,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 {
@@ -510,21 +622,55 @@ const commands = {
             const presencePenalty = presPenaltyStr ? parseFloat(presPenaltyStr) : undefined;
             // Tools selection
             console.log(`\n${bright}Available Tools:${reset}`);
-            console.log(`  1. ${cyan}calculator${reset} - Perform math calculations`);
-            console.log(`  2. ${cyan}get_current_time${reset} - Get current date/time`);
-            console.log(`  3. ${cyan}web_search${reset} - Search the web (requires API key)`);
-            console.log(`  4. ${cyan}read_file${reset} - Read files (requires configuration)`);
-            console.log(`  5. ${cyan}None${reset} - No tools`);
-            const toolsChoice = await prompt(rl, `${cyan}Select tools (comma-separated, e.g., 1,2 or 5 for none):${reset} `);
+            const predefinedTools = ['calculator', 'get_current_time', 'web_search', 'read_file'];
+            predefinedTools.forEach((tool, idx) => {
+                console.log(`  ${idx + 1}. ${cyan}${tool}${reset}`);
+            });
+            // Show custom tools
+            let customToolStartIdx = predefinedTools.length + 1;
+            if (customTools.size > 0) {
+                customTools.forEach((tool) => {
+                    console.log(`  ${customToolStartIdx}. ${cyan}${tool.name}${reset} ${gray}(custom)${reset}`);
+                    customToolStartIdx++;
+                });
+            }
+            const noneIdx = customToolStartIdx;
+            const createIdx = noneIdx + 1;
+            console.log(`  ${noneIdx}. ${cyan}None${reset} - No tools`);
+            console.log(`  ${createIdx}. ${cyan}Create New${reset} - Create a custom tool`);
+            const toolsChoice = await prompt(rl, `${cyan}Select tools (comma-separated, e.g., 1,2 or ${noneIdx} for none):${reset} `);
             const tools = [];
-            if (toolsChoice && toolsChoice !== '5') {
-                const toolIndices = toolsChoice.split(',').map(s => parseInt(s.trim()));
-                const toolNames = ['calculator', 'get_current_time', 'web_search', 'read_file'];
-                toolIndices.forEach(idx => {
-                    if (idx >= 1 && idx <= 4) {
-                        tools.push(toolNames[idx - 1]);
+            if (toolsChoice) {
+                const choiceNums = toolsChoice.split(',').map(s => parseInt(s.trim()));
+                choiceNums.forEach(choiceNum => {
+                    if (choiceNum >= 1 && choiceNum <= predefinedTools.length) {
+                        // Predefined tool
+                        tools.push(predefinedTools[choiceNum - 1]);
+                    }
+                    else if (choiceNum > predefinedTools.length && choiceNum < noneIdx) {
+                        // Custom tool
+                        const customToolArray = Array.from(customTools.keys());
+                        const customToolIdx = choiceNum - predefinedTools.length - 1;
+                        if (customToolIdx >= 0 && customToolIdx < customToolArray.length) {
+                            tools.push(customToolArray[customToolIdx]);
+                        }
+                    }
+                    else if (choiceNum === createIdx) {
+                        // Create new tool - handled below
                     }
                 });
+                // If create was selected, handle it
+                if (choiceNums.includes(createIdx)) {
+                    console.log(`\n${yellow}Creating new tool...${reset}`);
+                    console.log(`${gray}After creating the tool, run ${bright}build${reset}${gray} again to add it to this agent${reset}\n`);
+                    // Trigger tools create command
+                    await commands.tools.handler(['create'], rl);
+                    // After creating, ask if they want to add it
+                    const newToolName = await prompt(rl, `${cyan}Tool name to add to this agent (or Enter to skip):${reset} `);
+                    if (newToolName && customTools.has(newToolName.toLowerCase())) {
+                        tools.push(newToolName);
+                    }
+                }
             }
             // Confirm
             console.log(`\n${dim}┌─ AGENT CONFIGURATION ─────────────────────────┐${reset}`);
@@ -588,20 +734,41 @@ const commands = {
         description: 'List available agents',
         usage: 'agents',
         handler: async () => {
-            console.log(`\n${bright}Available Pre-built Agents:${reset}\n`);
-            console.log(`  ${cyan}gpt4-assistant${reset}       General-purpose GPT-4 assistant`);
-            console.log(`  ${cyan}claude-assistant${reset}     General-purpose Claude assistant`);
-            console.log(`  ${cyan}code-reviewer${reset}        Code review and analysis`);
-            console.log(`  ${cyan}data-analyst${reset}         Data analysis and insights`);
-            console.log(`  ${cyan}creative-writer${reset}      Creative writing and content`);
-            console.log(`\n${gray}Use ${bright}build${reset}${gray} to create custom agents${reset}\n`);
+            console.log(`\n${bright}Available Agents:${reset}\n`);
+            // Show built-in agents
+            console.log(`${bright}Built-in Agents:${reset}`);
+            console.log(`  ${cyan}assistant${reset}         GPT-3.5 Assistant (fast, economical)`);
+            console.log(`  ${cyan}gpt4${reset}             GPT-4 Assistant (most capable)`);
+            console.log(`  ${cyan}test${reset}              Test agent (mock, no AI)`);
+            // Show custom agents
+            if (customAgents.size > 0) {
+                console.log(`\n${bright}Custom Agents:${reset}`);
+                customAgents.forEach((agent) => {
+                    const modelInfo = agent.useLocalModel
+                        ? ` (Local: ${agent.localModelProvider}/${agent.localModelName})`
+                        : ` (${agent.baseAgent})`;
+                    const toolsInfo = agent.tools && agent.tools.length > 0
+                        ? ` [Tools: ${agent.tools.join(', ')}]`
+                        : '';
+                    console.log(`  ${cyan}${agent.name}${reset}${modelInfo}${toolsInfo}`);
+                    if (agent.description) {
+                        console.log(`    ${gray}${agent.description}${reset}`);
+                    }
+                });
+            }
+            else {
+                console.log(`\n${gray}No custom agents yet.${reset}`);
+            }
+            console.log(`\n${gray}Use ${bright}build${reset}${gray} to create custom agents${reset}`);
+            console.log(`${gray}Use ${bright}tools${reset}${gray} to manage tools${reset}\n`);
         }
     },
     'run-agent': {
         description: 'Start chatting with an AI agent',
         usage: 'run-agent [agent-name]',
         handler: async (args, rl) => {
-            let agentName = args[0];
+            // Join all args to support multi-word agent names
+            let agentName = args.join(' ').trim();
             // If no agent specified, prompt for one
             if (!agentName) {
                 console.log(`\n${bright}Available Agents:${reset}\n`);
@@ -638,7 +805,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 {
@@ -844,6 +1017,224 @@ const commands = {
             console.log(`${gray}Goodbye!${reset}\n`);
             process.exit(0);
         }
+    },
+    tools: {
+        description: 'Manage tools for agents',
+        usage: 'tools [list|create|edit|delete|test] [tool-name]',
+        handler: async (args, rl) => {
+            const action = args[0] || 'list';
+            if (action === 'list') {
+                console.log(`\n${bright}Available Tools:${reset}\n`);
+                // Predefined tools
+                console.log(`${bright}Predefined Tools:${reset}`);
+                console.log(`  ${cyan}calculator${reset}          - Perform mathematical calculations`);
+                console.log(`  ${cyan}get_current_time${reset}   - Get current date and time`);
+                console.log(`  ${cyan}web_search${reset}           - Search the web (requires API key)`);
+                console.log(`  ${cyan}read_file${reset}            - Read files from filesystem`);
+                // Custom tools
+                if (customTools.size > 0) {
+                    console.log(`\n${bright}Custom Tools:${reset}`);
+                    customTools.forEach((tool) => {
+                        console.log(`  ${cyan}${tool.name}${reset}${tool.description ? ` - ${tool.description}` : ''}`);
+                        if (tool.version) {
+                            console.log(`    ${gray}Version: ${tool.version}${reset}`);
+                        }
+                        if (tool.author) {
+                            console.log(`    ${gray}Author: ${tool.author}${reset}`);
+                        }
+                    });
+                }
+                console.log(`\n${gray}Use ${bright}tools create${reset}${gray} to create a custom tool${reset}`);
+                console.log(`${gray}Use ${bright}tools edit <name>${reset}${gray} to edit a tool${reset}`);
+                console.log(`${gray}Use ${bright}tools delete <name>${reset}${gray} to delete a tool${reset}\n`);
+            }
+            else if (action === 'create') {
+                console.log(`\n${dim}┌─ TOOL BUILDER ───────────────────────────────┐${reset}`);
+                console.log(`${dim}│${reset} ${brightGreen}Create Custom Tool${reset}`);
+                console.log(`${dim}└──────────────────────────────────────────────────┘${reset}\n`);
+                const name = await prompt(rl, `${cyan}Tool name:${reset} `);
+                if (!name) {
+                    console.log(`${red}Tool name required${reset}\n`);
+                    return;
+                }
+                if (customTools.has(name.toLowerCase())) {
+                    console.log(`${red}Tool '${name}' already exists${reset}\n`);
+                    return;
+                }
+                const description = await prompt(rl, `${cyan}Tool description:${reset} `);
+                console.log(`\n${gray}Enter the tool code (JavaScript/TypeScript):${reset}`);
+                console.log(`${gray}The tool function should accept (input: any) and return Promise<any>${reset}`);
+                console.log(`${gray}Type 'END' on a new line when finished:${reset}\n`);
+                const code = await promptMultiline(rl, `${cyan}Tool code:${reset}`, 'END');
+                if (!code || code.trim().length === 0) {
+                    console.log(`${red}Tool code required${reset}\n`);
+                    return;
+                }
+                // Validate code has async function
+                if (!code.includes('async') && !code.includes('Promise')) {
+                    console.log(`${yellow}⚠ Warning: Tool should be async or return a Promise${reset}`);
+                }
+                const version = await prompt(rl, `${cyan}Version (optional, default: 1.0.0):${reset} `) || '1.0.0';
+                const author = await prompt(rl, `${cyan}Author (optional):${reset} `);
+                // Ask for parameters
+                const parameters = [];
+                console.log(`\n${bright}Tool Parameters (optional):${reset}`);
+                console.log(`${gray}Press Enter to skip, or enter parameter details${reset}`);
+                let addParam = true;
+                while (addParam) {
+                    const paramName = await prompt(rl, `${cyan}Parameter name (or Enter to finish):${reset} `);
+                    if (!paramName) {
+                        addParam = false;
+                        break;
+                    }
+                    const paramType = await prompt(rl, `${cyan}Parameter type (string|number|boolean|object):${reset} `) || 'string';
+                    const paramDesc = await prompt(rl, `${cyan}Parameter description:${reset} `);
+                    const paramRequired = await prompt(rl, `${cyan}Required? (yes/no, default: yes):${reset} `);
+                    parameters.push({
+                        name: paramName,
+                        type: paramType,
+                        description: paramDesc,
+                        required: paramRequired.toLowerCase() !== 'no'
+                    });
+                }
+                const tool = {
+                    name,
+                    description: description || '',
+                    code,
+                    parameters: parameters.length > 0 ? parameters : undefined,
+                    version,
+                    author
+                };
+                customTools.set(name.toLowerCase(), tool);
+                saveCustomTools();
+                console.log(`\n${green}✓${reset} Tool created: ${bright}${name}${reset}`);
+                console.log(`  Use ${cyan}tools test ${name}${reset} to test it${reset}`);
+                console.log(`  Add it to agents with: ${cyan}build${reset}${gray} (select tools)${reset}\n`);
+            }
+            else if (action === 'edit') {
+                const toolName = args[1];
+                if (!toolName) {
+                    console.log(`${red}Tool name required${reset}`);
+                    console.log(`${gray}Usage: tools edit <tool-name>${reset}\n`);
+                    return;
+                }
+                const tool = customTools.get(toolName.toLowerCase());
+                if (!tool) {
+                    console.log(`${red}Tool '${toolName}' not found${reset}\n`);
+                    return;
+                }
+                console.log(`\n${bright}Editing tool: ${tool.name}${reset}\n`);
+                const newDescription = await prompt(rl, `${cyan}Description (current: ${tool.description}):${reset} `) || tool.description;
+                console.log(`\n${gray}Current code:${reset}`);
+                console.log(`${gray}${'─'.repeat(50)}${reset}`);
+                console.log(tool.code);
+                console.log(`${gray}${'─'.repeat(50)}${reset}\n`);
+                console.log(`${gray}Enter new code (or press Enter to keep current):${reset}`);
+                const newCode = await promptMultiline(rl, `${cyan}Tool code:${reset}`, 'END');
+                tool.description = newDescription;
+                if (newCode && newCode.trim().length > 0) {
+                    tool.code = newCode;
+                }
+                saveCustomTools();
+                console.log(`\n${green}✓${reset} Tool updated: ${bright}${tool.name}${reset}\n`);
+            }
+            else if (action === 'delete') {
+                const toolName = args[1];
+                if (!toolName) {
+                    console.log(`${red}Tool name required${reset}`);
+                    console.log(`${gray}Usage: tools delete <tool-name>${reset}\n`);
+                    return;
+                }
+                const tool = customTools.get(toolName.toLowerCase());
+                if (!tool) {
+                    console.log(`${red}Tool '${toolName}' not found${reset}\n`);
+                    return;
+                }
+                const confirm = await prompt(rl, `${yellow}Delete tool '${tool.name}'? (yes/no):${reset} `);
+                if (confirm.toLowerCase() === 'yes' || confirm.toLowerCase() === 'y') {
+                    customTools.delete(toolName.toLowerCase());
+                    saveCustomTools();
+                    console.log(`\n${green}✓${reset} Tool deleted: ${bright}${tool.name}${reset}\n`);
+                }
+                else {
+                    console.log(`${yellow}Deletion cancelled${reset}\n`);
+                }
+            }
+            else if (action === 'test') {
+                const toolName = args[1];
+                if (!toolName) {
+                    console.log(`${red}Tool name required${reset}`);
+                    console.log(`${gray}Usage: tools test <tool-name>${reset}\n`);
+                    return;
+                }
+                const tool = customTools.get(toolName.toLowerCase());
+                if (!tool) {
+                    console.log(`${red}Tool '${toolName}' not found${reset}\n`);
+                    return;
+                }
+                console.log(`\n${bright}Testing tool: ${tool.name}${reset}\n`);
+                console.log(`${gray}Tool code:${reset}`);
+                console.log(`${gray}${'─'.repeat(50)}${reset}`);
+                console.log(tool.code);
+                console.log(`${gray}${'─'.repeat(50)}${reset}\n`);
+                // Get test input
+                const testInput = await prompt(rl, `${cyan}Test input (JSON or plain text):${reset} `);
+                try {
+                    // Create a safe execution context
+                    const vm = await import('vm');
+                    const context = {
+                        console,
+                        setTimeout,
+                        setInterval,
+                        clearTimeout,
+                        clearInterval,
+                        Buffer,
+                        require: (module) => {
+                            // Whitelist safe modules
+                            const allowed = ['fs', 'path', 'os', 'crypto', 'url', 'http', 'https', 'axios'];
+                            if (allowed.includes(module)) {
+                                return require(module);
+                            }
+                            throw new Error(`Module '${module}' is not allowed`);
+                        }
+                    };
+                    // Parse test input
+                    let parsedInput = testInput;
+                    try {
+                        parsedInput = JSON.parse(testInput);
+                    }
+                    catch {
+                        // Use as string if not valid JSON
+                    }
+                    // Wrap tool code in async function
+                    const wrappedCode = `
+            (async () => {
+              ${tool.code}
+              // Tool should export a function or be a function
+              if (typeof tool === 'function') {
+                return await tool(${JSON.stringify(parsedInput)});
+              } else if (typeof execute === 'function') {
+                return await execute(${JSON.stringify(parsedInput)});
+              } else {
+                throw new Error('Tool must export a function named "tool" or "execute"');
+              }
+            })()
+          `;
+                    const result = await vm.default.runInNewContext(wrappedCode, context, { timeout: 5000 });
+                    console.log(`\n${green}✓${reset} Tool executed successfully:`);
+                    console.log(JSON.stringify(result, null, 2));
+                    console.log();
+                }
+                catch (error) {
+                    console.log(`\n${red}✗${reset} Tool execution failed:`);
+                    console.log(`${red}${error.message}${reset}\n`);
+                }
+            }
+            else {
+                console.log(`${red}Unknown action: ${action}${reset}`);
+                console.log(`${gray}Available actions: list, create, edit, delete, test${reset}\n`);
+            }
+        }
     }
 };
 function getStatusColor(status) {
@@ -865,6 +1256,26 @@ async function startREPL() {
     showWelcome();
     rl.prompt();
     rl.on('line', async (line) => {
+        // Handle multiline mode FIRST (before any command processing)
+        if (multilineMode && multilineResolver) {
+            const trimmed = line.trim();
+            // Check for end marker (must be exactly END, case-insensitive)
+            if (trimmed.toUpperCase() === multilineEndMarker.toUpperCase()) {
+                multilineMode = false;
+                const result = multilineLines.join('\n').trim();
+                const resolver = multilineResolver;
+                multilineResolver = null;
+                multilineLines = [];
+                // Restore normal prompt
+                rl.setPrompt(`${cyan}4runr>${reset} `);
+                resolver(result);
+                return;
+            }
+            // Collect the line (preserve original line including empty lines)
+            multilineLines.push(line);
+            rl.prompt();
+            return;
+        }
         const input = line.trim();
         if (!input) {
             rl.prompt();
@@ -888,50 +1299,104 @@ 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
+                    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) {