lemonade-sdk 8.0.1__tar.gz → 8.0.3__tar.gz

{lemonade_sdk-8.0.1/src/lemonade_sdk.egg-info → lemonade_sdk-8.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemonade-sdk
-Version: 8.0.1
+Version: 8.0.3
 Summary: Lemonade SDK: Your LLM Aide for Validation and Deployment
 Author-email: lemonade@amd.com
 Requires-Python: >=3.10, <3.12
@@ -26,45 +26,49 @@ Requires-Dist: openai>=1.81.0
 Requires-Dist: transformers<=4.51.3
 Requires-Dist: jinja2
 Requires-Dist: tabulate
-Requires-Dist: huggingface-hub==0.30.2
+Requires-Dist: sentencepiece
+Requires-Dist: huggingface-hub==0.33.0
+Provides-Extra: oga-hybrid
+Requires-Dist: onnx==1.16.1; extra == "oga-hybrid"
+Requires-Dist: numpy==1.26.4; extra == "oga-hybrid"
+Requires-Dist: protobuf>=6.30.1; extra == "oga-hybrid"
+Provides-Extra: oga-cpu
+Requires-Dist: onnxruntime-genai==0.8.2; extra == "oga-cpu"
+Requires-Dist: onnxruntime>=1.22.0; extra == "oga-cpu"
+Provides-Extra: dev
+Requires-Dist: torch>=2.6.0; extra == "dev"
+Requires-Dist: accelerate; extra == "dev"
+Requires-Dist: datasets; extra == "dev"
+Requires-Dist: pandas>=1.5.3; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
+Requires-Dist: human-eval-windows==1.0.4; extra == "dev"
+Requires-Dist: lm-eval[api]; extra == "dev"
 Provides-Extra: oga-hybrid-minimal
-Requires-Dist: onnx==1.16.1; extra == "oga-hybrid-minimal"
-Requires-Dist: numpy==1.26.4; extra == "oga-hybrid-minimal"
-Requires-Dist: protobuf>=6.30.1; extra == "oga-hybrid-minimal"
+Requires-Dist: lemonade-sdk[oga-hybrid]; extra == "oga-hybrid-minimal"
 Provides-Extra: oga-cpu-minimal
-Requires-Dist: onnxruntime-genai==0.6.0; extra == "oga-cpu-minimal"
-Requires-Dist: onnxruntime<1.22.0,>=1.10.1; extra == "oga-cpu-minimal"
+Requires-Dist: lemonade-sdk[oga-cpu]; extra == "oga-cpu-minimal"
 Provides-Extra: llm
-Requires-Dist: torch>=2.6.0; extra == "llm"
-Requires-Dist: accelerate; extra == "llm"
-Requires-Dist: sentencepiece; extra == "llm"
-Requires-Dist: datasets; extra == "llm"
-Requires-Dist: pandas>=1.5.3; extra == "llm"
-Requires-Dist: matplotlib; extra == "llm"
-Requires-Dist: human-eval-windows==1.0.4; extra == "llm"
-Requires-Dist: lm-eval[api]; extra == "llm"
+Requires-Dist: lemonade-sdk[dev]; extra == "llm"
 Provides-Extra: llm-oga-cpu
-Requires-Dist: lemonade-sdk[oga-cpu-minimal]; extra == "llm-oga-cpu"
-Requires-Dist: lemonade-sdk[llm]; extra == "llm-oga-cpu"
+Requires-Dist: lemonade-sdk[dev,oga-cpu]; extra == "llm-oga-cpu"
 Provides-Extra: llm-oga-igpu
 Requires-Dist: onnxruntime-genai-directml==0.6.0; extra == "llm-oga-igpu"
 Requires-Dist: onnxruntime-directml<1.22.0,>=1.19.0; extra == "llm-oga-igpu"
 Requires-Dist: transformers<4.45.0; extra == "llm-oga-igpu"
-Requires-Dist: lemonade-sdk[llm]; extra == "llm-oga-igpu"
+Requires-Dist: lemonade-sdk[dev]; extra == "llm-oga-igpu"
 Provides-Extra: llm-oga-cuda
-Requires-Dist: onnxruntime-genai-cuda==0.6.0; extra == "llm-oga-cuda"
-Requires-Dist: onnxruntime-gpu<1.22.0,>=1.19.1; extra == "llm-oga-cuda"
-Requires-Dist: transformers<4.45.0; extra == "llm-oga-cuda"
-Requires-Dist: lemonade-sdk[llm]; extra == "llm-oga-cuda"
+Requires-Dist: onnxruntime-genai-cuda==0.8.2; extra == "llm-oga-cuda"
+Requires-Dist: onnxruntime-gpu>=1.22.0; extra == "llm-oga-cuda"
+Requires-Dist: transformers<=4.51.3; extra == "llm-oga-cuda"
+Requires-Dist: lemonade-sdk[dev]; extra == "llm-oga-cuda"
 Provides-Extra: llm-oga-npu
 Requires-Dist: onnx==1.16.0; extra == "llm-oga-npu"
 Requires-Dist: onnxruntime==1.18.0; extra == "llm-oga-npu"
 Requires-Dist: numpy==1.26.4; extra == "llm-oga-npu"
 Requires-Dist: protobuf>=6.30.1; extra == "llm-oga-npu"
-Requires-Dist: lemonade-sdk[llm]; extra == "llm-oga-npu"
+Requires-Dist: lemonade-sdk[dev]; extra == "llm-oga-npu"
 Provides-Extra: llm-oga-hybrid
-Requires-Dist: lemonade-sdk[oga-hybrid-minimal]; extra == "llm-oga-hybrid"
-Requires-Dist: lemonade-sdk[llm]; extra == "llm-oga-hybrid"
+Requires-Dist: lemonade-sdk[dev,oga-hybrid]; extra == "llm-oga-hybrid"
 Provides-Extra: llm-oga-unified
 Requires-Dist: lemonade-sdk[llm-oga-hybrid]; extra == "llm-oga-unified"
 Dynamic: author-email

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/setup.py

@@ -48,29 +48,30 @@ setup(
         "transformers<=4.51.3",
         "jinja2",
         "tabulate",
-        # huggingface-hub==0.31.0 introduces a new transfer protocol that was causing us issues
-        "huggingface-hub==0.30.2",
+        "sentencepiece",
+        "huggingface-hub==0.33.0",
     ],
     extras_require={
-        # The -minimal extras are meant to deploy specific backends into end-user
+        # The non-dev extras are meant to deploy specific backends into end-user
         # applications, without including developer-focused tools
-        "oga-hybrid-minimal": [
+        "oga-hybrid": [
             # Note: `lemonade-install --ryzenai hybrid` is necessary
             # to complete installation
             "onnx==1.16.1",
             "numpy==1.26.4",
             "protobuf>=6.30.1",
         ],
-        "oga-cpu-minimal": [
-            "onnxruntime-genai==0.6.0",
-            "onnxruntime >=1.10.1,<1.22.0",
+        "oga-cpu": [
+            "onnxruntime-genai==0.8.2",
+            "onnxruntime >=1.22.0",
         ],
-        "llm": [
+        # Developer-focused tools for benchmarking, accuracy testing, and
+        # model preparation (ONNX export, quantization, device-specifc optimization, etc.)
+        "dev": [
             # Minimal dependencies for developers to use all features of
             # Lemonade SDK, including building and optimizing models
             "torch>=2.6.0",
             "accelerate",
-            "sentencepiece",
             "datasets",
             "pandas>=1.5.3",
             "matplotlib",
@@ -79,36 +80,35 @@ setup(
             "human-eval-windows==1.0.4",
             "lm-eval[api]",
         ],
-        "llm-oga-cpu": [
-            "lemonade-sdk[oga-cpu-minimal]",
-            "lemonade-sdk[llm]",
-        ],
+        # Keep backwards compatibility for old extras names
+        "oga-hybrid-minimal": ["lemonade-sdk[oga-hybrid]"],
+        "oga-cpu-minimal": ["lemonade-sdk[oga-cpu]"],
+        "llm": ["lemonade-sdk[dev]"],
+        "llm-oga-cpu": ["lemonade-sdk[dev,oga-cpu]"],
+        # The following extras are deprecated and/or not commonly used
         "llm-oga-igpu": [
             "onnxruntime-genai-directml==0.6.0",
             "onnxruntime-directml>=1.19.0,<1.22.0",
             "transformers<4.45.0",
-            "lemonade-sdk[llm]",
+            "lemonade-sdk[dev]",
         ],
         "llm-oga-cuda": [
-            "onnxruntime-genai-cuda==0.6.0",
-            "onnxruntime-gpu >=1.19.1,<1.22.0",
-            "transformers<4.45.0",
-            "lemonade-sdk[llm]",
+            "onnxruntime-genai-cuda==0.8.2",
+            "onnxruntime-gpu >=1.22.0",
+            "transformers<=4.51.3",
+            "lemonade-sdk[dev]",
         ],
         "llm-oga-npu": [
             "onnx==1.16.0",
+            # NPU requires specific onnxruntime version for Ryzen AI compatibility
+            # This may conflict with other OGA extras that require >=1.22.0
             "onnxruntime==1.18.0",
             "numpy==1.26.4",
             "protobuf>=6.30.1",
-            "lemonade-sdk[llm]",
-        ],
-        "llm-oga-hybrid": [
-            "lemonade-sdk[oga-hybrid-minimal]",
-            "lemonade-sdk[llm]",
-        ],
-        "llm-oga-unified": [
-            "lemonade-sdk[llm-oga-hybrid]",
+            "lemonade-sdk[dev]",
         ],
+        "llm-oga-hybrid": ["lemonade-sdk[dev,oga-hybrid]"],
+        "llm-oga-unified": ["lemonade-sdk[llm-oga-hybrid]"],
     },
     classifiers=[],
     entry_points={

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/cli.py

@@ -90,9 +90,9 @@ https://github.com/lemonade-sdk/lemonade/blob/main/docs/README.md""",
     )
 
     profiler_instances = [
-        profiler(global_args[profiler.unique_name])
+        profiler(global_args[profiler.unique_name.replace("-", "_")])
         for profiler in profilers
-        if global_args.get(profiler.unique_name, None) is not None
+        if global_args.get(profiler.unique_name.replace("-", "_"), None) is not None
     ]
 
     if len(evaluation_tools) > 0:

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/profilers/profiler.py

@@ -48,7 +48,10 @@ class Profiler(abc.ABC):
         This method is called so that the profiler can create its output files.
         The state is passed so that build info can be gathered and stats can be written.
         The timestamp can be used for filename in current working directory.
-        The start times contain a list of tools and start times.
+        The start times parameter is a dict with the keys being the tools names and
+        the values being the time the tool started.  There is an initial "warmup" key
+        that has a start time before the first tool and a "cool down" key that contains the
+        time when the last tool ended.
         """
 
 

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/tools/oga/load.py

@@ -1,12 +1,6 @@
 # onnxruntime_genai is not lint-friendly yet and PyLint can't
 # find any of the class methods
 # pylint: disable=no-member
-#
-# Model builder constraints:
-#   11/10/24 Need transformers <4.45.0 OR onnxruntime-genai 0.5.0 (which must be built from source)
-#   (transformers v4.45 changes the format of the tokenizer.json file which will be supported in
-#   onnxruntime-genai 0.5)
-#
 
 import argparse
 import os
@@ -51,8 +45,8 @@ def import_error_heler(e: Exception):
     """
     raise ImportError(
         f"{e}\n Please install lemonade-sdk with "
-        "one of the llm-oga extras, for example:\n"
-        "pip install lemonade-sdk[llm-oga-cpu]\n"
+        "one of the oga extras, for example:\n"
+        "pip install lemonade-sdk[dev,oga-cpu]\n"
         "See https://lemonade_server.ai/install_options.html for details"
     )
 

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/tools/prompt.py

@@ -176,12 +176,21 @@ class LLMPrompt(Tool):
 
         input_ids = tokenizer(prompt, return_tensors="pt").input_ids
         if isinstance(input_ids, (list, str)):
-            # OGA models return a list of tokens
+            # OGA models return a list of tokens (older versions)
             # Our llama.cpp adapter returns a string
             len_tokens_in = len(input_ids)
-        else:
+        elif hasattr(input_ids, "shape"):
             # HF models return a 2-D tensor
-            len_tokens_in = input_ids.shape[1]
+            # OGA models with newer versions may return numpy arrays
+            if len(input_ids.shape) == 1:
+                # 1-D array from newer OGA versions
+                len_tokens_in = len(input_ids)
+            else:
+                # 2-D tensor from HF models
+                len_tokens_in = input_ids.shape[1]
+        else:
+            # Fallback: try to get length directly
+            len_tokens_in = len(input_ids)
 
         len_tokens_out = []
         response_texts = []
@@ -202,9 +211,15 @@ class LLMPrompt(Tool):
                 random_seed += 1
 
             # Flatten the input and response
-            input_ids_array = (
-                input_ids if isinstance(input_ids, (list, str)) else input_ids[0]
-            )
+            if isinstance(input_ids, (list, str)):
+                input_ids_array = input_ids
+            elif hasattr(input_ids, "shape") and len(input_ids.shape) == 1:
+                # 1-D array from newer OGA versions - already flat
+                input_ids_array = input_ids
+            else:
+                # 2-D tensor from HF models - take first row
+                input_ids_array = input_ids[0]
+
             response_array = response if isinstance(response, str) else response[0]
 
             # Separate the prompt from the response

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/tools/report/table.py

@@ -7,6 +7,7 @@ from tabulate import tabulate
 import lemonade.common.build as build
 import lemonade.common.filesystem as fs
 from lemonade.cache import Keys
+from lemonade.tools.accuracy import LMEvalHarness
 from lemonade.tools.huggingface.bench import HuggingfaceBench
 from lemonade.tools.llamacpp.bench import LlamaCppBench
 from lemonade.tools.mmlu import AccuracyMMLU
@@ -73,6 +74,7 @@ class SimpleStat(TableColumn):
         align="center",
         omit_if_lean=False,
         wrap=None,
+        stat_fn=None,
     ):
         self.column_header = column_header
         self.stat = stat
@@ -80,6 +82,7 @@ class SimpleStat(TableColumn):
         self.align = align
         self.omit_if_lean = omit_if_lean
         self.wrap = wrap or self.default_wrap
+        self.stat_fn = stat_fn
 
     def get_str(self, build_stats, lean=False):
         if lean and self.omit_if_lean:
@@ -87,6 +90,8 @@ class SimpleStat(TableColumn):
         data = build_stats.get(self.stat, None)
         if data is None:
             return ""
+        if self.stat_fn:
+            data = self.stat_fn(data)
         cell_str = "\n".join(
             [_wrap(f"{x:{self.format_str}}", self.wrap) for x in _to_list(data)]
         )
@@ -232,6 +237,47 @@ class AdditionalStat(TableColumn):
         return "\n".join(cell_entry)
 
 
+class DictListStat(TableColumn):
+    """
+    A statistic that is a list of dicts and values from a given list of keys will be
+    pulled out of each dict and placed in the cell
+    """
+
+    def __init__(
+        self,
+        column_header,
+        statistic_name,
+        key_format_list,
+        align="center",
+        omit_if_lean=False,
+        wrap=None,
+    ):
+        self.column_header = column_header
+        self.statistic_name = statistic_name
+        self.key_format_list = key_format_list
+        self.align = align
+        self.omit_if_lean = omit_if_lean
+        self.wrap = wrap or self.default_wrap
+
+    def get_str(self, build_stats, lean=False):
+        if lean and self.omit_if_lean:
+            return None
+        stat = build_stats.get(self.statistic_name, None)
+        if not stat:
+            return ""
+        cell_entry = []
+        for stat_dict in stat:
+            line = [
+                format_str.format(stat_dict[key])
+                for key, format_str in self.key_format_list
+            ]
+            cell_entry.append(" ".join(line))
+        return "\n".join(cell_entry)
+
+    def get_keys(self):
+        return [self.statistic_name]
+
+
 ################################################################################
 # ABSTRACT BASE CLASS FOR DEFINING A TABLE
 ################################################################################
@@ -349,6 +395,28 @@ class Table(ABC):
                     headers.append(column.column_header)
                     col_align += (column.align,)
 
+        # Stat column headers
+        stat_columns = self.table_descriptor.get("stat_columns", [])
+        stat_columns_include = []
+        for column in stat_columns:
+            # Check to see that at least one build has data for the column
+            keep_column = False
+            if not (self.lean and column.omit_if_lean):
+                keys = column.get_keys()
+                for build_stats in self.all_stats:
+                    found = [(key in build_stats) for key in keys]
+                    if any(found):
+                        keep_column = True
+                        headers.append(column.column_header)
+                        col_align += (column.align,)
+                        break
+            stat_columns_include.append(keep_column)
+        stat_columns = [
+            column
+            for column, include in zip(stat_columns, stat_columns_include)
+            if include
+        ]
+
         # Final headers
         last_columns = self.table_descriptor.get("last_columns", [])
         for column in last_columns:
@@ -385,6 +453,12 @@ class Table(ABC):
                     if entry_str is not None:
                         row.append(entry_str)
 
+            # Per stat columns
+            for entry in stat_columns:
+                entry_str = entry.get_str(build_stats, self.lean)
+                if entry_str is not None:
+                    row.append(entry_str)
+
             # Final columns
             for entry in last_columns:
                 entry_str = entry.get_str(build_stats, self.lean)
@@ -513,6 +587,12 @@ class LemonadePerfTable(Table):
                     Keys.STD_DEV_TOKENS_PER_SECOND,
                     ".2f",
                 ),
+                SimpleStat(
+                    _wrap("Total Generated Tokens", 9),
+                    Keys.RESPONSE_TOKENS,
+                    "d",
+                    stat_fn=sum,
+                ),
                 SimpleStat(
                     _wrap("Memory Used (GB)", 8), Keys.MAX_MEMORY_USED_GBYTE, ".3f"
                 ),
@@ -527,7 +607,16 @@ class LemonadePerfTable(Table):
                     ".2f",
                 )
             ],
+            LMEvalHarness: [
+                AdditionalStat(
+                    "EleutherAI\nLM Evaluation",
+                    "^lm_eval_",
+                    "^lm_eval_",
+                    ".1f",
+                )
+            ],
         },
