llms-py 3.0.9__py3-none-any.whl → 3.0.11__py3-none-any.whl

llms/extensions/app/db.py

@@ -528,9 +528,9 @@ class AppDB:
         with self.db.create_writer_connection() as conn:
             conn.execute(
                 "UPDATE thread SET completedAt = :completedAt, error = :error WHERE completedAt IS NULL",
-                {"completedAt": datetime.now(), "error": "Server Shutdown"},
+                {"completedAt": datetime.now().isoformat(" "), "error": "Server Shutdown"},
             )
             conn.execute(
                 "UPDATE request SET completedAt = :completedAt, error = :error WHERE completedAt IS NULL",
-                {"completedAt": datetime.now(), "error": "Server Shutdown"},
+                {"completedAt": datetime.now().isoformat(" "), "error": "Server Shutdown"},
             )

llms/extensions/providers/anthropic.py

@@ -77,9 +77,17 @@ def install_anthropic(ctx):
 
                 anthropic_message = {"role": message.get("role"), "content": []}
 
+                # Handle interleaved thinking (must always be a list if present)
+                if "thinking" in message and message["thinking"]:
+                    anthropic_message["content"].append({"type": "thinking", "thinking": message["thinking"]})
+
                 content = message.get("content", "")
                 if isinstance(content, str):
-                    anthropic_message["content"] = content
+                    if anthropic_message["content"]:
+                        # If we have thinking, we must use blocks for text
+                        anthropic_message["content"].append({"type": "text", "text": content})
+                    else:
+                        anthropic_message["content"] = content
                 elif isinstance(content, list):
                     for item in content:
                         if item.get("type") == "text":

llms/main.py

@@ -18,6 +18,7 @@ import mimetypes
 import os
 import re
 import secrets
+import shlex
 import shutil
 import site
 import subprocess
@@ -25,10 +26,11 @@ import sys
 import time
 import traceback
 from datetime import datetime
+from enum import IntEnum
 from importlib import resources  # Py≥3.9  (pip install importlib_resources for 3.7/3.8)
 from io import BytesIO
 from pathlib import Path
-from typing import Optional, get_type_hints
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union, get_type_hints
 from urllib.parse import parse_qs, urlencode, urljoin
 
 import aiohttp
@@ -41,7 +43,7 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.9"
+VERSION = "3.0.11"
 _ROOT = None
 DEBUG = os.getenv("DEBUG") == "1"
 MOCK = os.getenv("MOCK") == "1"
@@ -59,6 +61,12 @@ g_oauth_states = {}  # CSRF protection: {state: {created, redirect_uri}}
 g_app = None  # ExtensionsContext Singleton
 
 
+class ExitCode(IntEnum):
+    SUCCESS = 0
+    FAILED = 1
+    UNHANDLED = 9
+
+
 def _log(message):
     if g_verbose:
         print(f"{g_logprefix}{message}", flush=True)
@@ -1853,12 +1861,18 @@ def config_str(key):
     return key in g_config and g_config[key] or None
 
 
-def load_config(config, providers, verbose=None):
+def load_config(config, providers, verbose=None, debug=None, disable_extensions: List[str] = None):
     global g_config, g_providers, g_verbose
     g_config = config
     g_providers = providers
-    if verbose:
+    if verbose is not None:
         g_verbose = verbose
+    if debug is not None:
+        global DEBUG
+        DEBUG = debug
+    if disable_extensions:
+        global DISABLE_EXTENSIONS
+        DISABLE_EXTENSIONS = disable_extensions
 
 
 def init_llms(config, providers):
