llms-py 3.0.10__py3-none-any.whl → 3.0.12__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/extensions/providers/google.py

@@ -63,6 +63,50 @@ def install_google(ctx):
                 to[k] = v
         return to
 
+    def sanitize_parameters(params):
+        """Sanitize tool parameters for Google provider."""
+
+        if not isinstance(params, dict):
+            return params
+
+        # Create a copy to avoid modifying original tool definition
+        p = params.copy()
+
+        # Remove forbidden fields
+        for forbidden in ["$schema", "additionalProperties"]:
+            if forbidden in p:
+                del p[forbidden]
+
+        # Recursively sanitize known nesting fields
+        # 1. Properties (dict of schemas)
+        if "properties" in p:
+            for k, v in p["properties"].items():
+                p["properties"][k] = sanitize_parameters(v)
+
+        # 2. Items (schema or list of schemas)
+        if "items" in p:
+            if isinstance(p["items"], list):
+                p["items"] = [sanitize_parameters(i) for i in p["items"]]
+            else:
+                p["items"] = sanitize_parameters(p["items"])
+
+        # 3. Combinators (list of schemas)
+        for combinator in ["allOf", "anyOf", "oneOf"]:
+            if combinator in p:
+                p[combinator] = [sanitize_parameters(i) for i in p[combinator]]
+
+        # 4. Not (schema)
+        if "not" in p:
+            p["not"] = sanitize_parameters(p["not"])
+
+        # 5. Definitions (dict of schemas)
+        for def_key in ["definitions", "$defs"]:
+            if def_key in p:
+                for k, v in p[def_key].items():
+                    p[def_key][k] = sanitize_parameters(v)
+
+        return p
+
     class GoogleProvider(OpenAiCompatible):
         sdk = "@ai-sdk/google"
 
@@ -112,11 +156,12 @@ def install_google(ctx):
                 for tool in chat["tools"]:
                     if tool["type"] == "function":
                         f = tool["function"]
+
                         function_declarations.append(
                             {
                                 "name": f["name"],
                                 "description": f.get("description"),
-                                "parameters": f.get("parameters"),
+                                "parameters": sanitize_parameters(f.get("parameters")),
                             }
                         )
                     elif tool["type"] == "file_search":
@@ -183,13 +228,19 @@ def install_google(ctx):
                             if name:
                                 # content is the string response
                                 # Some implementations pass the content directly.
-                                # Google docs say: response: { "name": "...", "content": { ... } }
-                                # Actually "response" field in functionResponse is a Struct/Map.
+                                # Google docs say: response: { "key": "value" }
+                                try:
+                                    response_data = json.loads(message["content"])
+                                    if not isinstance(response_data, dict):
+                                        response_data = {"content": message["content"]}
+                                except Exception:
+                                    response_data = {"content": message["content"]}
+
                                 parts.append(
                                     {
                                         "functionResponse": {
                                             "name": name,
-                                            "response": {"name": name, "content": message["content"]},
+                                            "response": response_data,
                                         }
                                     }
                                 )

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.10"
+VERSION = "3.0.12"
 _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)
@@ -1620,10 +1628,15 @@ async def g_chat_completion(chat, context=None):
             tool_history = []
             final_response = None
 
-            for _ in range(max_iterations):
+            for request_count in range(max_iterations):
                 if should_cancel_thread(context):
                     return
 
+                if DEBUG:
+                    messages = current_chat.get("messages", [])
+                    last_message = messages[-1] if messages else None
+                    _dbg(f"Provider {provider_name}, request {request_count}:\n{json.dumps(last_message, indent=2)}")
+
                 response = await provider.chat(current_chat, context=context)
 
                 if should_cancel_thread(context):
@@ -1853,12 +1866,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 +2558,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 +2634,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 +2658,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 +2667,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 +2709,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 +2758,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 +2776,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 +2888,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 +2984,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 +2996,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 +3018,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 +3129,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 +3298,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 +3367,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 +3409,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 +3443,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 +3476,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 +3539,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 +3548,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 +3560,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 +3568,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 +3579,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 +3587,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 +3604,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 +3662,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 +3671,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 +3716,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 +4310,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 +4329,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 +4340,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 +4358,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 +4397,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 +4444,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
+
+
+def cli(command_line: str):
+    parser = create_arg_parser()
 
