lemonade-sdk 8.1.4__py3-none-any.whl → 8.2.2__py3-none-any.whl

lemonade/tools/server/static/js/shared.js

@@ -54,15 +54,53 @@ function renderMarkdown(text) {
 
 // Display an error message in the banner
 function showErrorBanner(msg) {
+    showBanner(msg, 'error');
+}
+
+// Display a banner with a specific type (error, warning, success)
+function showBanner(msg, type = 'error') {
+    // If DOM isn't ready, wait for it
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => {
+            showBanner(msg, type);
+        });
+        return;
+    }
+
     const banner = document.getElementById('error-banner');
     if (!banner) return;
     const msgEl = document.getElementById('error-banner-msg');
-    const fullMsg = msg + '\nCheck the Lemonade Server logs via the system tray app for more information.';
+    const logsUrl = window.location.origin + '/static/logs.html';
+
+    // Determine the full message and styling based on type
+    let fullMsg = msg;
+    let backgroundColor, color;
+
+    switch(type) {
+        case 'success':
+            backgroundColor = '#27ae60'; // green
+            color = '#ffffff';
+            break;
+        case 'warning':
+            backgroundColor = '#8d5803ff'; // yellow/orange
+            color = '#ffffff';
+            break;
+        case 'error':
+        default:
+            backgroundColor = '#b10819ff'; // red
+            color = '#ffffff';
+            fullMsg = `${msg}<br>Check the Lemonade Server logs <a href="${logsUrl}" target="_blank" rel="noopener noreferrer">on the browser</a> or via the system tray app for more information.`;
+            break;
+    }
+    
     if (msgEl) {
-        msgEl.textContent = fullMsg;
+        msgEl.innerHTML = fullMsg;
     } else {
-        banner.textContent = fullMsg;
+        banner.innerHTML = fullMsg;
     }
+
+    banner.style.backgroundColor = backgroundColor;
+    banner.style.color = color;
     banner.style.display = 'flex';
 }
 
