lemonade-sdk 7.0.2__tar.gz → 7.0.4__tar.gz

{lemonade_sdk-7.0.2 → lemonade_sdk-7.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemonade-sdk
-Version: 7.0.2
+Version: 7.0.4
 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.2 → lemonade_sdk-7.0.4}/setup.py

@@ -107,7 +107,7 @@ setup(
     include_package_data=True,
     package_data={
         "lemonade_server": ["server_models.json"],
-        "lemonade": ["tools/server/static/styles.css"],
+        "lemonade": ["tools/server/static/*"],
     },
 )
 

{lemonade_sdk-7.0.2 → lemonade_sdk-7.0.4}/src/lemonade/tools/huggingface_load.py

@@ -326,6 +326,7 @@ class HuggingfaceAdapter(ModelAdapter):
     def generate(
         self,
         input_ids,
+        random_seed=1,
         **kwargs,
     ):
 
@@ -346,6 +347,11 @@ class HuggingfaceAdapter(ModelAdapter):
             **kwargs,
         }
 
+        if random_seed is None:
+            torch.random.seed()
+        else:
+            torch.random.manual_seed(random_seed)
+
         with torch.no_grad(), torch.inference_mode():
             outputs = self.model.generate(input_ids=input_ids, **generation_kwargs)
 

{lemonade_sdk-7.0.2 → lemonade_sdk-7.0.4}/src/lemonade/tools/ort_genai/oga.py

@@ -139,6 +139,7 @@ class OrtGenaiModel(ModelAdapter):
         pad_token_id=None,
         stopping_criteria=None,
         max_length=None,
+        random_seed=1,
     ):
         params = og.GeneratorParams(self.model)
 
@@ -179,6 +180,9 @@ class OrtGenaiModel(ModelAdapter):
         if use_oga_pre_6_api:
             params.input_ids = input_ids
 
+        if random_seed is None:
+            random_seed = -1  # In og.Generator, -1 = seed with random device
+
         if self.config and "search" in self.config:
             search_config = self.config["search"]
             params.set_search_options(
@@ -196,10 +200,7 @@ class OrtGenaiModel(ModelAdapter):
                 past_present_share_buffer=search_config.get(
                     "past_present_share_buffer", True
                 ),
-                # Make sure that results do not vary across laptops
-                # by default, random_seed=-1 causes different laptops to give
-                # different results
-                random_seed=1,
+                random_seed=random_seed,
                 # Not currently supported by OGA
                 # diversity_penalty=search_config.get('diversity_penalty', 0.0),
                 # no_repeat_ngram_size=search_config.get('no_repeat_ngram_size', 0),
@@ -212,6 +213,7 @@ class OrtGenaiModel(ModelAdapter):
                 temperature=temperature,
                 max_length=max_length_to_use,
                 min_length=min_length,
+                random_seed=random_seed,
             )
         params.try_graph_capture_with_max_batch_size(1)
 

{lemonade_sdk-7.0.2 → lemonade_sdk-7.0.4}/src/lemonade/tools/prompt.py

@@ -15,6 +15,7 @@ DEFAULT_GENERATE_PARAMS = {
     "temperature": 0.7,
 }
 
+DEFAULT_RANDOM_SEED = 1
 DEFAULT_MAX_NEW_TOKENS = 512
 DEFAULT_N_TRIALS = 1
 
@@ -108,6 +109,19 @@ class LLMPrompt(Tool):
             f"(useful for testing, default is {DEFAULT_N_TRIALS})",
         )
 
+        parser.add_argument(
+            "--random-seed",
+            "-r",
+            default=str(DEFAULT_RANDOM_SEED),
+            help="Positive integer seed for random number generator used in "
+            "sampling tokens "
+            f"(default is {DEFAULT_RANDOM_SEED}). If the number of trials is "
+            "greater than one, then the seed is incremented by one for each "
+            "trial. Set to `None` for random, non-repeatable results.  This "
+            "random seed behavior only applies to models loaded with "
+            "`oga-load` or `huggingface-load`.",
+        )
+
         return parser
 
     def parse(self, state: State, args, known_only=True) -> argparse.Namespace:
@@ -123,6 +137,11 @@ class LLMPrompt(Tool):
             with open(parsed_args.prompt, "r", encoding="utf-8") as f:
                 parsed_args.prompt = f.read()
 
