lemonade-sdk 7.0.1__py3-none-any.whl → 7.0.3__py3-none-any.whl

lemonade/tools/server/serve.py

@@ -8,7 +8,6 @@ import traceback
 from typing import Optional, Union
 import json
 import subprocess
-from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI, HTTPException, status, Request
@@ -16,6 +15,8 @@ from fastapi.responses import StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 import uvicorn
+from uvicorn.config import Config
+from uvicorn.server import Server as UvicornServer
 from transformers import TextIteratorStreamer, StoppingCriteria, StoppingCriteriaList
 from tabulate import tabulate
 
@@ -45,9 +46,7 @@ from openai.types.responses import (
 
 import lemonade.api as lemonade_api
 from lemonade_server.model_manager import ModelManager
-from lemonade.tools.management_tools import ManagementTool
-import lemonade.tools.server.llamacpp as llamacpp
-from lemonade.tools.server.pydantic_models import (
+from lemonade_server.pydantic_models import (
     DEFAULT_MAX_NEW_TOKENS,
     LoadConfig,
     CompletionRequest,
@@ -55,9 +54,11 @@ from lemonade.tools.server.pydantic_models import (
     ResponsesRequest,
     PullConfig,
 )
+from lemonade.tools.management_tools import ManagementTool
+import lemonade.tools.server.llamacpp as llamacpp
 from lemonade.tools.server.tool_calls import extract_tool_calls, get_tool_call_pattern
 from lemonade.tools.server.instructions import get_instructions_html
-
+from lemonade.tools.server.port_utils import lifespan
 
 DEFAULT_PORT = 8000
 DEFAULT_LOG_LEVEL = "info"
@@ -243,15 +244,22 @@ class Server(ManagementTool):
 
         return parser
 
-    def run(
+    def _setup_server_common(
         self,
-        # ManagementTool has a required cache_dir arg, but
-        # we always use the default cache directory
-        _=None,
-        port: int = DEFAULT_PORT,
-        log_level: str = DEFAULT_LOG_LEVEL,
+        port: int,
         truncate_inputs: bool = False,
+        log_level: str = DEFAULT_LOG_LEVEL,
+        threaded_mode: bool = False,
     ):
+        """
+        Common setup logic shared between run() and run_in_thread().
+
+        Args:
+            port: Port number for the server
+            truncate_inputs: Whether to truncate inputs if they exceed max length
+            log_level: Logging level to configure
+            threaded_mode: Whether this is being set up for threaded execution
+        """
         # Store truncation settings
         self.truncate_inputs = truncate_inputs
 
@@ -265,22 +273,27 @@ class Server(ManagementTool):
 
         logging.trace = trace
 
-        # Configure logging to match uvicorn's format
-        logging_level = getattr(logging, log_level.upper())
-        logging.basicConfig(
-            level=logging_level,
-            format="%(levelprefix)s %(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
+        # Configure logging based on mode
+        if threaded_mode:
+            # Configure logging for warning level (to reduce noise in threaded execution)
+            logging.getLogger("uvicorn.error").setLevel(logging.WARNING)
+        else:
+            # Configure logging to match uvicorn's format
+            logging_level = getattr(logging, log_level.upper())
+            logging.basicConfig(
+                level=logging_level,
+                format="%(levelprefix)s %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
 
-        # Add uvicorn's log formatter
-        logging.root.handlers[0].formatter = uvicorn.logging.DefaultFormatter(
-            fmt="%(levelprefix)s %(message)s",
-            use_colors=True,
-        )
+            # Add uvicorn's log formatter
+            logging.root.handlers[0].formatter = uvicorn.logging.DefaultFormatter(
+                fmt="%(levelprefix)s %(message)s",
+                use_colors=True,
+            )
 
-        # Ensure the log level is properly set
-        logging.getLogger().setLevel(logging_level)
+            # Ensure the log level is properly set
+            logging.getLogger().setLevel(logging_level)
 
         # Update debug logging state after setting log level
         self.debug_logging_enabled = logging.getLogger().isEnabledFor(logging.DEBUG)
@@ -293,8 +306,62 @@ class Server(ManagementTool):
         # that the lifespan can access it
         self.app.port = port
 
+    def run(
+        self,
+        # ManagementTool has a required cache_dir arg, but
+        # we always use the default cache directory
+        _=None,
+        port: int = DEFAULT_PORT,
+        log_level: str = DEFAULT_LOG_LEVEL,
+        truncate_inputs: bool = False,
+    ):
+        # Common setup
+        self._setup_server_common(
+            port=port,
+            truncate_inputs=truncate_inputs,
+            log_level=log_level,
+            threaded_mode=False,
+        )
+
         uvicorn.run(self.app, host="localhost", port=port, log_level=log_level)
 
+    def run_in_thread(
+        self,
+        port: int = DEFAULT_PORT,
+        host: str = "localhost",
+        log_level: str = "warning",
+        truncate_inputs: bool = False,
+    ):
+        """
+        Set up the server for running in a thread.
+        Returns a uvicorn server instance that can be controlled externally.
+        """
+        # Common setup
+        self._setup_server_common(
+            port=port,
+            truncate_inputs=truncate_inputs,
+            log_level=log_level,
+            threaded_mode=True,
+        )
+
+        class CustomServer(UvicornServer):
+            """Custom Uvicorn server that can be properly shutdown from another thread"""
+
+            def install_signal_handlers(self):
+                pass
+
+        # Configure the server
+        config = Config(
+            app=self.app,
+            host=host,
+            port=port,
+            log_level=log_level,
+            log_config=None,
+        )
+
+        # Create and return the uvicorn server
+        return CustomServer(config=config)
+
     async def _show_telemetry(self):
         """
         Show telemetry data in debug mode.
@@ -1133,7 +1200,7 @@ class Server(ManagementTool):
             # We will populate a LoadConfig that has all of the required fields
             config_to_use: LoadConfig
 
-            # First, validate that the arguments are valid
+            # First, ensure that the arguments are valid
             if config.model_name:
                 # Get the dictionary of supported model from disk
                 supported_models = ModelManager().supported_models
@@ -1226,7 +1293,7 @@ class Server(ManagementTool):
             try:
                 if config_to_use.recipe == "llamacpp":
                     self.llama_server_process = llamacpp.server_load(
-                        checkpoint=config_to_use.checkpoint,
+                        model_config=config_to_use,
                         model_reference=model_reference,
                         telemetry=self.llama_telemetry,
                     )
@@ -1241,6 +1308,8 @@ class Server(ManagementTool):
                     "status": "success",
                     "message": f"Loaded model: {model_reference}",
                 }
+            except HTTPException:
+                raise
             except Exception:  # pylint: disable=broad-exception-caught
                 self.model_load_failure(model_reference)
 
@@ -1339,22 +1408,5 @@ class Server(ManagementTool):
             return response
 
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Code here will run when the application starts up
-
-    logging.info(
-        "\n"
-        "\n"
-        "🍋  Lemonade Server Ready!\n"
-        f"🍋    Open http://localhost:{app.port} in your browser for:\n"
-        "🍋      💬 chat\n"
-        "🍋      💻 model management\n"
-        "🍋      📄 docs\n"
-    )
-
-    yield
-
-
 # This file was originally licensed under Apache 2.0. It has been modified.
 # Modifications Copyright (c) 2025 AMD

lemonade/tools/server/static/instructions.html

@@ -0,0 +1,262 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Lemonade Server</title>
+    <link rel="icon" href="data:,">
+    <link rel="stylesheet" href="/static/styles.css">
+    <script>
+    window.SERVER_PORT = {{SERVER_PORT}};
+    </script>
+    {{SERVER_MODELS_JS}}
+</head>
+<body>
+    <nav class="navbar">
+        <a href="https://github.com/lemonade-sdk/lemonade">GitHub</a>
+        <a href="https://lemonade-server.ai/docs/">Docs</a>
+        <a href="https://lemonade-server.ai/docs/server/server_models/">Models</a>
+        <a href="https://lemonade-server.ai/docs/server/apps/">Featured Apps</a>
+    </nav>
+    <main class="main">
+        <div class="title">🍋 Lemonade Server</div>
+        <div class="tab-container"> 
+            <div class="tabs"> 
+                <button class="tab active" id="tab-chat" onclick="showTab('chat')">LLM Chat</button> 
+                <button class="tab" id="tab-models" onclick="showTab('models')">Model Management</button> 
+            </div> 
+            <div class="tab-content active" id="content-chat"> 
+                <div class="chat-container"> 
+                    <div class="chat-history" id="chat-history"></div> 
+                    <div class="chat-input-row"> 
+                        <select id="model-select"></select> 
+                        <input type="text" id="chat-input" placeholder="Type your message..." /> 
+                        <button id="send-btn">Send</button> 
+                    </div> 
+                </div> 
+            </div> 
+            <div class="tab-content" id="content-models"> 
+                <div class="model-mgmt-container">
+                    <div class="model-mgmt-pane">
+                        <h3>Installed Models</h3>
+                        <table class="model-table" id="installed-models-table">
+                            <colgroup><col style="width:100%"></colgroup>
+                            <tbody id="installed-models-tbody"></tbody>
+                        </table>
+                    </div>
+                    <div class="model-mgmt-pane">
+                        <h3>Suggested Models</h3>
+                        <table class="model-table" id="suggested-models-table">
+                            <tbody id="suggested-models-tbody"></tbody>
+                        </table>
+                    </div>
+                </div>
+            </div> 
+        </div> 
+    </main>
+    <footer class="site-footer">
+        <div class="dad-joke">When life gives you LLMs, make an LLM aide.</div>
+        <div class="copyright">Copyright 2025 AMD</div>
+    </footer>
+    <script src="https://cdn.jsdelivr.net/npm/openai@4.21.0/dist/openai.min.js"></script> 
+    <script> 
+    // Tab switching logic 
+    function showTab(tab) { 
+        document.getElementById('tab-chat').classList.remove('active'); 
+        document.getElementById('tab-models').classList.remove('active'); 
+        document.getElementById('content-chat').classList.remove('active'); 
+        document.getElementById('content-models').classList.remove('active'); 
+        if (tab === 'chat') { 
+            document.getElementById('tab-chat').classList.add('active'); 
+            document.getElementById('content-chat').classList.add('active'); 
+        } else { 
+            document.getElementById('tab-models').classList.add('active'); 
+            document.getElementById('content-models').classList.add('active'); 
+        } 
+    }
+
+    // Helper to get server base URL
+    function getServerBaseUrl() {
+        const port = window.SERVER_PORT || 8000;
+        return `http://localhost:${port}`;
+    }
+
+    // Populate model dropdown from /api/v1/models endpoint
+    async function loadModels() {
+        try {
+            const resp = await fetch(getServerBaseUrl() + '/api/v1/models');
+            const data = await resp.json();
+            const select = document.getElementById('model-select');
+            select.innerHTML = '';
+            if (!data.data || !Array.isArray(data.data)) {
+                select.innerHTML = '<option>No models found (malformed response)</option>';
+                return;
+            }
+            if (data.data.length === 0) {
+                select.innerHTML = '<option>No models available</option>';
+                return;
+            }
+            let defaultIndex = 0;
+            data.data.forEach(function(model, index) {
+                const modelId = model.id || model.name || model;
+                const opt = document.createElement('option');
+                opt.value = modelId;
+                opt.textContent = modelId;
+                if (modelId === 'Llama-3.2-1B-Instruct-Hybrid') {
+                    defaultIndex = index;
+                }
+                select.appendChild(opt);
+            });
+            select.selectedIndex = defaultIndex;
+        } catch (e) {
+            const select = document.getElementById('model-select');
+            select.innerHTML = `<option>Error loading models: ${e.message}</option>`;
+            console.error('Error loading models:', e);
+        }
+    }
+    loadModels();
+
+    // Model Management Tab Logic
+    async function refreshModelMgmtUI() {
+        // Get installed models from /api/v1/models
+        let installed = [];
+        try {
+            const resp = await fetch(getServerBaseUrl() + '/api/v1/models');
+            const data = await resp.json();
+            if (data.data && Array.isArray(data.data)) {
+                installed = data.data.map(m => m.id || m.name || m);
+            }
+        } catch (e) {}
+        // All models from server_models.json (window.SERVER_MODELS)
+        const allModels = window.SERVER_MODELS || {};
+        // Filter suggested models not installed
+        const suggested = Object.keys(allModels).filter(
+            k => allModels[k].suggested && !installed.includes(k)
+        );
+        // Render installed models as a table (two columns, second is invisible)
+        const installedTbody = document.getElementById('installed-models-tbody');
+        installedTbody.innerHTML = '';
+        installed.forEach(function(mid) {
+            var tr = document.createElement('tr');
+            var tdName = document.createElement('td');
+            tdName.textContent = mid;
+            var tdEmpty = document.createElement('td');
+            tdEmpty.style.width = '0';
+            tdEmpty.style.padding = '0';
+            tdEmpty.style.border = 'none';
+            tr.appendChild(tdName);
+            tr.appendChild(tdEmpty);
+            installedTbody.appendChild(tr);
+        });
+        // Render suggested models as a table
+        const suggestedTbody = document.getElementById('suggested-models-tbody');
+        suggestedTbody.innerHTML = '';
+        suggested.forEach(mid => {
+            const tr = document.createElement('tr');
+            const tdName = document.createElement('td');
+            tdName.textContent = mid;
+            tdName.style.paddingRight = '1em';
+            tdName.style.verticalAlign = 'middle';
+            const tdBtn = document.createElement('td');
+            tdBtn.style.width = '1%';
+            tdBtn.style.verticalAlign = 'middle';
+            const btn = document.createElement('button');
+            btn.textContent = '+';
+            btn.title = 'Install model';
+            btn.onclick = async function() {
+                btn.disabled = true;
+                btn.textContent = 'Installing...';
+                btn.classList.add('installing-btn');
+                try {
+                    await fetch(getServerBaseUrl() + '/api/v1/pull', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ model_name: mid })
+                    });
+                    await refreshModelMgmtUI();
+                    await loadModels(); // update chat dropdown too
+                } catch (e) {
+                    btn.textContent = 'Error';
+                }
+            };
+            tdBtn.appendChild(btn);
+            tr.appendChild(tdName);
+            tr.appendChild(tdBtn);
+            suggestedTbody.appendChild(tr);
+        });
+    }
+    // Initial load
+    refreshModelMgmtUI();
+    // Optionally, refresh when switching to the tab
+    document.getElementById('tab-models').addEventListener('click', refreshModelMgmtUI);
+
+    // Chat logic (streaming with OpenAI JS client placeholder)
+    const chatHistory = document.getElementById('chat-history');
+    const chatInput = document.getElementById('chat-input');
+    const sendBtn = document.getElementById('send-btn');
+    const modelSelect = document.getElementById('model-select');
+    let messages = [];
+
+    function appendMessage(role, text) {
+        const div = document.createElement('div');
+        div.className = 'chat-message ' + role;
+        // Add a bubble for iMessage style
+        const bubble = document.createElement('div');
+        bubble.className = 'chat-bubble ' + role;
+        bubble.innerHTML = text;
+        div.appendChild(bubble);
+        chatHistory.appendChild(div);
+        chatHistory.scrollTop = chatHistory.scrollHeight;
+    }
+
+    async function sendMessage() {
+        const text = chatInput.value.trim();
+        if (!text) return;
+        appendMessage('user', text);
+        messages.push({ role: 'user', content: text });
+        chatInput.value = '';
+        sendBtn.disabled = true;
+        // Streaming OpenAI completions (placeholder, adapt as needed)
+        let llmText = '';
+        appendMessage('llm', '...');
+        const llmDiv = chatHistory.lastChild.querySelector('.chat-bubble.llm');
+        try {
+            // Use the correct endpoint for chat completions
+            const resp = await fetch(getServerBaseUrl() + '/api/v1/chat/completions', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: modelSelect.value,
+                    messages: messages,
+                    stream: true
+                })
+            });
+            if (!resp.body) throw new Error('No stream');
+            const reader = resp.body.getReader();
+            let decoder = new TextDecoder();
+            llmDiv.textContent = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const chunk = decoder.decode(value);
+                if (chunk.trim() === 'data: [DONE]' || chunk.trim() === '[DONE]') continue;
+                // Try to extract the content from the OpenAI chunk
+                const match = chunk.match(/"content"\s*:\s*"([^"]*)"/);
+                if (match && match[1]) {
+                    llmText += match[1];
+                    llmDiv.textContent = llmText;
+                }
+            }
+            messages.push({ role: 'assistant', content: llmText });
+        } catch (e) {
+            llmDiv.textContent = '[Error: ' + e.message + ']';
+        }
+        sendBtn.disabled = false;
+    }
+    sendBtn.onclick = sendMessage;
+    chatInput.addEventListener('keydown', function(e) {
+        if (e.key === 'Enter') sendMessage();
+    });
+    </script>
+</body>
+</html>

lemonade/tools/server/thread_utils.py

@@ -0,0 +1,87 @@
+import threading
+import logging
+from lemonade.tools.server.serve import Server
+
+
+class ServerRunner(threading.Thread):
+    """
+    Thread class for running the Lemonade Server with a loaded model.
+    """
+
+    def __init__(
+        self, model, tokenizer, checkpoint, recipe, host="localhost", port=8000
+    ):
+        threading.Thread.__init__(self)
+        self.model = model
+        self.tokenizer = tokenizer
+        self.checkpoint = checkpoint
+        self.recipe = recipe
+        self.host = host
+        self.port = port
+        self.server = None
+        self.ready_event = threading.Event()
+        self.shutdown_event = threading.Event()
+        self.uvicorn_server = None
+
+    def run(self):
+        try:
+            # Create the server instance
+            self.server = Server()
+
+            # Configure the server with model/tokenizer
+            self.server.model = self.model
+            self.server.tokenizer = self.tokenizer
+            self.server.llm_loaded = type(
+                "obj",
+                (object,),
+                {
+                    "checkpoint": self.checkpoint,
+                    "recipe": self.recipe,
+                    "max_prompt_length": None,
+                    "reasoning": False,
+                    "model_name": "custom",
+                },
+            )
+
+            # Set up the server for threaded execution
+            self.uvicorn_server = self.server.run_in_thread(
+                port=self.port, host=self.host, log_level="warning"
+            )
+
+            # Set the ready event
+            self.ready_event.set()
+
+            # Run the server until shutdown is requested
+            logging.info(f"Starting server on http://{self.host}:{self.port}")
+            self.uvicorn_server.run()
+
+        except Exception as e:
+            logging.error(f"Error starting server: {e}")
+            self.ready_event.set()
+            raise
+
+    def shutdown(self):
+        """Shutdown the server"""
+        if hasattr(self, "uvicorn_server") and self.uvicorn_server:
+            logging.info("Shutting down server...")
+            self.uvicorn_server.should_exit = True
+            self.shutdown_event.set()
+
+        # Clean up resources properly to avoid memory leaks
+        if hasattr(self, "server") and self.server:
+            logging.info("Cleaning up model and tokenizer resources...")
+
+            if hasattr(self.server, "model"):
+                self.server.model = None
+
+            if hasattr(self.server, "tokenizer"):
+                self.server.tokenizer = None
+
+            if hasattr(self.server, "llm_loaded"):
+                self.server.llm_loaded = None
+
+        # Clean up local references
+        if hasattr(self, "model"):
+            del self.model
+        if hasattr(self, "tokenizer"):
+            del self.tokenizer

lemonade/version.py

@@ -1 +1 @@
-__version__ = "7.0.1"
+__version__ = "7.0.3"

{lemonade_sdk-7.0.1.dist-info → lemonade_sdk-7.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemonade-sdk
-Version: 7.0.1
+Version: 7.0.3
 Summary: Lemonade SDK: Your LLM Aide for Validation and Deployment
 Author-email: lemonade@amd.com
 Requires-Python: >=3.10, <3.12

{lemonade_sdk-7.0.1.dist-info → lemonade_sdk-7.0.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
 lemonade/__init__.py,sha256=W1Qk7r0rnQqFhPNHp6BIBT_q-OH3s-8Q_POoVfAmKW0,117
 lemonade/api.py,sha256=9apNWSMS4bYpYl7iqDA4CsHHOOMdjOIuJhNYSqj_jIA,3878
 lemonade/cache.py,sha256=djr2qgyUUAWlQv8FehU9qlNtCwK0IZqo82hcBDyZ3-A,2850
-lemonade/cli.py,sha256=_s-LWpaVIhOmaP0Q1qirXxNiBhdumAZ-5ub5-lRNccs,4351
+lemonade/cli.py,sha256=ddN2QqsGMsVwydfcR7MSZu1z8_-bUgUP7dhw9lzbHa8,4424
 lemonade/sequence.py,sha256=KSH7BPsiyDKsOsg_ziQKEGsDwMmuO_YbgPRBxkZd0pw,13267
 lemonade/state.py,sha256=sdSezla7Cd7KYL90xY3p9kcNV4ndSyN6UvNLOr3vBMA,5261
-lemonade/version.py,sha256=co6LyaBArt-ahHXYZSdSER8TFZ2vVTb86CNG6X8Pxwc,22
+lemonade/version.py,sha256=Ur-fY8dgd79WuOM208uDSw5amQiSzM7VmTbWPLQBZvw,22
 lemonade/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lemonade/common/analyze_model.py,sha256=sYWDznEUEWjx_Qekg7f1hHY4Pfe87IQ77lmsWqePgE0,803
 lemonade/common/build.py,sha256=Pk86mCr6fyBIx2zXDpq0BkdahlCmWRnwSTpShA_gwZw,7849
@@ -23,20 +23,21 @@ lemonade/profilers/__init__.py,sha256=JKVonvJ4XZ9_6sKXPWsiMLQCNyzQOxhQw5BEHR1qOf
 lemonade/profilers/memory_tracker.py,sha256=-SSBmNlrweiX59wyNtLMWiwaMOskBzNO1_cufVwteqs,9357
 lemonade/profilers/profiler.py,sha256=y_iMGr1ToQ6rcwcIcXck4ajapisLXCfHggiV-IpPF98,1666
 lemonade/tools/__init__.py,sha256=_6xRc-FHxmujoLjLjWtpYrWYEXtCSneSy-5ya01kyPk,53
+lemonade/tools/accuracy.py,sha256=QndammQ1bmlTaF_6YDaaiJp6fpkKZDYGySdQpAgZIp8,11699
 lemonade/tools/adapter.py,sha256=4H6gfbjvqyU6qm1_-b2FE-c3a7N9OzEBeDVnIwqRDvg,3014
 lemonade/tools/bench.py,sha256=aN5LMA_EH6-ZhAH3Gf26JYL7s0eKpUd3j-bReRhzvEY,10016
 lemonade/tools/huggingface_bench.py,sha256=POE5JYzArK2FBktazOkluLNFzlLctM39B19fK5sMx-0,10017
-lemonade/tools/huggingface_load.py,sha256=i4duS1DTs797savylsR5TxZRHg8Rjhd7Ogtb0fgoWNA,18716
+lemonade/tools/huggingface_load.py,sha256=857GxaQcqmSv2DSsMh503aSicwQDQg5wGGlpwehHHrg,18868
 lemonade/tools/humaneval.py,sha256=RCkVR-yOL56T4EyURaU3MR3yhU4NCbeuWHDyhVWZtxw,9502
 lemonade/tools/llamacpp.py,sha256=uv-xv5KfHm0eU1I6vEKuaRC-QpilE1FffVA-zoCvHt4,8659
 lemonade/tools/llamacpp_bench.py,sha256=tZamG-1Z5pG_bD4O4yz2mUo2AWwEgOw9RSdEDllW4HY,5941
 lemonade/tools/management_tools.py,sha256=RO-lU-hjZhrP9KD9qcLI7MrLu-Rxnkrxzn45qqwKInE,8554
 lemonade/tools/mmlu.py,sha256=hNa7A8dhpjOtgfd5MGcagpwpw4_AZRZvVj5Duz9LJ88,11381
 lemonade/tools/perplexity.py,sha256=Z6ha7LS5DhdZWHZxhDz8mDnfESbTGc6TGo8KnPjRmiE,5606
-lemonade/tools/prompt.py,sha256=eFm-KsJCzaO_iDaj5JkwZGxceaw0bnhx60ZieJ095k0,7593
+lemonade/tools/prompt.py,sha256=AhRdWpx5BVnuJTmCsxSCw_oKHRlTiRLmOkriXon_mLE,8629
 lemonade/tools/tool.py,sha256=UsxVYukfm_iM3BfeGYPZxQlTK5UfDfDOl3RIyLr8A1Y,13256
 lemonade/tools/ort_genai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lemonade/tools/ort_genai/oga.py,sha256=-6y90ivX-LuQK3-ZBSM3llXHtKfBmMxdm7mPvTKSYdU,43883
+lemonade/tools/ort_genai/oga.py,sha256=dZ6kbwHBVfzTujAG0ojYDhjS8uH6kwW5xZTcu20hFIc,43886
 lemonade/tools/ort_genai/oga_bench.py,sha256=T3c40NevM3NA7CT98B6vBj1nXfdITDqpfMHYSjhjwpA,5061
 lemonade/tools/quark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lemonade/tools/quark/quark_load.py,sha256=QWzhXP8MehgD_KjnsmN5a-3D5kdI2XZtKTH4HoDoFoo,5572
@@ -45,21 +46,24 @@ lemonade/tools/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 lemonade/tools/report/llm_report.py,sha256=bVHhwCINA-Ok2EdSwAsLubsc83N3KWOVuwTguw7jDcE,6676
 lemonade/tools/report/table.py,sha256=a0TXo1X84RxCSu0un_XM3ANOlhLtPDuqtGwR7eomf2s,24853
 lemonade/tools/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lemonade/tools/server/instructions.py,sha256=Lvm-tRZaYgHkyt3zQkmMChkXO6rUiLoIAunudmMr_D8,13388
-lemonade/tools/server/llamacpp.py,sha256=PeHg1DbMGcf68txFgC1CJJN5HRHEnIJ4_4EDhvqAFUI,9255
-lemonade/tools/server/pydantic_models.py,sha256=z1RAs9hkAFkOfMiTPtmUiC3CD2P6OMI2N0J2ztNs0d4,2179
-lemonade/tools/server/serve.py,sha256=7meKOKVHaODHBYD_3dDJyaiwoC_m4z_FWniZfsZ9cCI,50655
+lemonade/tools/server/instructions.py,sha256=PbQ8HItagIWbJLYf2IVPhthYVi1E878vNdS42qmTc3E,1230
+lemonade/tools/server/llamacpp.py,sha256=YqUzx-TmyvWMrZfue7xURFfgTRLPGGSzNJtF9GERC_8,10184
+lemonade/tools/server/port_utils.py,sha256=24Ryz5cNU0R9L1kuVSapZoyXTZHzhF4y0Yje9MVOrE0,1535
+lemonade/tools/server/serve.py,sha256=O2ZcM1xogIRAqBE49tQ-gTFpEXExlwHOT3bYL1rZgmc,52483
+lemonade/tools/server/thread_utils.py,sha256=pK9K_6DNWoQ78NArkAX3Ym2WsxLnCs9sKTk6TitlYnI,2804
 lemonade/tools/server/tool_calls.py,sha256=xrAlQwKG-nv2xLlf8f9CDSaUbyMn8ZtHkds9iZLG9K8,5230
+lemonade/tools/server/static/instructions.html,sha256=tCkc55LrI4oWQM2VYuK3_m02MvG5XxIcTbCSgxyTAIU,11257
 lemonade/tools/server/static/styles.css,sha256=8U1EejQaqRLQ6QTCF5UG_dLPtLjRwT1menUHMDhaq2M,5045
 lemonade_install/__init__.py,sha256=26zohKg2jgr_5y7tObduWMYQg8zCTWMZHL8lfi2zZVQ,40
 lemonade_install/install.py,sha256=61qUO7kWCLcdjK0_IQZ46-rKP_AWkyznh4YpDclPKyM,28036
-lemonade_sdk-7.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lemonade_sdk-7.0.1.dist-info/licenses/NOTICE.md,sha256=B8lEqi4QE41J9ljz4Riv2JgHD1v8GCZE6nNBHO3KIA0,2135
+lemonade_sdk-7.0.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lemonade_sdk-7.0.3.dist-info/licenses/NOTICE.md,sha256=B8lEqi4QE41J9ljz4Riv2JgHD1v8GCZE6nNBHO3KIA0,2135
 lemonade_server/cli.py,sha256=DR6sIt66K1sZZG3ascEw_6HUgz3UhU9KGUyzxf4nO_A,7351
-lemonade_server/model_manager.py,sha256=WDGDxrKjq-u2GkGWLNUsRk0d74J-RG2yCYEnH8WMnDw,4010
-lemonade_server/server_models.json,sha256=ZSg1R555bLVW4U7BPaYX5ZgwaJVNAP3z1C62dzMRqAM,6198
-lemonade_sdk-7.0.1.dist-info/METADATA,sha256=bvg9-Tzg_v8sTKjkAJtLahpDq_GmLDMDKA9PTisaNGw,5443
-lemonade_sdk-7.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lemonade_sdk-7.0.1.dist-info/entry_points.txt,sha256=gJppn0ETtXXR6ceKWEIRdk42kMC7ps59EmU3NCPyPUk,144
-lemonade_sdk-7.0.1.dist-info/top_level.txt,sha256=10ap5GNiPhalO4V50LRoxA1FqRT9g3Xkia6BITu880k,42
-lemonade_sdk-7.0.1.dist-info/RECORD,,
+lemonade_server/model_manager.py,sha256=-r9JS_fPcoLCQCFKZfkInBIIgT4F1tQ_EIKqMqNYpqM,5546
+lemonade_server/pydantic_models.py,sha256=pdOZW6nAYKWKllMLR7y5wdbIofIznxe5Vehac0Hgqto,2276
+lemonade_server/server_models.json,sha256=3C-lJ2lsNwdy0AKT_US_lcVOoiF3xmadbiOUeOQuJXA,6927
+lemonade_sdk-7.0.3.dist-info/METADATA,sha256=pSSPTu7kUyAh4W8lCVvxS-WAnjMT9Dsyw0r0WHcrxgA,5443
+lemonade_sdk-7.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lemonade_sdk-7.0.3.dist-info/entry_points.txt,sha256=gJppn0ETtXXR6ceKWEIRdk42kMC7ps59EmU3NCPyPUk,144
+lemonade_sdk-7.0.3.dist-info/top_level.txt,sha256=10ap5GNiPhalO4V50LRoxA1FqRT9g3Xkia6BITu880k,42
+lemonade_sdk-7.0.3.dist-info/RECORD,,