@@ -169,11 +207,16 @@ async function loadModelStandardized(modelId, options = {}) {
     // Store original states for restoration on error
     const originalStatusText = document.getElementById('model-status-text')?.textContent || '';
     
+    // Track this load operation as active to prevent polling interference
+    if (window.activeOperations) {
+        window.activeOperations.add(modelId);
+    }
+    
     try {
         // Update load button if provided
         if (loadButton) {
             loadButton.disabled = true;
-            loadButton.textContent = '⌛';
+            loadButton.textContent = '⏳';
         }
         
         // Update status indicator to show loading state
@@ -181,7 +224,7 @@ async function loadModelStandardized(modelId, options = {}) {
         
         // Update chat dropdown and send button to show loading state
         const modelSelect = document.getElementById('model-select');
-        const sendBtn = document.getElementById('send-btn');
+        const sendBtn = document.getElementById('toggle-btn');
         if (modelSelect && sendBtn) {
             // Ensure the model exists in the dropdown options
             let modelOption = modelSelect.querySelector(`option[value="${modelId}"]`);
@@ -214,10 +257,18 @@ async function loadModelStandardized(modelId, options = {}) {
         }
         
         // Make the API call to load the model
+        // Include mmproj if the model has it defined
+        const loadPayload = { model_name: modelId };
+        const allModels = window.SERVER_MODELS || {};
+        const modelData = allModels[modelId];
+        if (modelData && modelData.mmproj) {
+            loadPayload.mmproj = modelData.mmproj;
+        }
+
         await httpRequest(getServerBaseUrl() + '/api/v1/load', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ model_name: modelId })
+            body: JSON.stringify(loadPayload)
         });
         
         // Update model status indicator after successful load
@@ -238,7 +289,8 @@ async function loadModelStandardized(modelId, options = {}) {
         // Reset load button if provided
         if (loadButton) {
             loadButton.disabled = false;
-            loadButton.textContent = 'Load';
+            loadButton.textContent = '🚀';
+            loadButton.classList.remove('loading');
         }
         
         // Reset chat controls
@@ -250,7 +302,7 @@ async function loadModelStandardized(modelId, options = {}) {
             // Reset the default option text
             const defaultOption = modelSelect.querySelector('option[value=""]');
             if (defaultOption) {
-                defaultOption.textContent = 'Pick a model';
+                defaultOption.textContent = 'Click to select a model ▼';
             }
         }
         
@@ -264,6 +316,11 @@ async function loadModelStandardized(modelId, options = {}) {
             onSuccess(modelId);
         }
         
+        // Remove from active operations on success
+        if (window.activeOperations) {
+            window.activeOperations.delete(modelId);
+        }
+        
         return true;
         
     } catch (error) {
@@ -272,7 +329,8 @@ async function loadModelStandardized(modelId, options = {}) {
         // Reset load button if provided
         if (loadButton) {
             loadButton.disabled = false;
-            loadButton.textContent = 'Load';
+            loadButton.textContent = '🚀';
+            loadButton.classList.remove('loading');
         }
         
         // Reset status indicator on error
@@ -280,7 +338,7 @@ async function loadModelStandardized(modelId, options = {}) {
         
         // Reset chat controls on error
         const modelSelect = document.getElementById('model-select');
-        const sendBtn = document.getElementById('send-btn');
+        const sendBtn = document.getElementById('toggle-btn');
         if (modelSelect && sendBtn) {
             modelSelect.disabled = false;
             sendBtn.disabled = false;
@@ -294,7 +352,7 @@ async function loadModelStandardized(modelId, options = {}) {
             // Reset the default option text
             const defaultOption = modelSelect.querySelector('option[value=""]');
             if (defaultOption) {
-                defaultOption.textContent = 'Pick a model';
+                defaultOption.textContent = 'Click to select a model ▼';
             }
         }
         
@@ -303,11 +361,16 @@ async function loadModelStandardized(modelId, options = {}) {
             onLoadingEnd(modelId, false);
         }
         
-        // Call error callback or show default error
+        // Call error callback and always show default error banner as fallback
         if (onError) {
             onError(error, modelId);
-        } else {
-            showErrorBanner('Failed to load model: ' + error.message);
+        }
+        // Always show error banner to ensure user sees the error
+        showErrorBanner('Failed to load model: ' + error.message);
+        
+        // Remove from active operations on error too
+        if (window.activeOperations) {
+            window.activeOperations.delete(modelId);
         }
         
         return false;
@@ -474,6 +537,8 @@ function createModelNameWithLabels(modelId, allModels) {
                 labelClass = 'reranking';
             } else if (labelLower === 'coding') {
                 labelClass = 'coding';
+            } else if (labelLower === 'tool-calling') {
+                labelClass = 'tool-calling';
             }
             labelSpan.className = `model-label ${labelClass}`;
             labelSpan.textContent = label;

lemonade/tools/server/static/logs.html

@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Lemonade Server Logs</title>
+    <style>
+        body {
+            font-family: monospace;
+            background: #1e1e1e;
+            color: #d4d4d4;
+            margin: 0;
+            padding: 0;
+        }
+        #log-container {
+            padding: 10px;
+            height: 100vh;
+            overflow-y: auto;
+            white-space: pre-wrap;
+        }
+    </style>
+</head>
+<body>
+    <div id="log-container"></div>
+
+<script>
+    /**
+     * LogStreamer - Backwards-compatible log streaming client
+     * Supports both WebSocket (Python server) and SSE (C++ server)
+     * Tries WebSocket first, falls back to SSE if unavailable
+     */
+    class LogStreamer {
+        constructor(baseUrl, onMessage, onError = null) {
+            this.baseUrl = baseUrl;
+            this.onMessage = onMessage;
+            this.onError = onError;
+            this.connection = null;
+            this.type = null; // 'websocket' or 'sse'
+        }
+        
+        async connect() {
+            // Try WebSocket first (Python server)
+            try {
+                await this.connectWebSocket();
+                console.log('[LogStreamer] Connected via WebSocket');
+                return;
+            } catch (wsError) {
+                console.log('[LogStreamer] WebSocket failed, trying SSE...', wsError);
+            }
+            
+            // Fallback to SSE (C++ server)
+            try {
+                this.connectSSE();
+                console.log('[LogStreamer] Connected via SSE');
+            } catch (sseError) {
+                console.error('[LogStreamer] Both WebSocket and SSE failed', sseError);
+                if (this.onError) {
+                    this.onError(new Error('Unable to connect to log stream'));
+                }
+            }
+        }
+        
+        connectWebSocket() {
+            return new Promise((resolve, reject) => {
+                const wsUrl = this.baseUrl
+                    .replace('http://', 'ws://')
+                    .replace('https://', 'wss://') + '/api/v1/logs/ws';
+                
+                const ws = new WebSocket(wsUrl);
+                let connectionTimeout = setTimeout(() => {
+                    reject(new Error('WebSocket connection timeout'));
+                    ws.close();
+                }, 3000); // 3 second timeout
+                
+                ws.onopen = () => {
+                    clearTimeout(connectionTimeout);
+                    this.connection = ws;
+                    this.type = 'websocket';
+                    resolve();
+                };
+                
+                ws.onmessage = (event) => {
+                    this.onMessage(event.data);
+                };
+                
+                ws.onerror = (error) => {
+                    clearTimeout(connectionTimeout);
+                    if (this.onError && this.connection) {
+                        this.onError(error);
+                    }
+                    reject(error);
+                };
+                
+                ws.onclose = () => {
+                    if (this.type === 'websocket') {
+                        console.log('[LogStreamer] WebSocket closed');
+                        if (this.onError) {
+                            this.onError(new Error('WebSocket connection closed'));
+                        }
+                    }
+                };
+            });
+        }
+        
+        connectSSE() {
+            const sseUrl = this.baseUrl + '/api/v1/logs/stream';
+            const eventSource = new EventSource(sseUrl);
+            
+            eventSource.onopen = () => {
+                this.connection = eventSource;
+                this.type = 'sse';
+            };
+            
+            eventSource.onmessage = (event) => {
+                this.onMessage(event.data);
+            };
+            
+            eventSource.onerror = (error) => {
+                console.error('[LogStreamer] SSE error:', error);
+                if (this.onError) {
+                    this.onError(error);
+                }
+            };
+        }
+        
+        disconnect() {
+            if (!this.connection) return;
+            
+            if (this.type === 'websocket') {
+                this.connection.close();
+            } else if (this.type === 'sse') {
+                this.connection.close();
+            }
+            
+            this.connection = null;
+            this.type = null;
+        }
+        
+        getConnectionType() {
+            return this.type;
+        }
+    }
+
+    // Utility functions
+    function stripAnsi(str) {
+        return str.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+    }
+
+    function isNearBottom() {
+        const threshold = 50; // px from bottom
+        return logContainer.scrollTop + logContainer.clientHeight >= logContainer.scrollHeight - threshold;
+    }
+
+    // Initialize log streaming
+    const logContainer = document.getElementById("log-container");
+    const baseUrl = `${location.protocol}//${location.host}`;
+    
+    const logStreamer = new LogStreamer(
+        baseUrl,
+        (logLine) => {
+            // Handle incoming log line
+            const line = document.createElement("div");
+            line.textContent = stripAnsi(logLine);
+            logContainer.appendChild(line);
+
+            // Only autoscroll if the user is already at (or near) the bottom
+            if (isNearBottom()) {
+                logContainer.scrollTop = logContainer.scrollHeight;
+            }
+        },
+        (error) => {
+            // Handle error
+            const msg = document.createElement("div");
+            msg.textContent = `[Connection error: ${error.message}]`;
+            msg.style.color = "red";
+            logContainer.appendChild(msg);
+        }
+    );
+    
+    // Connect to log stream
+    logStreamer.connect();
+    
+    // Show connection type in console
+    setTimeout(() => {
+        const type = logStreamer.getConnectionType();
+        if (type) {
+            console.log(`[LogViewer] Connected via ${type === 'websocket' ? 'WebSocket' : 'Server-Sent Events'}`);
+        }
+    }, 100);
+</script>
+</body>
+</html>