+        if parsed_args.random_seed == "None":
+            parsed_args.random_seed = None
+        else:
+            parsed_args.random_seed = int(parsed_args.random_seed)
+
         return parsed_args
 
     def run(
@@ -132,6 +151,7 @@ class LLMPrompt(Tool):
         max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,
         n_trials: int = DEFAULT_N_TRIALS,
         template: bool = False,
+        random_seed: int = DEFAULT_RANDOM_SEED,
     ) -> State:
 
         model: ModelAdapter = state.model
@@ -170,9 +190,16 @@ class LLMPrompt(Tool):
 
             # Get the response from the LLM, which may include the prompt in it
             response = model.generate(
-                input_ids, max_new_tokens=max_new_tokens, **DEFAULT_GENERATE_PARAMS
+                input_ids,
+                max_new_tokens=max_new_tokens,
+                random_seed=random_seed,
+                **DEFAULT_GENERATE_PARAMS,
             )
 
+            # Increment random seed if not none
+            if random_seed is not None:
+                random_seed += 1
+
             # Flatten the input and response
             input_ids_array = (
                 input_ids if isinstance(input_ids, (list, str)) else input_ids[0]

lemonade_sdk-7.0.4/src/lemonade/tools/server/instructions.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+import json
+from fastapi.responses import HTMLResponse
+from lemonade_server.model_manager import ModelManager
+
+
+def get_instructions_html(port=8000):
+    """
+    Show instructions on how to use the server.
+    """
+    # Load server models from JSON
+    server_models_path = (
+        Path(__file__).parent.parent.parent.parent
+        / "lemonade_server"
+        / "server_models.json"
+    )
+    with open(server_models_path, "r", encoding="utf-8") as f:
+        server_models = json.load(f)
+
+    # Use shared filter function from model_manager.py
+    filtered_models = ModelManager().filter_models_by_backend(server_models)
+
+    # Pass filtered server_models to JS
+    server_models_js = (
+        f"<script>window.SERVER_MODELS = {json.dumps(filtered_models)};</script>"
+    )
+
+    # Load HTML template
+    template_path = Path(__file__).parent / "static" / "instructions.html"
+    with open(template_path, "r", encoding="utf-8") as f:
+        html_template = f.read()
+
+    # Replace template variables
+    html_content = html_template.replace("{{SERVER_PORT}}", str(port))
+    html_content = html_content.replace("{{SERVER_MODELS_JS}}", server_models_js)
+
+    return HTMLResponse(content=html_content)

{lemonade_sdk-7.0.2 → lemonade_sdk-7.0.4}/src/lemonade/tools/server/llamacpp.py

@@ -14,8 +14,8 @@ from fastapi.responses import StreamingResponse
 
 from openai import OpenAI
 
+from lemonade_server.pydantic_models import ChatCompletionRequest
 from lemonade_server.model_manager import ModelManager
-from lemonade.tools.server.pydantic_models import ChatCompletionRequest
 from lemonade.tools.server.port_utils import find_free_port
 
 LLAMA_VERSION = "b5543"
@@ -145,16 +145,14 @@ def _log_subprocess_output(
                 break
 
 
-def _wait_for_load(
-    llama_server_process: subprocess.Popen, port: int, fail_message: str
-):
+def _wait_for_load(llama_server_process: subprocess.Popen, port: int):
     status_code = None
     while not llama_server_process.poll() and status_code != 200:
         health_url = f"http://localhost:{port}/health"
         try:
             health_response = requests.get(health_url)
         except requests.exceptions.ConnectionError:
-            logging.warning(fail_message)
+            logging.debug("Not able to connect to llama-server yet, will retry")
         else:
             status_code = health_response.status_code
             logging.debug(
@@ -165,24 +163,25 @@ def _wait_for_load(
 
 
 def _launch_llama_subprocess(
-    model_path: str, use_gpu: bool, telemetry: LlamaTelemetry
+    snapshot_files: dict, use_gpu: bool, telemetry: LlamaTelemetry
 ) -> subprocess.Popen:
     """
     Launch llama server subprocess with GPU or CPU configuration
     """
 
+    # Build the base command
+    base_command = [LLAMA_SERVER_EXE_PATH, "-m", snapshot_files["variant"]]
+    if "mmproj" in snapshot_files:
+        base_command.extend(["--mmproj", snapshot_files["mmproj"]])
+        if not use_gpu:
+            base_command.extend(["--no-mmproj-offload"])
+
     # Find a port, and save it in the telemetry object for future reference
     # by other functions
     telemetry.choose_port()
 
-    base_command = [
-        LLAMA_SERVER_EXE_PATH,
-        "-m",
-        model_path,
-        "--port",
-        str(telemetry.port),
-        "--jinja",
-    ]
+    # Add port and jinja to enable tool use
+    base_command.extend(["--port", str(telemetry.port), "--jinja"])
 
     # Configure GPU layers: 99 for GPU, 0 for CPU-only
     ngl_value = "99" if use_gpu else "0"
@@ -204,7 +203,7 @@ def _launch_llama_subprocess(
     return process
 
 
-def server_load(checkpoint: str, model_reference: str, telemetry: LlamaTelemetry):
+def server_load(model_config: dict, model_reference: str, telemetry: LlamaTelemetry):
     # Download llama.cpp server if it isn't already available
     if not os.path.exists(LLAMA_SERVER_EXE_DIR):
         # Download llama.cpp server zip
@@ -236,36 +235,37 @@ def server_load(checkpoint: str, model_reference: str, telemetry: LlamaTelemetry
         logging.info("Cleaned up zip file")
 
     # Download the gguf to the hugging face cache
-    snapshot_path = ModelManager().download_gguf(checkpoint)
-    model_path = os.path.join(snapshot_path, os.listdir(snapshot_path)[0])
-    logging.debug(f"GGUF file path: {model_path}")
+    snapshot_files = ModelManager().download_gguf(model_config)
+    logging.debug(f"GGUF file paths: {snapshot_files}")
 
     # Start the llama-serve.exe process
     logging.debug(f"Using llama_server for GGUF model: {LLAMA_SERVER_EXE_PATH}")
 
     # Attempt loading on GPU first
     llama_server_process = _launch_llama_subprocess(
-        model_path, use_gpu=True, telemetry=telemetry
+        snapshot_files, use_gpu=True, telemetry=telemetry
     )
 
     # Check the /health endpoint until GPU server is ready
     _wait_for_load(
         llama_server_process,
         telemetry.port,
-        f"Loading {model_reference} on GPU didn't work, re-attempting on CPU",
     )
 
     # If loading on GPU failed, try loading on CPU
     if llama_server_process.poll():
+        logging.warning(
+            f"Loading {model_reference} on GPU didn't work, re-attempting on CPU"
+        )
+
         llama_server_process = _launch_llama_subprocess(
-            model_path, use_gpu=False, telemetry=telemetry
+            snapshot_files, use_gpu=False, telemetry=telemetry
         )
 
         # Check the /health endpoint until CPU server is ready
         _wait_for_load(
             llama_server_process,
             telemetry.port,
-            f"Loading {model_reference} on CPU didn't work",
         )
 
     if llama_server_process.poll():

{lemonade_sdk-7.0.2 → lemonade_sdk-7.0.4}/src/lemonade/tools/server/serve.py

@@ -46,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,
@@ -56,6 +54,8 @@ 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
@@ -1103,7 +1103,6 @@ class Server(ManagementTool):
         """
         Report server health information to the client.
         """
-        self.stop_event.set()
 
         return {
             "status": "ok",
@@ -1200,7 +1199,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
@@ -1293,7 +1292,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,
                     )

lemonade_sdk-7.0.4/src/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_sdk-7.0.4/src/lemonade/version.py

@@ -0,0 +1 @@
+__version__ = "7.0.4"

{lemonade_sdk-7.0.2 → lemonade_sdk-7.0.4}/src/lemonade_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemonade-sdk
-Version: 7.0.2
+Version: 7.0.4
 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.2 → lemonade_sdk-7.0.4}/src/lemonade_sdk.egg-info/SOURCES.txt

@@ -54,10 +54,10 @@ src/lemonade/tools/server/__init__.py
 src/lemonade/tools/server/instructions.py
 src/lemonade/tools/server/llamacpp.py
 src/lemonade/tools/server/port_utils.py
-src/lemonade/tools/server/pydantic_models.py
 src/lemonade/tools/server/serve.py
 src/lemonade/tools/server/thread_utils.py
 src/lemonade/tools/server/tool_calls.py
+src/lemonade/tools/server/static/instructions.html
 src/lemonade/tools/server/static/styles.css
 src/lemonade_install/__init__.py
 src/lemonade_install/install.py
@@ -69,4 +69,5 @@ src/lemonade_sdk.egg-info/requires.txt
 src/lemonade_sdk.egg-info/top_level.txt
 src/lemonade_server/cli.py
 src/lemonade_server/model_manager.py
+src/lemonade_server/pydantic_models.py
 src/lemonade_server/server_models.json