-    if not handled:
+    # 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.10',
+    version: '3.0.12',
     base,
     prefsKey,
     welcome: 'Welcome to llms.py',

{llms_py-3.0.10.dist-info → llms_py-3.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llms-py
-Version: 3.0.10
+Version: 3.0.12
 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
@@ -44,6 +44,6 @@ Lightweight CLI, API and ChatGPT-like alternative to Open WebUI for accessing mu
 
 [llmspy.org](https://llmspy.org)
 
-[![](https://github.com/ServiceStack/llmspy.org/blob/main/public/img/llmspy-home.webp?raw=true)](https://llmspy.org)
+[![](https://github.com/ServiceStack/llmspy.org/blob/main/public/img/llmspy-home-v3.webp?raw=true)](https://llmspy.org)
 
 GitHub: [llmspy.org](https://github.com/ServiceStack/llmspy.org)

{llms_py-3.0.10.dist-info → llms_py-3.0.12.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=ZSRfpbTGMJjU_H65Iz4I6aDBmEQjFnfUwSGRr4SJfQg,169748
+llms/main.py,sha256=HgQ_nS0OSqu8BRq_k4a1vpPhGzNiIgvIg-fxs7O6G44,174163
 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,10 +128,10 @@ 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
+llms/extensions/providers/google.py,sha256=oCCTE2KAw-WWE2v14XpKzgAMdFIWbjTBoa6GWuqT4dw,26215
 llms/extensions/providers/nvidia.py,sha256=C6cwqn3EufYDfRIgbc8MDkQNyD6w3c7hbjfYaHJSDik,4279
 llms/extensions/providers/openai.py,sha256=hkE-LVsw6M92_qEbpayuPo17Z1OWKHe7lm2wduLMng8,6138
 llms/extensions/providers/openrouter.py,sha256=5SfCJKo1aGKoDGez6HXYQe9elMMo9sSEDFqqdxamAgA,3330
@@ -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=F4MaotQJDO60uHJBC6tA4dlQE1aPOR28tvLU670sLIs,6541
+llms/ui/ai.mjs,sha256=S-LmypGGmTrAteH9By37md6gRJw2ILbjXf36Glho5EY,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
@@ -169,9 +169,9 @@ llms/ui/modules/model-selector.mjs,sha256=6U4rAZ7vmQELFRQGWk4YEtq02v3lyHdMq6yUOp
 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.10.dist-info/licenses/LICENSE,sha256=bus9cuAOWeYqBk2OuhSABVV1P4z7hgrEFISpyda_H5w,1532
-llms_py-3.0.10.dist-info/METADATA,sha256=IWZDosCH-2jQpFVfSZ4YEUHqOkph9QdILhpQspYVfCc,2192
-llms_py-3.0.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-llms_py-3.0.10.dist-info/entry_points.txt,sha256=WswyE7PfnkZMIxboC-MS6flBD6wm-CYU7JSUnMhqMfM,40
-llms_py-3.0.10.dist-info/top_level.txt,sha256=gC7hk9BKSeog8gyg-EM_g2gxm1mKHwFRfK-10BxOsa4,5
-llms_py-3.0.10.dist-info/RECORD,,
+llms_py-3.0.12.dist-info/licenses/LICENSE,sha256=bus9cuAOWeYqBk2OuhSABVV1P4z7hgrEFISpyda_H5w,1532
+llms_py-3.0.12.dist-info/METADATA,sha256=KVDU66mm6L_mF4uwzhWhSbPHqqydeOKSuuKHf0IRJ_w,2195
+llms_py-3.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llms_py-3.0.12.dist-info/entry_points.txt,sha256=WswyE7PfnkZMIxboC-MS6flBD6wm-CYU7JSUnMhqMfM,40
+llms_py-3.0.12.dist-info/top_level.txt,sha256=gC7hk9BKSeog8gyg-EM_g2gxm1mKHwFRfK-10BxOsa4,5
+llms_py-3.0.12.dist-info/RECORD,,