Upload folder using huggingface_hub

web/agent_wrapper.py

@@ -37,12 +37,13 @@ class AgentSession:
     Manages a single agent session with streaming support.
     """
 
-    def __init__(self):
+    def __init__(self, api_keys: Optional[Dict[str, str]] = None):
         self._agent = None
         self._repl_tool: Optional[PythonREPLTool] = None
         self._messages: List[Dict] = []
         self._initialized = False
-        
+        self._api_keys = api_keys or {}
+
         # Global singleton keeps the dataset cache (shared across sessions)
         self._memory = get_memory()
         # Per-session conversation memory — never touches other sessions
@@ -57,10 +58,17 @@ class AgentSession:
         """Initialize the agent and tools."""
         logger.info("Initializing agent session...")
 
-        if not os.environ.get("ARRAYLAKE_API_KEY"):
+        # Resolve API keys: user-provided take priority over env vars
+        openai_key = self._api_keys.get("openai_api_key") or os.environ.get("OPENAI_API_KEY")
+        arraylake_key = self._api_keys.get("arraylake_api_key") or os.environ.get("ARRAYLAKE_API_KEY")
+
+        if not arraylake_key:
             logger.warning("ARRAYLAKE_API_KEY not found")
+        else:
+            # Set in env so retrieval tools can pick it up
+            os.environ["ARRAYLAKE_API_KEY"] = arraylake_key
 
-        if not os.environ.get("OPENAI_API_KEY"):
+        if not openai_key:
             logger.error("OPENAI_API_KEY not found")
             return
 
@@ -82,11 +90,12 @@ class AgentSession:
             # Replace the default REPL with our configured one
             tools = [t for t in tools if t.name != "python_repl"] + [self._repl_tool]
 
-            # Initialize LLM
+            # Initialize LLM with resolved key
             logger.info("Connecting to LLM...")
             llm = ChatOpenAI(
                 model=CONFIG.model_name,
-                temperature=CONFIG.temperature
+                temperature=CONFIG.temperature,
+                api_key=openai_key,
             )
 
             # Use session-local memory for datasets (NOT global!)
@@ -254,12 +263,12 @@ class AgentSession:
 _sessions: Dict[str, AgentSession] = {}
 
 
-def create_session(connection_id: str) -> AgentSession:
+def create_session(connection_id: str, api_keys: Optional[Dict[str, str]] = None) -> AgentSession:
     """Create a new session for a connection."""
     if connection_id in _sessions:
         # Close existing session first
         _sessions[connection_id].close()
-    session = AgentSession()
+    session = AgentSession(api_keys=api_keys)
     _sessions[connection_id] = session
     logger.info(f"Created session for connection: {connection_id}")
     return session

web/routes/api.py

@@ -51,6 +51,15 @@ class ConfigResponse(BaseModel):
     model: str
 
 
+@router.get("/keys-status")
+async def keys_status():
+    """Check which API keys are configured via environment variables."""
+    return {
+        "openai": bool(os.environ.get("OPENAI_API_KEY")),
+        "arraylake": bool(os.environ.get("ARRAYLAKE_API_KEY")),
+    }
+
+
 @router.get("/health", response_model=HealthResponse)
 async def health_check():
     """Check if the server and agent are healthy."""

web/routes/websocket.py

@@ -51,14 +51,32 @@ async def websocket_chat(websocket: WebSocket):
     logger.info(f"New connection: {connection_id}")
 
     try:
-        # Create session for this connection
+        # Session created lazily after we receive API keys
         from web.agent_wrapper import create_session, get_session, close_session
-        session = create_session(connection_id)
-        
+        session = None
+
         while True:
             data = await websocket.receive_json()
             message = data.get("message", "").strip()
 
+            # Handle API key configuration from client
+            if data.get("type") == "configure_keys":
+                api_keys = {
+                    "openai_api_key": data.get("openai_api_key", ""),
+                    "arraylake_api_key": data.get("arraylake_api_key", ""),
+                }
+                session = create_session(connection_id, api_keys=api_keys)
+                ready = session.is_ready()
+                await manager.send_json(websocket, {
+                    "type": "keys_configured",
+                    "ready": ready,
+                })
+                continue
+
+            # Create default session if not yet created (keys from env)
+            if session is None:
+                session = create_session(connection_id)
+
             if not message:
                 continue
 

web/static/css/style.css

@@ -766,4 +766,89 @@ dialog .close-modal:hover {
 
 [data-theme="light"] ::selection {
     background: rgba(26, 115, 232, 0.2);
+}
+
+/* ===== API KEYS PANEL ===== */
+.api-keys-panel {
+    margin: 0 auto 16px;
+    max-width: 480px;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--glass-border);
+    border-radius: 12px;
+    overflow: hidden;
+}
+
+.api-keys-header {
+    padding: 12px 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+    background: var(--glass-bg);
+    border-bottom: 1px solid var(--glass-border);
+}
+
+.api-keys-body {
+    padding: 16px;
+}
+
+.api-keys-note {
+    font-size: 13px;
+    color: var(--text-secondary);
+    margin-bottom: 12px;
+    line-height: 1.4;
+}
+
+.api-key-field {
+    margin-bottom: 12px;
+}
+
+.api-key-field label {
+    display: block;
+    font-size: 13px;
+    font-weight: 500;
+    color: var(--text-secondary);
+    margin-bottom: 4px;
+}
+
+.api-key-field .required {
+    color: #ef4444;
+}
+
+.api-key-field input {
+    width: 100%;
+    padding: 8px 12px;
+    background: var(--bg-primary);
+    border: 1px solid var(--glass-border);
+    border-radius: 6px;
+    color: var(--text-primary);
+    font-family: monospace;
+    font-size: 13px;
+    box-sizing: border-box;
+}
+
+.api-key-field input:focus {
+    outline: none;
+    border-color: var(--accent-primary);
+    box-shadow: var(--focus-ring);
+}
+
+.save-keys-btn {
+    width: 100%;
+    padding: 10px;
+    background: var(--accent-primary);
+    color: #fff;
+    border: none;
+    border-radius: 6px;
+    font-size: 14px;
+    font-weight: 600;
+    cursor: pointer;
+    margin-top: 4px;
+}
+
+.save-keys-btn:hover {
+    opacity: 0.9;
+}
+
+.save-keys-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
 }

web/static/js/chat.js

@@ -8,6 +8,8 @@ class EurusChat {
         this.messageId = 0;
         this.currentAssistantMessage = null;
         this.isConnected = false;
+        this.keysConfigured = false;
+        this.serverKeysPresent = { openai: false, arraylake: false };
         this.reconnectAttempts = 0;
         this.maxReconnectAttempts = 5;
         this.reconnectDelay = 1000;
@@ -20,6 +22,10 @@ class EurusChat {
         this.clearBtn = document.getElementById('clear-btn');
         this.cacheBtn = document.getElementById('cache-btn');
         this.cacheModal = document.getElementById('cache-modal');
+        this.apiKeysPanel = document.getElementById('api-keys-panel');
+        this.saveKeysBtn = document.getElementById('save-keys-btn');
+        this.openaiKeyInput = document.getElementById('openai-key');
+        this.arraylakeKeyInput = document.getElementById('arraylake-key');
 
         marked.setOptions({
             highlight: (code, lang) => {
@@ -37,10 +43,82 @@ class EurusChat {
     }
 
     init() {
+        this.checkKeysStatus();
         this.connect();
         this.setupEventListeners();
         this.setupImageModal();
         this.setupTheme();
+        this.setupKeysPanel();
+    }
+
+    async checkKeysStatus() {
+        try {
+            const resp = await fetch('/api/keys-status');
+            const data = await resp.json();
+            this.serverKeysPresent = data;
+
+            if (data.openai) {
+                // Keys pre-configured on server — hide the panel
+                this.apiKeysPanel.style.display = 'none';
+                this.keysConfigured = true;
+            } else {
+                // No server keys — check localStorage for saved keys
+                const savedOpenai = localStorage.getItem('eurus-openai-key');
+                const savedArraylake = localStorage.getItem('eurus-arraylake-key');
+                if (savedOpenai) {
+                    this.openaiKeyInput.value = savedOpenai;
+                }
+                if (savedArraylake) {
+                    this.arraylakeKeyInput.value = savedArraylake;
+                }
+                this.apiKeysPanel.style.display = 'block';
+                this.keysConfigured = false;
+            }
+        } catch (e) {
+            // Can't reach server yet, show panel
+            this.apiKeysPanel.style.display = 'block';
+        }
+    }
+
+    setupKeysPanel() {
+        this.saveKeysBtn.addEventListener('click', () => this.saveAndSendKeys());
+
+        // Allow Enter in key fields to submit
+        [this.openaiKeyInput, this.arraylakeKeyInput].forEach(input => {
+            input.addEventListener('keydown', (e) => {
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    this.saveAndSendKeys();
+                }
+            });
+        });
+    }
+
+    saveAndSendKeys() {
+        const openaiKey = this.openaiKeyInput.value.trim();
+        const arraylakeKey = this.arraylakeKeyInput.value.trim();
+
+        if (!openaiKey) {
+            this.openaiKeyInput.focus();
+            return;
+        }
+
+        // Save to localStorage (client-side only)
+        localStorage.setItem('eurus-openai-key', openaiKey);
+        if (arraylakeKey) {
+            localStorage.setItem('eurus-arraylake-key', arraylakeKey);
+        }
+
+        // Send keys via WebSocket
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.saveKeysBtn.disabled = true;
+            this.saveKeysBtn.textContent = 'Connecting...';
+            this.ws.send(JSON.stringify({
+                type: 'configure_keys',
+                openai_api_key: openaiKey,
+                arraylake_api_key: arraylakeKey,
+            }));
+        }
     }
 
     setupTheme() {
@@ -83,7 +161,21 @@ class EurusChat {
                 this.isConnected = true;
                 this.reconnectAttempts = 0;
                 this.updateConnectionStatus('connected');
-                this.sendBtn.disabled = false;
+
+                // If server has no keys, auto-send saved keys from localStorage
+                if (!this.serverKeysPresent.openai) {
+                    const savedOpenai = localStorage.getItem('eurus-openai-key');
+                    if (savedOpenai) {
+                        const savedArraylake = localStorage.getItem('eurus-arraylake-key') || '';
+                        this.ws.send(JSON.stringify({
+                            type: 'configure_keys',
+                            openai_api_key: savedOpenai,
+                            arraylake_api_key: savedArraylake,
+                        }));
+                    }
+                } else {
+                    this.sendBtn.disabled = false;
+                }
             };
 
             this.ws.onclose = () => {
@@ -277,6 +369,18 @@ class EurusChat {
 
     handleMessage(data) {
         switch (data.type) {
+            case 'keys_configured':
+                this.keysConfigured = data.ready;
+                if (data.ready) {
+                    this.apiKeysPanel.style.display = 'none';
+                    this.sendBtn.disabled = false;
+                } else {
+                    this.saveKeysBtn.disabled = false;
+                    this.saveKeysBtn.textContent = 'Connect';
+                    this.showError('Failed to initialize agent. Check your API keys.');
+                }
+                break;
+
             case 'thinking':
                 this.showThinkingIndicator();
                 break;

web/templates/index.html

@@ -4,6 +4,25 @@
 
 {% block content %}
 <div class="chat-container">
+    <!-- API Keys panel — hidden when keys are pre-configured via env -->
+    <div id="api-keys-panel" class="api-keys-panel" style="display: none;">
+        <div class="api-keys-header">
+            <span>API Keys Required</span>
+        </div>
+        <div class="api-keys-body">
+            <p class="api-keys-note">Enter your API keys to use Eurus. Keys are stored in your browser only and never saved on the server.</p>
+            <div class="api-key-field">
+                <label for="openai-key">OpenAI API Key <span class="required">*</span></label>
+                <input type="password" id="openai-key" placeholder="sk-..." autocomplete="off">
+            </div>
+            <div class="api-key-field">
+                <label for="arraylake-key">Arraylake API Key</label>
+                <input type="password" id="arraylake-key" placeholder="ema_..." autocomplete="off">
+            </div>
+            <button id="save-keys-btn" class="save-keys-btn">Connect</button>
+        </div>
+    </div>
+
     <div id="chat-messages" class="chat-messages">
         <div class="message system-message">
             <h3>Welcome to Eurus</h3>