@@ -2539,7 +2553,7 @@ class AppExtensions:
     APIs extensions can use to extend the app
     """
 
-    def __init__(self, cli_args, extra_args):
+    def __init__(self, cli_args: argparse.Namespace, extra_args: Dict[str, Any]):
         self.cli_args = cli_args
         self.extra_args = extra_args
         self.config = None
@@ -2615,12 +2629,12 @@ class AppExtensions:
             "ctx.mjs": "/ui/ctx.mjs",
         }
 
-    def set_config(self, config):
+    def set_config(self, config: Dict[str, Any]):
         self.config = config
         self.auth_enabled = self.config.get("auth", {}).get("enabled", False)
 
     # Authentication middleware helper
-    def check_auth(self, request):
+    def check_auth(self, request: web.Request) -> Tuple[bool, Optional[Dict[str, Any]]]:
         """Check if request is authenticated. Returns (is_authenticated, user_data)"""
         if not self.auth_enabled:
             return True, None
@@ -2639,7 +2653,7 @@ class AppExtensions:
 
         return False, None
 
-    def get_session(self, request):
+    def get_session(self, request: web.Request) -> Optional[Dict[str, Any]]:
         session_token = get_session_token(request)
 
         if not session_token or session_token not in g_sessions:
@@ -2648,30 +2662,39 @@ class AppExtensions:
         session_data = g_sessions[session_token]
         return session_data
 
-    def get_username(self, request):
+    def get_username(self, request: web.Request) -> Optional[str]:
         session = self.get_session(request)
         if session:
             return session.get("userName")
         return None
 
-    def get_user_path(self, username=None):
+    def get_user_path(self, username: Optional[str] = None) -> str:
         if username:
             return home_llms_path(os.path.join("user", username))
         return home_llms_path(os.path.join("user", "default"))
 
-    def chat_request(self, template=None, text=None, model=None, system_prompt=None):
+    def get_providers(self) -> Dict[str, Any]:
+        return g_handlers
+
+    def chat_request(
+        self,
+        template: Optional[str] = None,
+        text: Optional[str] = None,
+        model: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+    ) -> Dict[str, Any]:
         return g_chat_request(template=template, text=text, model=model, system_prompt=system_prompt)
 
-    async def chat_completion(self, chat, context=None):
+    async def chat_completion(self, chat: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> Any:
         response = await g_chat_completion(chat, context)
         return response
 
-    def on_cache_saved_filters(self, context):
+    def on_cache_saved_filters(self, context: Dict[str, Any]):
         # _log(f"on_cache_saved_filters {len(self.cache_saved_filters)}: {context['url']}")
         for filter_func in self.cache_saved_filters:
             filter_func(context)
 
-    async def on_chat_error(self, e, context):
+    async def on_chat_error(self, e: Exception, context: Dict[str, Any]):
         # Apply chat error filters
         if "stackTrace" not in context:
             context["stackTrace"] = traceback.format_exc()
@@ -2681,25 +2704,27 @@ class AppExtensions:
             except Exception as e:
                 _err("chat error filter failed", e)
 
-    async def on_chat_tool(self, chat, context):
+    async def on_chat_tool(self, chat: Dict[str, Any], context: Dict[str, Any]):
         m_len = len(chat.get("messages", []))
         t_len = len(self.chat_tool_filters)
         _dbg(
-            f"on_tool_call for thread {context.get('threadId', None)} with {m_len} {pluralize('message', m_len)}, invoking {t_len} {pluralize('filter', t_len)}:"
+            f"on_tool_call for thread {context.get('threadId')} with {m_len} {pluralize('message', m_len)}, invoking {t_len} {pluralize('filter', t_len)}:"
         )
         for filter_func in self.chat_tool_filters:
             await filter_func(chat, context)
 
-    def exit(self, exit_code=0):
+    def shutdown(self):
         if len(self.shutdown_handlers) > 0:
             _dbg(f"running {len(self.shutdown_handlers)} shutdown handlers...")
             for handler in self.shutdown_handlers:
                 handler()
 
+    def exit(self, exit_code: int = 0):
+        self.shutdown()
         _dbg(f"exit({exit_code})")
         sys.exit(exit_code)
 
-    def create_chat_with_tools(self, chat, use_tools="all"):
+    def create_chat_with_tools(self, chat: Dict[str, Any], use_tools: str = "all") -> Dict[str, Any]:
         # Inject global tools if present
         current_chat = chat.copy()
         tools = current_chat.get("tools")
@@ -2728,7 +2753,7 @@ def handler_name(handler):
 
 
 class ExtensionContext:
-    def __init__(self, app, path):
+    def __init__(self, app: AppExtensions, path: str):
         self.app = app
         self.cli_args = app.cli_args
         self.extra_args = app.extra_args
@@ -2746,101 +2771,107 @@ class ExtensionContext:
         self.request_args = app.request_args
         self.disabled = False
 
-    def chat_to_prompt(self, chat):
+    def chat_to_prompt(self, chat: Dict[str, Any]) -> str:
         return chat_to_prompt(chat)
 
-    def chat_to_system_prompt(self, chat):
+    def chat_to_system_prompt(self, chat: Dict[str, Any]) -> str:
         return chat_to_system_prompt(chat)
 
-    def chat_response_to_message(self, response):
+    def chat_response_to_message(self, response: Dict[str, Any]) -> Dict[str, Any]:
         return chat_response_to_message(response)
 
-    def last_user_prompt(self, chat):
+    def last_user_prompt(self, chat: Dict[str, Any]) -> str:
         return last_user_prompt(chat)
 
-    def to_file_info(self, chat, info=None, response=None):
+    def to_file_info(
+        self, chat: Dict[str, Any], info: Optional[Dict[str, Any]] = None, response: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
         return to_file_info(chat, info=info, response=response)
 
-    def save_image_to_cache(self, base64_data, filename, image_info, ignore_info=False):
+    def save_image_to_cache(
+        self, base64_data: Union[str, bytes], filename: str, image_info: Dict[str, Any], ignore_info: bool = False
+    ) -> Tuple[str, Optional[Dict[str, Any]]]:
         return save_image_to_cache(base64_data, filename, image_info, ignore_info=ignore_info)
 
-    def save_bytes_to_cache(self, bytes_data, filename, file_info):
+    def save_bytes_to_cache(
+        self, bytes_data: Union[str, bytes], filename: str, file_info: Optional[Dict[str, Any]]
+    ) -> Tuple[str, Optional[Dict[str, Any]]]:
         return save_bytes_to_cache(bytes_data, filename, file_info)
 
-    def text_from_file(self, path):
+    def text_from_file(self, path: str) -> str:
         return text_from_file(path)
 
-    def json_from_file(self, path):
+    def json_from_file(self, path: str) -> Any:
         return json_from_file(path)
 
-    def download_file(self, url):
+    def download_file(self, url: str) -> Tuple[bytes, Dict[str, Any]]:
         return download_file(url)
 
-    def session_download_file(self, session, url):
+    def session_download_file(self, session: aiohttp.ClientSession, url: str) -> Tuple[bytes, Dict[str, Any]]:
         return session_download_file(session, url)
 
-    def read_binary_file(self, url):
+    def read_binary_file(self, url: str) -> Tuple[bytes, Dict[str, Any]]:
         return read_binary_file(url)
 
-    def log(self, message):
+    def log(self, message: Any):
         if self.verbose:
             print(f"[{self.name}] {message}", flush=True)
         return message
 
-    def log_json(self, obj):
+    def log_json(self, obj: Any):
         if self.verbose:
             print(f"[{self.name}] {json.dumps(obj, indent=2)}", flush=True)
         return obj
 
-    def dbg(self, message):
+    def dbg(self, message: Any):
         if self.debug:
             print(f"DEBUG [{self.name}]: {message}", flush=True)
 
-    def err(self, message, e):
+    def err(self, message: str, e: Exception):
         print(f"ERROR [{self.name}]: {message}", e)
         if self.verbose:
             print(traceback.format_exc(), flush=True)
 
-    def error_message(self, e):
+    def error_message(self, e: Exception) -> str:
         return to_error_message(e)
 
-    def error_response(self, e, stacktrace=False):
+    def error_response(self, e: Exception, stacktrace: bool = False) -> Dict[str, Any]:
         return to_error_response(e, stacktrace=stacktrace)
 
-    def add_provider(self, provider):
+    def add_provider(self, provider: Any):
         self.log(f"Registered provider: {provider.__name__}")
         self.app.all_providers.append(provider)
 
-    def register_ui_extension(self, index):
+    def register_ui_extension(self, index: str):
         path = os.path.join(self.ext_prefix, index)
         self.log(f"Registered UI extension: {path}")
         self.app.ui_extensions.append({"id": self.name, "path": path})
 
-    def register_chat_request_filter(self, handler):
+    def register_chat_request_filter(self, handler: Callable):
         self.log(f"Registered chat request filter: {handler_name(handler)}")
         self.app.chat_request_filters.append(handler)
 
-    def register_chat_tool_filter(self, handler):
+    def register_chat_tool_filter(self, handler: Callable):
         self.log(f"Registered chat tool filter: {handler_name(handler)}")
         self.app.chat_tool_filters.append(handler)
 
-    def register_chat_response_filter(self, handler):
+    def register_chat_response_filter(self, handler: Callable):
         self.log(f"Registered chat response filter: {handler_name(handler)}")
         self.app.chat_response_filters.append(handler)
 
-    def register_chat_error_filter(self, handler):
+    def register_chat_error_filter(self, handler: Callable):
         self.log(f"Registered chat error filter: {handler_name(handler)}")
         self.app.chat_error_filters.append(handler)
 
-    def register_cache_saved_filter(self, handler):
+    def register_cache_saved_filter(self, handler: Callable):
         self.log(f"Registered cache saved filter: {handler_name(handler)}")
         self.app.cache_saved_filters.append(handler)
 
-    def register_shutdown_handler(self, handler):
+    def register_shutdown_handler(self, handler: Callable):
         self.log(f"Registered shutdown handler: {handler_name(handler)}")
         self.app.shutdown_handlers.append(handler)
 
-    def add_static_files(self, ext_dir):
+    def add_static_files(self, ext_dir: str):
         self.log(f"Registered static files: {ext_dir}")
 
         async def serve_static(request):
@@ -2852,57 +2883,63 @@ class ExtensionContext:
 
         self.app.server_add_get.append((os.path.join(self.ext_prefix, "{path:.*}"), serve_static, {}))
 
-    def web_path(self, method, path):
+    def web_path(self, method: str, path: str) -> str:
         full_path = os.path.join(self.ext_prefix, path) if path else self.ext_prefix
         self.dbg(f"Registered {method:<6} {full_path}")
         return full_path
 
-    def add_get(self, path, handler, **kwargs):
+    def add_get(self, path: str, handler: Callable, **kwargs: Any):
         self.app.server_add_get.append((self.web_path("GET", path), handler, kwargs))
 
-    def add_post(self, path, handler, **kwargs):
+    def add_post(self, path: str, handler: Callable, **kwargs: Any):
         self.app.server_add_post.append((self.web_path("POST", path), handler, kwargs))
 
-    def add_put(self, path, handler, **kwargs):
+    def add_put(self, path: str, handler: Callable, **kwargs: Any):
         self.app.server_add_put.append((self.web_path("PUT", path), handler, kwargs))
 
-    def add_delete(self, path, handler, **kwargs):
+    def add_delete(self, path: str, handler: Callable, **kwargs: Any):
         self.app.server_add_delete.append((self.web_path("DELETE", path), handler, kwargs))
 
-    def add_patch(self, path, handler, **kwargs):
+    def add_patch(self, path: str, handler: Callable, **kwargs: Any):
         self.app.server_add_patch.append((self.web_path("PATCH", path), handler, kwargs))
 
-    def add_importmaps(self, dict):
+    def add_importmaps(self, dict: Dict[str, str]):
         self.app.import_maps.update(dict)
 
-    def add_index_header(self, html):
+    def add_index_header(self, html: str):
         self.app.index_headers.append(html)
 
-    def add_index_footer(self, html):
+    def add_index_footer(self, html: str):
         self.app.index_footers.append(html)
 
-    def get_config(self):
+    def get_config(self) -> Optional[Dict[str, Any]]:
         return g_config
 
-    def get_cache_path(self, path=""):
+    def get_cache_path(self, path: str = "") -> str:
         return get_cache_path(path)
 
-    def get_file_mime_type(self, filename):
+    def get_file_mime_type(self, filename: str) -> str:
         return get_file_mime_type(filename)
 
-    def chat_request(self, template=None, text=None, model=None, system_prompt=None):
+    def chat_request(
+        self,
+        template: Optional[str] = None,
+        text: Optional[str] = None,
+        model: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+    ) -> Dict[str, Any]:
         return self.app.chat_request(template=template, text=text, model=model, system_prompt=system_prompt)
 
-    def chat_completion(self, chat, context=None):
-        return self.app.chat_completion(chat, context=context)
+    async def chat_completion(self, chat: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> Any:
+        return await self.app.chat_completion(chat, context=context)
 
-    def get_providers(self):
+    def get_providers(self) -> Dict[str, Any]:
         return g_handlers
 
-    def get_provider(self, name):
+    def get_provider(self, name: str) -> Optional[Any]:
         return g_handlers.get(name)
 
-    def sanitize_tool_def(self, tool_def):
+    def sanitize_tool_def(self, tool_def: Dict[str, Any]) -> Dict[str, Any]:
         """
         Merge $defs parameter into tool_def property to reduce client/server complexity
         """
@@ -2942,7 +2979,7 @@ class ExtensionContext:
             parameters = func_def.get("parameters", {})
             defs = parameters.get("$defs", {})
             properties = parameters.get("properties", {})
-            for prop_name, prop_def in properties.items():
+            for _, prop_def in properties.items():
                 if "$ref" in prop_def:
                     ref = prop_def["$ref"]
                     if ref.startswith("#/$defs/"):
@@ -2954,7 +2991,7 @@ class ExtensionContext:
                 del parameters["$defs"]
         return tool_def
 
-    def register_tool(self, func, tool_def=None, group=None):
+    def register_tool(self, func: Callable, tool_def: Optional[Dict[str, Any]] = None, group: Optional[str] = None):
         if tool_def is None:
             tool_def = function_to_tool_definition(func)
 
@@ -2976,54 +3013,61 @@ class ExtensionContext:
             self.app.tool_groups[group] = []
         self.app.tool_groups[group].append(name)
 
-    def get_tool_definition(self, name):
+    def get_tool_definition(self, name: str) -> Optional[Dict[str, Any]]:
         for tool_def in self.app.tool_definitions:
             if tool_def["function"]["name"] == name:
                 return tool_def
         return None
 
-    def group_resources(self, resources: list):
+    def group_resources(self, resources: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
         return group_resources(resources)
 
-    def check_auth(self, request):
+    def check_auth(self, request: web.Request) -> Tuple[bool, Optional[Dict[str, Any]]]:
         return self.app.check_auth(request)
 
-    def get_session(self, request):
+    def get_session(self, request: web.Request) -> Optional[Dict[str, Any]]:
         return self.app.get_session(request)
 
-    def get_username(self, request):
+    def get_username(self, request: web.Request) -> Optional[str]:
         return self.app.get_username(request)
 
-    def get_user_path(self, username=None):
+    def get_user_path(self, username: Optional[str] = None) -> str:
         return self.app.get_user_path(username)
 
-    def context_to_username(self, context):
+    def context_to_username(self, context: Optional[Dict[str, Any]]) -> Optional[str]:
         if context and "request" in context:
             return self.get_username(context["request"])
         return None
 
-    def should_cancel_thread(self, context):
+    def should_cancel_thread(self, context: Dict[str, Any]) -> bool:
         return should_cancel_thread(context)
 
-    def cache_message_inline_data(self, message):
+    def cache_message_inline_data(self, message: Dict[str, Any]):
         return cache_message_inline_data(message)
 
-    async def exec_tool(self, name, args):
+    async def exec_tool(self, name: str, args: Dict[str, Any]) -> Tuple[Optional[str], List[Dict[str, Any]]]:
         return await g_exec_tool(name, args)
 
-    def tool_result(self, result, function_name: Optional[str] = None, function_args: Optional[dict] = None):
+    def tool_result(
+        self, result: Any, function_name: Optional[str] = None, function_args: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
         return g_tool_result(result, function_name, function_args)
 
-    def tool_result_part(self, result: dict, function_name: Optional[str] = None, function_args: Optional[dict] = None):
+    def tool_result_part(
+        self,
+        result: Dict[str, Any],
+        function_name: Optional[str] = None,
+        function_args: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
         return tool_result_part(result, function_name, function_args)
 
-    def to_content(self, result):
+    def to_content(self, result: Any) -> str:
         return to_content(result)
 
-    def create_chat_with_tools(self, chat, use_tools="all"):
+    def create_chat_with_tools(self, chat: Dict[str, Any], use_tools: str = "all") -> Dict[str, Any]:
         return self.app.create_chat_with_tools(chat, use_tools)
 
-    def chat_to_aspect_ratio(self, chat):
+    def chat_to_aspect_ratio(self, chat: Dict[str, Any]) -> str:
         return chat_to_aspect_ratio(chat)
 
 
@@ -3080,7 +3124,21 @@ def get_extensions_dirs():
     return ret
 
 
+def verify_root_path():
+    global _ROOT
+    _ROOT = os.getenv("LLMS_ROOT", resolve_root())
+    if not _ROOT:
+        print("Resource root not found")
+        exit(1)
+
+
 def init_extensions(parser):
+    """
+    Programmatic entry point for the CLI.
+    Example: cli("ls minimax")
+    """
+    verify_root_path()
+
     """
     Initializes extensions by loading their __init__.py files and calling the __parser__ function if it exists.
     """
@@ -3235,14 +3293,7 @@ def run_extension_cli():
                     return False
 
 
-def main():
-    global _ROOT, g_verbose, g_default_model, g_logprefix, g_providers, g_config, g_config_path, g_app
-
-    _ROOT = os.getenv("LLMS_ROOT", resolve_root())
-    if not _ROOT:
-        print("Resource root not found")
-        exit(1)
-
+def create_arg_parser():
     parser = argparse.ArgumentParser(description=f"llms v{VERSION}")
     parser.add_argument("--config", default=None, help="Path to config file", metavar="FILE")
     parser.add_argument("--providers", default=None, help="Path to models.dev providers file", metavar="FILE")
@@ -3311,11 +3362,13 @@ def main():
         help="Update an extension (use 'all' to update all extensions)",
         metavar="EXTENSION",
     )
+    return parser
 
-    # Load parser extensions, go through all extensions and load their parser arguments
-    init_extensions(parser)
 
-    cli_args, extra_args = parser.parse_known_args()
+def cli_exec(cli_args, extra_args):
+    global _ROOT, g_verbose, g_default_model, g_logprefix, g_providers, g_config, g_config_path, g_app
+
+    verify_root_path()
 
     g_app = AppExtensions(cli_args, extra_args)
 
@@ -3351,12 +3404,12 @@ def main():
         else:
             asyncio.run(save_text_url(github_url("providers-extra.json"), home_providers_extra_path))
             print(f"Created default extra providers config at {home_providers_extra_path}")
-        exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.providers:
         if not os.path.exists(cli_args.providers):
             print(f"providers.json not found at {cli_args.providers}")
-            exit(1)
+            return ExitCode.FAILED
         g_providers = json.loads(text_from_file(cli_args.providers))
 
     if cli_args.config:
@@ -3385,7 +3438,7 @@ def main():
     if cli_args.update_providers:
         asyncio.run(update_providers(home_providers_path))
         print(f"Updated {home_providers_path}")
-        exit(0)
+        return ExitCode.SUCCESS
 
     # if home_providers_path is older than 1 day, update providers list
     if (
@@ -3418,7 +3471,7 @@ def main():
                 print("  llms --add <github-user>/<repo>")
 
             asyncio.run(list_extensions())
-            exit(0)
+            return ExitCode.SUCCESS
 
         async def install_extension(name):
             # Determine git URL and target directory name
@@ -3481,7 +3534,7 @@ def main():
                     os.rmdir(target_path)
 
         asyncio.run(install_extension(cli_args.add))
-        exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.remove is not None:
         if cli_args.remove == "ls":
@@ -3490,11 +3543,11 @@ def main():
             extensions = os.listdir(extensions_path)
             if len(extensions) == 0:
                 print("No extensions installed.")
-                exit(0)
+                return ExitCode.SUCCESS
             print("Installed extensions:")
             for extension in extensions:
                 print(f"  {extension}")
-            exit(0)
+            return ExitCode.SUCCESS
         # Remove an extension
         extension_name = cli_args.remove
         extensions_path = get_extensions_path()
@@ -3502,7 +3555,7 @@ def main():
 
         if not os.path.exists(target_path):
             print(f"Extension {extension_name} not found at {target_path}")
-            exit(1)
+            return ExitCode.FAILED
 
         print(f"Removing extension: {extension_name}...")
         try:
@@ -3510,9 +3563,9 @@ def main():
             print(f"Extension {extension_name} removed successfully.")
         except Exception as e:
             print(f"Failed to remove extension: {e}")
-            exit(1)
+            return ExitCode.FAILED
 
-        exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.update:
         if cli_args.update == "ls":
@@ -3521,7 +3574,7 @@ def main():
             extensions = os.listdir(extensions_path)
             if len(extensions) == 0:
                 print("No extensions installed.")
-                exit(0)
+                return ExitCode.SUCCESS
             print("Installed extensions:")
             for extension in extensions:
                 print(f"  {extension}")
@@ -3529,7 +3582,7 @@ def main():
             print("\nUsage:")
             print("  llms --update <extension>")
             print("  llms --update all")
-            exit(0)
+            return ExitCode.SUCCESS
 
         async def update_extensions(extension_name):
             extensions_path = get_extensions_path()
@@ -3546,7 +3599,7 @@ def main():
                     _log(result.stdout.decode("utf-8"))
 
         asyncio.run(update_extensions(cli_args.update))
-        exit(0)
+        return ExitCode.SUCCESS
 
     g_app.extensions = install_extensions()
 
@@ -3604,7 +3657,7 @@ def main():
         print(f"\n{model_count} models available from {provider_count} providers")
 
         print_status()
-        g_app.exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.check is not None:
         # Check validity of models for a provider
@@ -3613,7 +3666,7 @@ def main():
         provider_name = cli_args.check
         model_names = extra_args if len(extra_args) > 0 else None
         loop.run_until_complete(check_models(provider_name, model_names))
-        g_app.exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.serve is not None:
         # Disable inactive providers and save to config before starting server
@@ -3658,7 +3711,7 @@ def main():
                 print("ERROR: Authentication is enabled but GitHub OAuth is not properly configured.")
                 print("Please set GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET environment variables,")
                 print("or disable authentication by setting 'auth.enabled' to false in llms.json")
-                exit(1)
+                return ExitCode.FAILED
 
             _log("Authentication enabled - GitHub OAuth configured")
 
@@ -4252,7 +4305,7 @@ def main():
 
         print(f"Starting server on port {port}...")
         web.run_app(app, host="0.0.0.0", port=port, print=_log)
-        g_app.exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.enable is not None:
         if cli_args.enable.endswith(","):
@@ -4271,7 +4324,7 @@ def main():
             if provider not in g_config["providers"]:
                 print(f"Provider '{provider}' not found")
                 print(f"Available providers: {', '.join(g_config['providers'].keys())}")
-                exit(1)
+                return ExitCode.FAILED
             if provider in g_config["providers"]:
                 provider_config, msg = enable_provider(provider)
                 print(f"\nEnabled provider {provider}:")
@@ -4282,7 +4335,7 @@ def main():
         print_status()
         if len(msgs) > 0:
             print("\n" + "\n".join(msgs))
-        g_app.exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.disable is not None:
         if cli_args.disable.endswith(","):
@@ -4300,24 +4353,24 @@ def main():
             if provider not in g_config["providers"]:
                 print(f"Provider {provider} not found")
                 print(f"Available providers: {', '.join(g_config['providers'].keys())}")
-                exit(1)
+                return ExitCode.FAILED
             disable_provider(provider)
             print(f"\nDisabled provider {provider}")
 
         print_status()
-        g_app.exit(0)
+        return ExitCode.SUCCESS
 
     if cli_args.default is not None:
         default_model = cli_args.default
         provider_model = get_provider_model(default_model)
         if provider_model is None:
             print(f"Model {default_model} not found")
-            exit(1)
+            return ExitCode.FAILED
         default_text = g_config["defaults"]["text"]
         default_text["model"] = default_model
         save_config(g_config)
         print(f"\nDefault model set to: {default_model}")
-        g_app.exit(0)
+        return ExitCode.SUCCESS
 
     if (
         cli_args.chat is not None
@@ -4339,13 +4392,13 @@ def main():
                 template = f"out:{cli_args.out}"
                 if template not in g_config["defaults"]:
                     print(f"Template for output modality '{cli_args.out}' not found")
-                    exit(1)
+                    return ExitCode.FAILED
                 chat = g_config["defaults"][template]
             if cli_args.chat is not None:
                 chat_path = os.path.join(os.path.dirname(__file__), cli_args.chat)
                 if not os.path.exists(chat_path):
                     print(f"Chat request template not found: {chat_path}")
-                    exit(1)
+                    return ExitCode.FAILED
                 _log(f"Using chat: {chat_path}")
 
                 with open(chat_path) as f:
@@ -4386,19 +4439,48 @@ def main():
                     raw=cli_args.raw,
                 )
             )
-            g_app.exit(0)
+            return ExitCode.SUCCESS
         except Exception as e:
             print(f"{cli_args.logprefix}Error: {e}")
             if cli_args.verbose:
                 traceback.print_exc()
-            g_app.exit(1)
+            return ExitCode.FAILED
 
     handled = run_extension_cli()
+    return ExitCode.SUCCESS if handled else ExitCode.UNHANDLED
+
+
+def get_app():
+    return g_app
 
-    if not handled:
+
+def cli(command_line: str):
+    parser = create_arg_parser()
+
+    # Load parser extensions, go through all extensions and load their parser arguments
+    if load_extensions:
+        init_extensions(parser)
+
+    args = shlex.split(command_line)
+    cli_args, extra_args = parser.parse_known_args(args)
+    return cli_exec(cli_args, extra_args)
+
+
+def main():
+    parser = create_arg_parser()
+
+    # Load parser extensions, go through all extensions and load their parser arguments
+    init_extensions(parser)
+
+    cli_args, extra_args = parser.parse_known_args()
+    exit_code = cli_exec(cli_args, extra_args)
+
+    if exit_code == ExitCode.UNHANDLED:
         # show usage from ArgumentParser
         parser.print_help()
-        g_app.exit(0)
+        g_app.exit(0) if g_app else exit(0)
+
+    g_app.exit(exit_code) if g_app else exit(exit_code)
 
 
 if __name__ == "__main__":

llms/ui/ai.mjs

@@ -6,7 +6,7 @@ const headers = { 'Accept': 'application/json' }
 const prefsKey = 'llms.prefs'
 
 export const o = {
-    version: '3.0.9',
+    version: '3.0.11',
     base,
     prefsKey,
     welcome: 'Welcome to llms.py',

llms/ui/modules/chat/ChatBody.mjs

@@ -12,6 +12,47 @@ function hasJsonStructure(str) {
     return tryParseJson(str) != null
 }
 
+function isEmpty(v) {
+    return !v || v === '{}' || v === '[]' || v === 'null' || v === 'undefined' || v === '""' || v === "''" || v === "``"
+}
+function embedHtml(html) {
+    const resizeScript = `<script>
+        let lastH = 0;
+        const sendHeight = () => {
+            const body = document.body;
+            if (!body) return;
+            // Force re-calc
+            const h = document.documentElement.getBoundingClientRect().height;
+            if (Math.abs(h - lastH) > 2) {
+                lastH = h;
+                window.parent.postMessage({ type: 'iframe-resize', height: h }, '*');
+            }
+        }
+        const ro = new ResizeObserver(sendHeight);
+        window.addEventListener('load', () => {
+            // Inject styles to prevent infinite loops
+            const style = document.createElement('style');
+            style.textContent = 'html, body { height: auto !important; min-height: 0 !important; margin: 0 !important; padding: 0 !important; overflow: hidden !important; }';
+            document.head.appendChild(style);
+            
+            const body = document.body;
+            if (body) {
+                ro.observe(body);
+                ro.observe(document.documentElement);
+                sendHeight();
+            }
+        });
+    <\/script>`
+
+    const escaped = (html + resizeScript)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;')
+    return `<iframe srcdoc="${escaped}" sandbox="allow-scripts" style="width:100%;height:auto;border:none;"></iframe>`
+}
+
 export const TypeText = {
     template: `
         <div v-if="text.type === 'text'">
@@ -332,46 +373,6 @@ export const ToolArguments = {
     },
     setup(props) {
         const refArgs = ref()
-        function isEmpty(v) {
-            return !v || v === '{}' || v === '[]' || v === 'null' || v === 'undefined' || v === '""' || v === "''" || v === "``"
-        }
-        function embedHtml(html) {
-            const resizeScript = `<script>
-                let lastH = 0;
-                const sendHeight = () => {
-                    const body = document.body;
-                    if (!body) return;
-                    // Force re-calc
-                    const h = document.documentElement.getBoundingClientRect().height;
-                    if (Math.abs(h - lastH) > 2) {
-                        lastH = h;
-                        window.parent.postMessage({ type: 'iframe-resize', height: h }, '*');
-                    }
-                }
-                const ro = new ResizeObserver(sendHeight);
-                window.addEventListener('load', () => {
-                    // Inject styles to prevent infinite loops
-                    const style = document.createElement('style');
-                    style.textContent = 'html, body { height: auto !important; min-height: 0 !important; margin: 0 !important; padding: 0 !important; overflow: hidden !important; }';
-                    document.head.appendChild(style);
-                    
-                    const body = document.body;
-                    if (body) {
-                        ro.observe(body);
-                        ro.observe(document.documentElement);
-                        sendHeight();
-                    }
-                });
-            <\/script>`
-
-            const escaped = (html + resizeScript)
-                .replace(/&/g, '&amp;')
-                .replace(/</g, '&lt;')
-                .replace(/>/g, '&gt;')
-                .replace(/"/g, '&quot;')
-                .replace(/'/g, '&#39;')
-            return `<iframe srcdoc="${escaped}" sandbox="allow-scripts" style="width:100%;height:auto;border:none;"></iframe>`
-        }
         const dict = computed(() => {
             if (isEmpty(props.value)) return null
             const ret = tryParseJson(props.value)
@@ -417,9 +418,47 @@ export const ToolArguments = {
 }
 
 export const ToolOutput = {
-    template: ``,
+    template: `
+        <div v-if="output" class="border-t border-gray-200 dark:border-gray-700">
+            <div class="px-3 py-1.5 flex justify-between items-center border-b border-gray-200 dark:border-gray-800 bg-gray-50/30 dark:bg-gray-800">
+                <div class="flex items-center gap-2 ">
+                    <svg class="size-3.5 text-gray-400" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 12h14M12 5l7 7-7 7"/></svg>
+                    <span class="text-[10px] uppercase tracking-wider text-gray-400 font-medium">Output</span>
+                </div>    
+                <div v-if="hasJsonStructure(output.content)" class="flex items-center gap-2 text-[10px] uppercase tracking-wider font-medium select-none">
+                    <span @click="$ctx.setPrefs({ toolFormat: 'text' })" 
+                        class="cursor-pointer transition-colors"
+                        :class="$ctx.prefs.toolFormat !== 'preview' ? 'text-gray-600 dark:text-gray-300' : 'text-gray-400 hover:text-gray-600 dark:hover:text-gray-300'">
+                        text
+                    </span>
+                    <span class="text-gray-300 dark:text-gray-700">|</span>
+                    <span @click="$ctx.setPrefs({ toolFormat: 'preview' })" 
+                        class="cursor-pointer transition-colors"
+                        :class="$ctx.prefs.toolFormat == 'preview' ? 'text-gray-600 dark:text-gray-300' : 'text-gray-400 hover:text-gray-600 dark:hover:text-gray-300'">
+                        preview
+                    </span>
+                </div>
+            </div>
+            <div class="not-prose px-3 py-2">
+                <pre v-if="$ctx.prefs.toolFormat !== 'preview' || !hasJsonStructure(output.content)" class="tool-output">{{ output.content }}</pre>
+                <div v-else class="text-xs">
+                    <HtmlFormat v-if="tryParseJson(output.content)" :value="tryParseJson(output.content)" :classes="$utils.htmlFormatClasses" />
+                    <div v-else class="text-gray-500 italic p-2">Invalid JSON content</div>
+                </div>
+            </div>
+            <ViewToolTypes :output="output" class="p-2" />
+        </div>
+    `,
+    props: {
+        tool: Object,
+        output: Object,
+    },
     setup(props) {
 
+        return {
+            tryParseJson,
+            hasJsonStructure,
+        }
     }
 }
 
@@ -523,36 +562,8 @@ export const ChatBody = {
                                             
                                             <ToolArguments :value="tool.function.arguments" />
 
-                                            <!-- Tool Output (Nested) -->
-                                            <div v-if="getToolOutput(tool.id)" class="border-t border-gray-200 dark:border-gray-700">
-                                                <div class="px-3 py-1.5 flex justify-between items-center border-b border-gray-200 dark:border-gray-800 bg-gray-50/30 dark:bg-gray-800">
-                                                    <div class="flex items-center gap-2 ">
-                                                        <svg class="size-3.5 text-gray-400" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 12h14M12 5l7 7-7 7"/></svg>
-                                                        <span class="text-[10px] uppercase tracking-wider text-gray-400 font-medium">Output</span>
-                                                    </div>    
-                                                    <div v-if="hasJsonStructure(getToolOutput(tool.id).content)" class="flex items-center gap-2 text-[10px] uppercase tracking-wider font-medium select-none">
-                                                        <span @click="setPrefs({ toolFormat: 'text' })" 
-                                                            class="cursor-pointer transition-colors"
-                                                            :class="prefs.toolFormat !== 'preview' ? 'text-gray-600 dark:text-gray-300' : 'text-gray-400 hover:text-gray-600 dark:hover:text-gray-300'">
-                                                            text
-                                                        </span>
-                                                        <span class="text-gray-300 dark:text-gray-700">|</span>
-                                                        <span @click="setPrefs({ toolFormat: 'preview' })" 
-                                                            class="cursor-pointer transition-colors"
-                                                            :class="prefs.toolFormat == 'preview' ? 'text-gray-600 dark:text-gray-300' : 'text-gray-400 hover:text-gray-600 dark:hover:text-gray-300'">
-                                                            preview
-                                                        </span>
-                                                    </div>
-                                                </div>
-                                                <div class="not-prose px-3 py-2">
-                                                    <pre v-if="prefs.toolFormat !== 'preview' || !hasJsonStructure(getToolOutput(tool.id).content)" class="tool-output">{{ getToolOutput(tool.id).content }}</pre>
-                                                    <div v-else class="text-xs">
-                                                        <HtmlFormat v-if="tryParseJson(getToolOutput(tool.id).content)" :value="tryParseJson(getToolOutput(tool.id).content)" :classes="$utils.htmlFormatClasses" />
-                                                        <div v-else class="text-gray-500 italic p-2">Invalid JSON content</div>
-                                                    </div>
-                                                </div>
-                                                <ViewToolTypes :output="getToolOutput(tool.id)" />
-                                            </div>
+                                            <ToolOutput :tool="tool" :output="getToolOutput(tool.id)" />
+
                                         </div>
                                     </div>
 

{llms_py-3.0.9.dist-info → llms_py-3.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llms-py
-Version: 3.0.9
+Version: 3.0.11
 Summary: A lightweight CLI tool and OpenAI-compatible server for querying multiple Large Language Model (LLM) providers
 Home-page: https://github.com/ServiceStack/llms
 Author: ServiceStack

{llms_py-3.0.9.dist-info → llms_py-3.0.11.dist-info}/RECORD

@@ -3,13 +3,13 @@ llms/__main__.py,sha256=hrBulHIt3lmPm1BCyAEVtB6DQ0Hvc3gnIddhHCmJasg,151
 llms/db.py,sha256=oozp5I5lECVO8oZEFwcZl3ES5mARqWeR1BkoqG5kSqM,11687
 llms/index.html,sha256=nGk1Djtn9p7l6LuKp4Kg0JIB9fCzxtTWXFfmDb4ggpc,1658
 llms/llms.json,sha256=NEr9kJRkUGZ2YZHbWC-haGPlVVL2Qtnx4kKZENGH1wk,11494
-llms/main.py,sha256=7nEm4UZph9cyswu_28_Vb14CSo3yg6BFhuQxdmIrFXk,169747
+llms/main.py,sha256=IoKt4rGaAKAcc-Y2M-cTbxyIqOy9tmeiWxnrHjzHHv0,173872
 llms/providers-extra.json,sha256=_6DmGBiQY9LM6_Y0zOiObYn7ba4g3akSNQfmHcYlENc,11101
 llms/providers.json,sha256=yjhDurlwo70xqfV0HNLiZaCpw3WvtIgkjoLahQIKX2w,282530
 llms/extensions/analytics/ui/index.mjs,sha256=m1XwaqYCLwK267JAUCAltkN_nOXep0GxfpvGNS5i4_w,69547
 llms/extensions/app/README.md,sha256=TKoblZpHlheLCh_dfXOxqTc5OvxlgMBa-vKo8Hqb2gg,1370
 llms/extensions/app/__init__.py,sha256=aU8Bfliw--Xj1bsKL3PSoX6MY1ZNgweNyMWS1V_YG4s,20855
-llms/extensions/app/db.py,sha256=CqpHReXXjrLXXNxINo-wsnBJenKZVVHKlWlhtXFWj08,21503
+llms/extensions/app/db.py,sha256=DU8YZ25yFsBI-O6msxh2GgzbwaqKqXkAHJLwQKcmFPI,21533
 llms/extensions/app/ui/Recents.mjs,sha256=2ypAKUp9_Oqcive1nUWZ8I2PQTBomBg_Pkjygi4oPgs,9261
 llms/extensions/app/ui/index.mjs,sha256=sB9176LLNuKFsZ28yL-tROA6J4xePNtvxtSrzFcinRo,13271
 llms/extensions/app/ui/threadStore.mjs,sha256=CLlD-1HBO1yhZBHLfL0ZdA4quT4R07qr1JW4a8igVNc,12287
@@ -128,7 +128,7 @@ llms/extensions/katex/ui/fonts/KaTeX_Typewriter-Regular.ttf,sha256=8B8-h9nGphwMC
 llms/extensions/katex/ui/fonts/KaTeX_Typewriter-Regular.woff,sha256=4U_tArGrp86fWv1YRLXQMhsiNR_rxyDg3ouHI1J2Cfc,16028
 llms/extensions/katex/ui/fonts/KaTeX_Typewriter-Regular.woff2,sha256=cdUX1ngneHz6vfGGkUzDNY7aU543kxlB8rL9SiH2jAs,13568
 llms/extensions/providers/__init__.py,sha256=C5zOBQEOB2L96rAZdjV42fPVk_dZxSh2Dv30Kb1w3lE,534
-llms/extensions/providers/anthropic.py,sha256=LAOdpa_cP1zBUvSQ-ct3kVjRga-nPJ1U_KBb99N4IEk,10429
+llms/extensions/providers/anthropic.py,sha256=V9mechnhyoX-5Z5AkwyQ-UzLax6cqG7j7GLvGTZF9no,10941
 llms/extensions/providers/cerebras.py,sha256=HaeFW0GwbD6V6Zrrwqyv78kQb0VXg9oHmykvJfIOOYE,1417
 llms/extensions/providers/chutes.py,sha256=5ZrfbqoOhgzKLQy_qULcp4jlvW5WXPR0jP9kN2Jzb9g,6229
 llms/extensions/providers/google.py,sha256=9P90bEefRA18tpjfEuAz1T5YpwzdOngrTFhw-LI3eXg,24434
@@ -143,7 +143,7 @@ llms/extensions/system_prompts/ui/prompts.json,sha256=t5DD3bird-87wFa4OlW-bC2wdo
 llms/extensions/tools/__init__.py,sha256=u76604Cn_sRFQRqeA_pkVEty27V688Mt9Z7Kh63yDr8,4825
 llms/extensions/tools/ui/index.mjs,sha256=IbGB2FQJ5VL4a8arwoR9C79vUCNrz8VIyQnHZ4vxU9o,34486
 llms/ui/App.mjs,sha256=CoUzO9mV__-jV19NKHYIbwHsjWMnO11jyNSbnJhe1gQ,7486
-llms/ui/ai.mjs,sha256=WRt2u5w8TdY2u9_rQqp7Ms7MOrWfKSLT4Z5rDS6VAZ8,6540
+llms/ui/ai.mjs,sha256=GVyxu3Thsuck0b1Akvqk2c5w-maSzONU06QN-TUWoJk,6541
 llms/ui/app.css,sha256=vfXErYVdVlE3pL8oZ-2G_OC-_reJzmaL0p91EVv48uo,186490
 llms/ui/ctx.mjs,sha256=X4scgXEQ9bMUfQl36sM4A3o2Ufad3LRwItxfmSu1xwc,12838
 llms/ui/fav.svg,sha256=_R6MFeXl6wBFT0lqcUxYQIDWgm246YH_3hSTW0oO8qw,734
@@ -166,12 +166,12 @@ llms/ui/lib/vue.mjs,sha256=75FuLhUTPk19sncwNIrm0BGEL0_Qw298-_v01fPWYoI,542872
 llms/ui/modules/icons.mjs,sha256=LGcH0ys0QLS2ZKCO42qHpwPYbBV_EssoWLezU4XZEzU,27751
 llms/ui/modules/layout.mjs,sha256=8pAxs8bedQI3b3eRA9nrfpLZznLmrpp4BZvigYAQjpQ,12572
 llms/ui/modules/model-selector.mjs,sha256=6U4rAZ7vmQELFRQGWk4YEtq02v3lyHdMq6yUOp-ArXg,43184
-llms/ui/modules/chat/ChatBody.mjs,sha256=8k81r1HTxrkmLsG7xvDmYMInThiZ37xVQBfld1tLWW0,50366
+llms/ui/modules/chat/ChatBody.mjs,sha256=5yWjo6tWmcKidDpRvKFeHqx3lXO3DB-3rTyXY72gB4U,49122
 llms/ui/modules/chat/SettingsDialog.mjs,sha256=HMBJTwrapKrRIAstIIqp0QlJL5O-ho4hzgvfagPfsX8,19930
 llms/ui/modules/chat/index.mjs,sha256=lfSbERMaM3bLsKhdJJPWwL4-FGr8U_ftlvqW5vC3T1s,39762
-llms_py-3.0.9.dist-info/licenses/LICENSE,sha256=bus9cuAOWeYqBk2OuhSABVV1P4z7hgrEFISpyda_H5w,1532
-llms_py-3.0.9.dist-info/METADATA,sha256=6PE0ikoQqoxK1TDYoo0iELmrYStuzIUewiHlmb3kZFY,2191
-llms_py-3.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-llms_py-3.0.9.dist-info/entry_points.txt,sha256=WswyE7PfnkZMIxboC-MS6flBD6wm-CYU7JSUnMhqMfM,40
-llms_py-3.0.9.dist-info/top_level.txt,sha256=gC7hk9BKSeog8gyg-EM_g2gxm1mKHwFRfK-10BxOsa4,5
-llms_py-3.0.9.dist-info/RECORD,,
+llms_py-3.0.11.dist-info/licenses/LICENSE,sha256=bus9cuAOWeYqBk2OuhSABVV1P4z7hgrEFISpyda_H5w,1532
+llms_py-3.0.11.dist-info/METADATA,sha256=90LpikNrckf1EaRrQHKGLOGobshThyJsRcX75csIs1Y,2192
+llms_py-3.0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llms_py-3.0.11.dist-info/entry_points.txt,sha256=WswyE7PfnkZMIxboC-MS6flBD6wm-CYU7JSUnMhqMfM,40
+llms_py-3.0.11.dist-info/top_level.txt,sha256=gC7hk9BKSeog8gyg-EM_g2gxm1mKHwFRfK-10BxOsa4,5
+llms_py-3.0.11.dist-info/RECORD,,