+        "stat_columns": [],
         "last_columns": [
             SimpleStat(
                 "System Info",

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/tools/server/llamacpp.py

@@ -210,15 +210,20 @@ def _log_subprocess_output(
     """
 
     if process.stdout:
-        for line in iter(process.stdout.readline, ""):
-            if line:
-                line_stripped = line.strip()
-                logging.debug("%s: %s", prefix, line_stripped)
+        try:
+            for line in iter(process.stdout.readline, ""):
+                if line:
+                    line_stripped = line.strip()
+                    logging.debug("%s: %s", prefix, line_stripped)
 
-                telemetry.parse_telemetry_line(line_stripped)
+                    telemetry.parse_telemetry_line(line_stripped)
 
-            if process.poll() is not None:
-                break
+                if process.poll() is not None:
+                    break
+        except UnicodeDecodeError as e:
+            logging.debug("Unicode decode error reading subprocess output: %s", str(e))
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging.error("Unexpected error reading subprocess output: %s", str(e))
 
 
 def _wait_for_load(llama_server_process: subprocess.Popen, port: int):
@@ -287,6 +292,8 @@ def _launch_llama_subprocess(
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         text=True,
+        encoding="utf-8",
+        errors="replace",
         bufsize=1,
         env=env,
     )
@@ -383,6 +390,10 @@ def server_load(model_config: PullConfig, telemetry: LlamaTelemetry):
             f"Loading {model_config.model_name} on GPU didn't work, re-attempting on CPU"
         )
 
+        if os.environ.get("LEMONADE_LLAMACPP_NO_FALLBACK"):
+            # Used for testing, when the test should fail if GPU didn't work
+            raise Exception("llamacpp GPU loading failed")
+
         llama_server_process = _launch_llama_subprocess(
             snapshot_files, use_gpu=False, telemetry=telemetry
         )

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/tools/server/static/webapp.html

@@ -110,20 +110,53 @@
     </footer>
     <script src="https://cdn.jsdelivr.net/npm/openai@4.21.0/dist/openai.min.js"></script> 
     <script>    // Tab switching logic 
-    function showTab(tab) { 
+    function showTab(tab, updateHash = true) { 
         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'); 
+            document.getElementById('content-chat').classList.add('active');
+            if (updateHash) {
+                window.location.hash = 'llm-chat';
+            }
         } else { 
             document.getElementById('tab-models').classList.add('active'); 
-            document.getElementById('content-models').classList.add('active'); 
+            document.getElementById('content-models').classList.add('active');
+            if (updateHash) {
+                window.location.hash = 'model-management';
+            }
         } 
     }
 
+    // Handle hash changes for anchor navigation
+    function handleHashChange() {
+        const hash = window.location.hash.slice(1); // Remove the # symbol
+        if (hash === 'llm-chat') {
+            showTab('chat', false);
+        } else if (hash === 'model-management') {
+            showTab('models', false);
+        }
+    }
+
+    // Initialize tab based on URL hash on page load
+    function initializeTabFromHash() {
+        const hash = window.location.hash.slice(1);
+        if (hash === 'llm-chat') {
+            showTab('chat', false);
+        } else if (hash === 'model-management') {
+            showTab('models', false);
+        }
+        // If no hash or unrecognized hash, keep default (chat tab is already active)
+    }
+
+    // Listen for hash changes
+    window.addEventListener('hashchange', handleHashChange);
+
+    // Initialize on page load
+    document.addEventListener('DOMContentLoaded', initializeTabFromHash);
+
     // Toggle Add Model form
     function toggleAddModelForm() {
         const form = document.querySelector('.model-mgmt-register-form');

{lemonade_sdk-8.0.1 → lemonade_sdk-8.0.3}/src/lemonade/tools/server/tray.py

@@ -197,11 +197,17 @@ class LemonadeTray(SystemTray):
         """
         webbrowser.open("https://lemonade-server.ai/docs/")
 
+    def open_llm_chat(self, _, __):
+        """
+        Open the LLM chat in the default web browser.
+        """
+        webbrowser.open(f"http://localhost:{self.port}/#llm-chat")
+
     def open_model_manager(self, _, __):
         """
         Open the model manager in the default web browser.
         """
-        webbrowser.open(f"http://localhost:{self.port}/")
+        webbrowser.open(f"http://localhost:{self.port}/#model-management")
 
     def check_server_state(self):
         """
@@ -266,7 +272,7 @@ class LemonadeTray(SystemTray):
             self.logger.error(f"Error changing port: {str(e)}")
             self.show_balloon_notification("Error", f"Failed to change port: {str(e)}")
 
-    def upgrade_to_latest(self, icon, item):
+    def upgrade_to_latest(self, _, __):
         """
         Download and launch the Lemonade Server installer
         """
@@ -281,21 +287,34 @@ class LemonadeTray(SystemTray):
         installer_path = os.path.join(
             tempfile.gettempdir(), "Lemonade_Server_Installer.exe"
         )
+        if os.path.exists(installer_path):
+            os.remove(installer_path)
 
         # Download the installer
         response = requests.get(self.latest_version_url, stream=True)
         response.raise_for_status()
 
-        # Save the installer to disk
+        # Save the installer to disk and force write to disk
         with open(installer_path, "wb") as f:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
+            f.flush()
+            os.fsync(f.fileno())
 
-        # Launch the installer
-        subprocess.Popen([installer_path], shell=True)
+        # Launch the installer as a completely detached process
+        # subprocess.DETACHED_PROCESS - Creates a process that's not attached to the console
+        # subprocess.CREATE_NEW_PROCESS_GROUP - Creates a new process group
+        # close_fds=True - Closes file descriptors to prevent inheritance
+        subprocess.Popen(
+            [installer_path],
+            creationflags=subprocess.DETACHED_PROCESS
+            | subprocess.CREATE_NEW_PROCESS_GROUP,
+            close_fds=True,
+            shell=True,
+            cwd=tempfile.gettempdir(),
+        )
 
-        # Quit the application
-        self.exit_app(icon, item)
+        # No need to quit the application, the installer will handle it
 
     def create_menu(self):
         """
@@ -326,16 +345,25 @@ class LemonadeTray(SystemTray):
 
         # Create menu items for all downloaded models
         model_menu_items = []
-        for model_name, _ in self.downloaded_models.items():
-            # Create a function that returns the lambda to properly capture the variables
-            def create_handler(mod):
-                return lambda icon, item: self.load_llm(icon, item, mod)
+        if not self.downloaded_models:
+            model_menu_items.append(
+                MenuItem(
+                    "No models available: Use the Model Manager to pull models",
+                    None,
+                    enabled=False,
+                )
+            )
+        else:
+            for model_name, _ in self.downloaded_models.items():
+                # Create a function that returns the lambda to properly capture the variables
+                def create_handler(mod):
+                    return lambda icon, item: self.load_llm(icon, item, mod)
 
-            model_item = MenuItem(model_name, create_handler(model_name))
+                model_item = MenuItem(model_name, create_handler(model_name))
 
-            # Set checked property instead of modifying the text
-            model_item.checked = model_name == self.loaded_llm
-            model_menu_items.append(model_item)
+                # Set checked property instead of modifying the text
+                model_item.checked = model_name == self.loaded_llm
+                model_menu_items.append(model_item)
 
         load_submenu = Menu(*model_menu_items)
 
@@ -378,6 +406,7 @@ class LemonadeTray(SystemTray):
             )
 
         items.append(MenuItem("Documentation", self.open_documentation))
+        items.append(MenuItem("LLM Chat", self.open_llm_chat))
         items.append(MenuItem("Model Manager", self.open_model_manager))
         items.append(MenuItem("Show Logs", self.show_logs))
         items.append(Menu.SEPARATOR)

lemonade_sdk-8.0.3/src/lemonade/version.py

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