llms-py 3.0.0b6__py3-none-any.whl → 3.0.0b7__py3-none-any.whl

llms/main.py

@@ -40,12 +40,12 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.0b6"
+VERSION = "3.0.0b7"
 _ROOT = None
-DEBUG = True  # os.getenv("PYPI_SERVICESTACK") is not None
-MOCK = False
-MOCK_DIR = os.getenv("MOCK_DIR")
+DEBUG = os.getenv("DEBUG") == "1"
 MOCK = os.getenv("MOCK") == "1"
+MOCK_DIR = os.getenv("MOCK_DIR")
+DISABLE_EXTENSIONS = (os.getenv("LLMS_DISABLE") or "").split(",")
 g_config_path = None
 g_config = None
 g_providers = None
@@ -493,7 +493,7 @@ class HTTPError(Exception):
         super().__init__(f"HTTP {status} {reason}")
 
 
-def save_image_to_cache(base64_data, filename, image_info):
+def save_bytes_to_cache(base64_data, filename, file_info):
     ext = filename.split(".")[-1]
     mimetype = get_file_mime_type(filename)
     content = base64.b64decode(base64_data) if isinstance(base64_data, str) else base64_data
@@ -505,8 +505,39 @@ def save_image_to_cache(base64_data, filename, image_info):
     subdir = sha256_hash[:2]
     relative_path = f"{subdir}/{save_filename}"
     full_path = get_cache_path(relative_path)
+    url = f"/~cache/{relative_path}"
 
-    url = f"~cache/{relative_path}"
+    os.makedirs(os.path.dirname(full_path), exist_ok=True)
+
+    with open(full_path, "wb") as f:
+        f.write(content)
+    info = {
+        "date": int(time.time()),
+        "url": url,
+        "size": len(content),
+        "type": mimetype,
+        "name": filename,
+    }
+    info.update(file_info)
+
+    g_app.on_cache_saved_filters({"url": url, "info": info})
+
+    return url, info
+
+
+def save_image_to_cache(base64_data, filename, image_info):
+    ext = filename.split(".")[-1]
+    mimetype = get_file_mime_type(filename)
+    content = base64.b64decode(base64_data) if isinstance(base64_data, str) else base64_data
+    sha256_hash = hashlib.sha256(content).hexdigest()
+
+    save_filename = f"{sha256_hash}.{ext}" if ext else sha256_hash
+
+    # Use first 2 chars for subdir to avoid too many files in one dir
+    subdir = sha256_hash[:2]
+    relative_path = f"{subdir}/{save_filename}"
+    full_path = get_cache_path(relative_path)
+    url = f"/~cache/{relative_path}"
 
     # if file and its .info.json already exists, return it
     info_path = os.path.splitext(full_path)[0] + ".info.json"
@@ -545,6 +576,8 @@ def save_image_to_cache(base64_data, filename, image_info):
     with open(info_path, "w") as f:
         json.dump(info, f)
 
+    g_app.on_cache_saved_filters({"url": url, "info": info})
+
     return url, info
 
 
@@ -577,6 +610,12 @@ def chat_to_prompt(chat):
     return prompt
 
 
+def chat_to_username(chat):
+    if "metadata" in chat and "user" in chat["metadata"]:
+        return chat["metadata"]["user"]
+    return None
+
+
 def last_user_prompt(chat):
     prompt = ""
     if "messages" in chat:
@@ -593,6 +632,21 @@ def last_user_prompt(chat):
     return prompt
 
 
+def to_file_info(chat, info=None, response=None):
+    prompt = last_user_prompt(chat)
+    ret = info or {}
+    if chat["model"] and "model" not in ret:
+        ret["model"] = chat["model"]
+    if prompt and "prompt" not in ret:
+        ret["prompt"] = prompt
+    if "image_config" in chat:
+        ret.update(chat["image_config"])
+    user = chat_to_username(chat)
+    if user:
+        ret["user"] = user
+    return ret
+
+
 # Image Generator Providers
 class GeneratorBase:
     def __init__(self, **kwargs):
@@ -875,13 +929,14 @@ class OpenAiCompatible:
         _log(f"POST {self.chat_url}")
         _log(chat_summary(chat))
         # remove metadata if any (conflicts with some providers, e.g. Z.ai)
-        chat.pop("metadata", None)
+        metadata = chat.pop("metadata", None)
 
         async with aiohttp.ClientSession() as session:
             started_at = time.time()
             async with session.post(
                 self.chat_url, headers=self.headers, data=json.dumps(chat), timeout=aiohttp.ClientTimeout(total=120)
             ) as response:
+                chat["metadata"] = metadata
                 return self.to_response(await response_json(response), chat, started_at)
 
 
@@ -1053,7 +1108,48 @@ def api_providers():
     return ret
 
 
-async def chat_completion(chat):
+def to_error_response(e, stacktrace=False):
+    status = {"errorCode": "Error", "message": str(e)}
+    if stacktrace:
+        status["stackTrace"] = traceback.format_exc()
+    return {"responseStatus": status}
+
+
+def create_error_response(message, error_code="Error", stack_trace=None):
+    ret = {"responseStatus": {"errorCode": error_code, "message": message}}
+    if stack_trace:
+        ret["responseStatus"]["stackTrace"] = stack_trace
+    return ret
+
+
+def g_chat_request(template=None, text=None, model=None, system_prompt=None):
+    chat_template = g_config["defaults"].get(template or "text")
+    if not chat_template:
+        raise Exception(f"Chat template '{template}' not found")
+
+    chat = chat_template.copy()
+    if model:
+        chat["model"] = model
+    if system_prompt is not None:
+        chat["messages"].insert(0, {"role": "system", "content": system_prompt})
+    if text is not None:
+        if not chat["messages"] or len(chat["messages"]) == 0:
+            chat["messages"] = [{"role": "user", "content": [{"type": "text", "text": ""}]}]
+
+        # replace content of last message if exists, else add
+        last_msg = chat["messages"][-1] if "messages" in chat else None
+        if last_msg and last_msg["role"] == "user":
+            if isinstance(last_msg["content"], list):
+                last_msg["content"][-1]["text"] = text
+            else:
+                last_msg["content"] = text
+        else:
+            chat["messages"].append({"role": "user", "content": text})
+
+    return chat
+
+
+async def g_chat_completion(chat, context=None):
     model = chat["model"]
     # get first provider that has the model
     candidate_providers = [name for name, provider in g_handlers.items() if provider.provider_model(model)]
@@ -1218,16 +1314,8 @@ async def cli_chat(chat, image=None, audio=None, file=None, args=None, raw=False
         printdump(chat)
 
     try:
-        # Apply pre-chat filters
-        context = {"chat": chat}
-        for filter_func in g_app.chat_request_filters:
-            chat = await filter_func(chat, context)
+        response = await g_app.chat_completion(chat)
 
-        response = await chat_completion(chat)
-
-        # Apply post-chat filters
-        for filter_func in g_app.chat_response_filters:
-            response = await filter_func(response, context)
         if raw:
             print(json.dumps(response, indent=2))
             exit(0)
@@ -1244,13 +1332,17 @@ async def cli_chat(chat, image=None, audio=None, file=None, args=None, raw=False
                         for image in msg["images"]:
                             image_url = image["image_url"]["url"]
                             generated_files.append(image_url)
+                    if "audios" in msg:
+                        for audio in msg["audios"]:
+                            audio_url = audio["audio_url"]["url"]
+                            generated_files.append(audio_url)
 
             if len(generated_files) > 0:
                 print("\nSaved files:")
                 for file in generated_files:
-                    if file.startswith("~cache"):
-                        print(get_cache_path(file[7:]))
-                        _log(f"http://localhost:8000/{file}")
+                    if file.startswith("/~cache"):
+                        print(get_cache_path(file[8:]))
+                        print(f"http://localhost:8000/{file}")
                     else:
                         print(file)
 
@@ -1288,7 +1380,7 @@ def init_llms(config, providers):
     # iterate over config and replace $ENV with env value
     for key, value in g_config.items():
         if isinstance(value, str) and value.startswith("$"):
-            g_config[key] = os.environ.get(value[1:], "")
+            g_config[key] = os.getenv(value[1:], "")
 
     # if g_verbose:
     #     printdump(g_config)
@@ -1326,11 +1418,11 @@ def create_provider_kwargs(definition, provider=None):
     if "api_key" in provider:
         value = provider["api_key"]
         if isinstance(value, str) and value.startswith("$"):
-            provider["api_key"] = os.environ.get(value[1:], "")
+            provider["api_key"] = os.getenv(value[1:], "")
 
     if "api_key" not in provider and "env" in provider:
         for env_var in provider["env"]:
-            val = os.environ.get(env_var)
+            val = os.getenv(env_var)
             if val:
                 provider["api_key"] = val
                 break
@@ -1467,11 +1559,11 @@ def print_status():
 
 
 def home_llms_path(filename):
-    return f"{os.environ.get('HOME')}/.llms/{filename}"
+    return f"{os.getenv('HOME')}/.llms/{filename}"
 
 
-def get_cache_path(filename):
-    return home_llms_path(f"cache/{filename}")
+def get_cache_path(path=""):
+    return home_llms_path(f"cache/{path}") if path else home_llms_path("cache")
 
 
 def get_config_path():
@@ -1480,8 +1572,8 @@ def get_config_path():
         "./llms.json",
         home_config_path,
     ]
-    if os.environ.get("LLMS_CONFIG_PATH"):
-        check_paths.insert(0, os.environ.get("LLMS_CONFIG_PATH"))
+    if os.getenv("LLMS_CONFIG_PATH"):
+        check_paths.insert(0, os.getenv("LLMS_CONFIG_PATH"))
 
     for check_path in check_paths:
         g_config_path = os.path.normpath(os.path.join(os.path.dirname(__file__), check_path))
@@ -1956,7 +2048,10 @@ class AppExtensions:
         self.chat_response_filters = []
         self.server_add_get = []
         self.server_add_post = []
-        self.server_add_post = []
+        self.server_add_put = []
+        self.server_add_delete = []
+        self.server_add_patch = []
+        self.cache_saved_filters = []
         self.tools = {}
         self.tool_definitions = []
         self.all_providers = [
@@ -1981,6 +2076,62 @@ class AppExtensions:
             "21:9": "1536×672",
         }
 
+    def get_session(self, request):
+        session_token = get_session_token(request)
+
+        if not session_token or session_token not in g_sessions:
+            return None
+
+        session_data = g_sessions[session_token]
+        return session_data
+
+    def get_username(self, request):
+        session = self.get_session(request)
+        if session:
+            return session.get("userName")
+        return None
+
+    def get_user_path(self, username=None):
+        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):
+        return g_chat_request(template=template, text=text, model=model, system_prompt=system_prompt)
+
+    async def chat_completion(self, chat, context=None):
+        # Apply pre-chat filters
+        if context is None:
+            context = {"chat": chat}
+        elif "request" in context:
+            username = self.get_username(context["request"])
+            if username:
+                if "metadata" not in chat:
+                    chat["metadata"] = {}
+                chat["metadata"]["user"] = username
+
+        for filter_func in self.chat_request_filters:
+            chat = await filter_func(chat, context)
+
+        response = await g_chat_completion(chat, context)
+
+        # Apply post-chat filters
+        for filter_func in self.chat_response_filters:
+            response = await filter_func(response, context)
+
+        return response
+
+    def on_cache_saved_filters(self, context):
+        # _log(f"on_cache_saved_filters {len(self.cache_saved_filters)}: {context['url']}")
+        for filter_func in self.cache_saved_filters:
+            filter_func(context)
+
+
+def handler_name(handler):
+    if hasattr(handler, "__name__"):
+        return handler.__name__
+    return "unknown"
+
 
 class ExtensionContext:
     def __init__(self, app, path):
@@ -1994,6 +2145,7 @@ class ExtensionContext:
         self.MOCK_DIR = MOCK_DIR
         self.debug = DEBUG
         self.verbose = g_verbose
+        self.aspect_ratios = app.aspect_ratios
 
     def chat_to_prompt(self, chat):
         return chat_to_prompt(chat)
@@ -2001,9 +2153,15 @@ class ExtensionContext:
     def last_user_prompt(self, chat):
         return last_user_prompt(chat)
 
+    def to_file_info(self, chat, info=None, response=None):
+        return to_file_info(chat, info=info, response=response)
+
     def save_image_to_cache(self, base64_data, filename, image_info):
         return save_image_to_cache(base64_data, filename, image_info)
 
+    def save_bytes_to_cache(self, bytes_data, filename, file_info):
+        return save_bytes_to_cache(bytes_data, filename, file_info)
+
     def text_from_file(self, path):
         return text_from_file(path)
 
@@ -2027,7 +2185,7 @@ class ExtensionContext:
             print(traceback.format_exc(), flush=True)
 
     def add_provider(self, provider):
-        self.log(f"Registered provider: {provider}")
+        self.log(f"Registered provider: {provider.__name__}")
         self.app.all_providers.append(provider)
 
     def register_ui_extension(self, index):
@@ -2036,13 +2194,17 @@ class ExtensionContext:
         self.app.ui_extensions.append({"id": self.name, "path": path})
 
     def register_chat_request_filter(self, handler):
-        self.log(f"Registered chat request filter: {handler}")
+        self.log(f"Registered chat request filter: {handler_name(handler)}")
         self.app.chat_request_filters.append(handler)
 
     def register_chat_response_filter(self, handler):
-        self.log(f"Registered chat response filter: {handler}")
+        self.log(f"Registered chat response filter: {handler_name(handler)}")
         self.app.chat_response_filters.append(handler)
 
+    def register_cache_saved_filter(self, handler):
+        self.log(f"Registered cache saved filter: {handler_name(handler)}")
+        self.app.cache_saved_filters.append(handler)
+
     def add_static_files(self, ext_dir):
         self.log(f"Registered static files: {ext_dir}")
 
@@ -2063,11 +2225,29 @@ class ExtensionContext:
         self.dbg(f"Registered POST: {os.path.join(self.ext_prefix, path)}")
         self.app.server_add_post.append((os.path.join(self.ext_prefix, path), handler, kwargs))
 
+    def add_put(self, path, handler, **kwargs):
+        self.dbg(f"Registered PUT: {os.path.join(self.ext_prefix, path)}")
+        self.app.server_add_put.append((os.path.join(self.ext_prefix, path), handler, kwargs))
+
+    def add_delete(self, path, handler, **kwargs):
+        self.dbg(f"Registered DELETE: {os.path.join(self.ext_prefix, path)}")
+        self.app.server_add_delete.append((os.path.join(self.ext_prefix, path), handler, kwargs))
+
+    def add_patch(self, path, handler, **kwargs):
+        self.dbg(f"Registered PATCH: {os.path.join(self.ext_prefix, path)}")
+        self.app.server_add_patch.append((os.path.join(self.ext_prefix, path), handler, kwargs))
+
     def get_config(self):
         return g_config
 
-    def chat_completion(self, chat):
-        return chat_completion(chat)
+    def get_cache_path(self, path=""):
+        return get_cache_path(path)
+
+    def chat_request(self, template=None, text=None, model=None, system_prompt=None):
+        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)
 
     def get_providers(self):
         return g_handlers
@@ -2075,21 +2255,6 @@ class ExtensionContext:
     def get_provider(self, name):
         return g_handlers.get(name)
 
-    def get_session(self, request):
-        session_token = get_session_token(request)
-
-        if not session_token or session_token not in g_sessions:
-            return None
-
-        session_data = g_sessions[session_token]
-        return session_data
-
-    def get_username(self, request):
-        session = self.get_session(request)
-        if session:
-            return session.get("userName")
-        return None
-
     def register_tool(self, func, tool_def=None):
         if tool_def is None:
             tool_def = function_to_tool_definition(func)
@@ -2099,44 +2264,71 @@ class ExtensionContext:
         self.app.tools[name] = func
         self.app.tool_definitions.append(tool_def)
 
+    def get_session(self, request):
+        return self.app.get_session(request)
 
-def load_builtin_extensions():
-    providers_path = _ROOT / "providers"
-    if not providers_path.exists():
-        return
+    def get_username(self, request):
+        return self.app.get_username(request)
 
-    for item in os.listdir(providers_path):
-        if not item.endswith(".py") or item == "__init__.py":
-            continue
+    def get_user_path(self, username=None):
+        return self.app.get_user_path(username)
 
-        item_path = providers_path / item
-        module_name = item[:-3]
 
-        try:
-            spec = importlib.util.spec_from_file_location(module_name, item_path)
-            if spec and spec.loader:
-                module = importlib.util.module_from_spec(spec)
-                sys.modules[f"llms.providers.{module_name}"] = module
-                spec.loader.exec_module(module)
-
-                install_func = getattr(module, "__install__", None)
-                if callable(install_func):
-                    install_func(ExtensionContext(g_app, item_path))
-                    _log(f"Loaded builtin extension: {module_name}")
-        except Exception as e:
-            _err(f"Failed to load builtin extension {module_name}", e)
+def get_extensions_path():
+    return os.getenv("LLMS_EXTENSIONS_DIR", os.path.join(Path.home(), ".llms", "extensions"))
 
 
-def get_extensions_path():
-    return os.environ.get("LLMS_EXTENSIONS_DIR", os.path.join(Path.home(), ".llms", "extensions"))
+def get_disabled_extensions():
+    ret = DISABLE_EXTENSIONS.copy()
+    if g_config:
+        for ext in g_config.get("disable_extensions", []):
+            if ext not in ret:
+                ret.append(ext)
+    return ret
 
 
-def init_extensions(parser):
+def get_extensions_dirs():
+    """
+    Returns a list of extension directories.
+    """
     extensions_path = get_extensions_path()
     os.makedirs(extensions_path, exist_ok=True)
 
-    for item in os.listdir(extensions_path):
-        item_path = os.path.join(extensions_path, item)
+    # allow overriding builtin extensions
+    override_extensions = []
+    if os.path.exists(extensions_path):
+        override_extensions = os.listdir(extensions_path)
+
+    ret = []
+    disabled_extensions = get_disabled_extensions()
+
+    builtin_extensions_dir = _ROOT / "extensions"
+    if os.path.exists(builtin_extensions_dir):
+        for item in os.listdir(builtin_extensions_dir):
+            if os.path.isdir(os.path.join(builtin_extensions_dir, item)):
+                if item in override_extensions:
+                    continue
+                if item in disabled_extensions:
+                    continue
+                ret.append(os.path.join(builtin_extensions_dir, item))
+
+    if os.path.exists(extensions_path):
+        for item in os.listdir(extensions_path):
+            if os.path.isdir(os.path.join(extensions_path, item)):
+                if item in disabled_extensions:
+                    continue
+                ret.append(os.path.join(extensions_path, item))
+
+    return ret
+
+
+def init_extensions(parser):
+    """
+    Initializes extensions by loading their __init__.py files and calling the __parser__ function if it exists.
+    """
+    for item_path in get_extensions_dirs():
+        item = os.path.basename(item_path)
+
         if os.path.isdir(item_path):
             try:
                 # check for __parser__ function if exists in __init.__.py and call it with parser
@@ -2161,25 +2353,28 @@ def install_extensions():
     Scans ensure ~/.llms/extensions/ for directories with __init__.py and loads them as extensions.
     Calls the `__install__(ctx)` function in the extension module.
     """
-    extensions_path = get_extensions_path()
-    os.makedirs(extensions_path, exist_ok=True)
 
-    ext_count = len(os.listdir(extensions_path))
+    extension_dirs = get_extensions_dirs()
+    ext_count = len(list(extension_dirs))
     if ext_count == 0:
         _log("No extensions found")
         return
 
+    disabled_extensions = get_disabled_extensions()
+    if len(disabled_extensions) > 0:
+        _log(f"Disabled extensions: {', '.join(disabled_extensions)}")
+
     _log(f"Installing {ext_count} extension{'' if ext_count == 1 else 's'}...")
 
-    sys.path.append(extensions_path)
+    for item_path in extension_dirs:
+        item = os.path.basename(item_path)
 
-    for item in os.listdir(extensions_path):
-        item_path = os.path.join(extensions_path, item)
         if os.path.isdir(item_path):
-            init_file = os.path.join(item_path, "__init__.py")
-            if os.path.exists(init_file):
+            sys.path.append(item_path)
+            try:
                 ctx = ExtensionContext(g_app, item_path)
-                try:
+                init_file = os.path.join(item_path, "__init__.py")
+                if os.path.exists(init_file):
                     spec = importlib.util.spec_from_file_location(item, init_file)
                     if spec and spec.loader:
                         module = importlib.util.module_from_spec(spec)
@@ -2194,20 +2389,20 @@ def install_extensions():
                             _dbg(f"Extension {item} has no __install__ function")
                     else:
                         _dbg(f"Extension {item} has no __init__.py")
+                else:
+                    _dbg(f"Extension {init_file} not found")
 
-                    # if ui folder exists, serve as static files at /ext/{item}/
-                    ui_path = os.path.join(item_path, "ui")
-                    if os.path.exists(ui_path):
-                        ctx.add_static_files(ui_path)
+                # if ui folder exists, serve as static files at /ext/{item}/
+                ui_path = os.path.join(item_path, "ui")
+                if os.path.exists(ui_path):
+                    ctx.add_static_files(ui_path)
 
-                        # Register UI extension if index.mjs exists (/ext/{item}/index.mjs)
-                        if os.path.exists(os.path.join(ui_path, "index.mjs")):
-                            ctx.register_ui_extension("index.mjs")
+                # Register UI extension if index.mjs exists (/ext/{item}/index.mjs)
+                if os.path.exists(os.path.join(ui_path, "index.mjs")):
+                    ctx.register_ui_extension("index.mjs")
 
-                except Exception as e:
-                    _err(f"Failed to install extension {item}", e)
-            else:
-                _dbg(f"Extension {init_file} not found")
+            except Exception as e:
+                _err(f"Failed to install extension {item}", e)
         else:
             _dbg(f"Extension {item} not found: {item_path} is not a directory {os.path.exists(item_path)}")
 
@@ -2216,11 +2411,9 @@ def run_extension_cli():
     """
     Run the CLI for an extension.
     """
-    extensions_path = get_extensions_path()
-    os.makedirs(extensions_path, exist_ok=True)
+    for item_path in get_extensions_dirs():
+        item = os.path.basename(item_path)
 
-    for item in os.listdir(extensions_path):
-        item_path = os.path.join(extensions_path, item)
         if os.path.isdir(item_path):
             init_file = os.path.join(item_path, "__init__.py")
             if os.path.exists(init_file):
@@ -2235,8 +2428,8 @@ def run_extension_cli():
                     # Check for __run__ function if exists in __init__.py and call it with ctx
                     run_func = getattr(module, "__run__", None)
                     if callable(run_func):
+                        _log(f"Running extension {item}...")
                         handled = run_func(ctx)
-                        _log(f"Extension {item} was run")
                         return handled
 
                 except Exception as e:
@@ -2247,6 +2440,11 @@ def run_extension_cli():
 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)
+
     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")
@@ -2283,9 +2481,7 @@ def main():
 
     parser.add_argument("--init", action="store_true", help="Create a default llms.json")
     parser.add_argument("--update-providers", action="store_true", help="Update local models.dev providers.json")
-    parser.add_argument("--update-extensions", action="store_true", help="Update installed extensions")
 
-    parser.add_argument("--root", default=None, help="Change root directory for UI files", metavar="PATH")
     parser.add_argument("--logprefix", default="", help="Prefix used in log messages", metavar="PREFIX")
     parser.add_argument("--verbose", action="store_true", help="Verbose output")
 
@@ -2323,7 +2519,7 @@ def main():
     g_app = AppExtensions(cli_args, extra_args)
 
     # Check for verbose mode from CLI argument or environment variables
-    verbose_env = os.environ.get("VERBOSE", "").lower()
+    verbose_env = os.getenv("VERBOSE", "").lower()
     if cli_args.verbose or verbose_env in ("1", "true"):
         g_verbose = True
         # printdump(cli_args)
@@ -2332,11 +2528,6 @@ def main():
     if cli_args.logprefix:
         g_logprefix = cli_args.logprefix
 
-    _ROOT = Path(cli_args.root) if cli_args.root else resolve_root()
-    if not _ROOT:
-        print("Resource root not found")
-        exit(1)
-
     home_config_path = home_llms_path("llms.json")
     home_providers_path = home_llms_path("providers.json")
     home_providers_extra_path = home_llms_path("providers-extra.json")
@@ -2397,7 +2588,7 @@ def main():
     if (
         os.path.exists(home_providers_path)
         and (time.time() - os.path.getmtime(home_providers_path)) > 86400
-        and os.environ.get("LLMS_DISABLE_UPDATE", "") != "1"
+        and os.getenv("LLMS_DISABLE_UPDATE", "") != "1"
     ):
         try:
             asyncio.run(update_providers(home_providers_path))
@@ -2554,12 +2745,10 @@ def main():
         asyncio.run(update_extensions(cli_args.update))
         exit(0)
 
-    load_builtin_extensions()
+    install_extensions()
 
     asyncio.run(reload_providers())
 
-    install_extensions()
-
     # print names
     _log(f"enabled providers: {', '.join(g_handlers.keys())}")
 
@@ -2615,6 +2804,7 @@ def main():
         exit(0)
 
     if cli_args.serve is not None:
+        error_auth_required = create_error_response("Authentication required", "Unauthorized")
         # Disable inactive providers and save to config before starting server
         all_providers = g_config["providers"].keys()
         enabled_providers = list(g_handlers.keys())
@@ -2645,8 +2835,8 @@ def main():
             if client_secret.startswith("$"):
                 client_secret = client_secret[1:]
 
-            client_id = os.environ.get(client_id, client_id)
-            client_secret = os.environ.get(client_secret, client_secret)
+            client_id = os.getenv(client_id, client_id)
+            client_secret = os.getenv(client_secret, client_secret)
 
             if (
                 not client_id
@@ -2691,35 +2881,15 @@ def main():
             # Check authentication if enabled
             is_authenticated, user_data = check_auth(request)
             if not is_authenticated:
-                return web.json_response(
-                    {
-                        "error": {
-                            "message": "Authentication required",
-                            "type": "authentication_error",
-                            "code": "unauthorized",
-                        }
-                    },
-                    status=401,
-                )
+                return web.json_response(error_auth_required, status=401)
 
             try:
                 chat = await request.json()
-
-                # Apply pre-chat filters
                 context = {"request": request, "chat": chat}
-                for filter_func in g_app.chat_request_filters:
-                    chat = await filter_func(chat, context)
-
-                response = await chat_completion(chat)
-
-                # Apply post-chat filters
-                # Apply post-chat filters
-                for filter_func in g_app.chat_response_filters:
-                    response = await filter_func(response, context)
-
+                response = await g_app.chat_completion(chat, context)
                 return web.json_response(response)
             except Exception as e:
-                return web.json_response({"error": str(e)}, status=500)
+                return web.json_response(to_error_response(e), status=500)
 
         app.router.add_post("/v1/chat/completions", chat_handler)
 
@@ -2773,16 +2943,7 @@ def main():
             # Check authentication if enabled
             is_authenticated, user_data = check_auth(request)
             if not is_authenticated:
-                return web.json_response(
-                    {
-                        "error": {
-                            "message": "Authentication required",
-                            "type": "authentication_error",
-                            "code": "unauthorized",
-                        }
-                    },
-                    status=401,
-                )
+                return web.json_response(error_auth_required, status=401)
 
             reader = await request.multipart()
 
@@ -2792,7 +2953,7 @@ def main():
                 field = await reader.next()
 
             if not field:
-                return web.json_response({"error": "No file provided"}, status=400)
+                return web.json_response(create_error_response("No file provided"), status=400)
 
             filename = field.filename or "file"
             content = await field.read()
@@ -2830,9 +2991,10 @@ def main():
             with open(full_path, "wb") as f:
                 f.write(content)
 
+            url = f"/~cache/{relative_path}"
             response_data = {
                 "date": int(time.time()),
-                "url": f"/~cache/{relative_path}",
+                "url": url,
                 "size": len(content),
                 "type": mimetype,
                 "name": filename,
@@ -2852,6 +3014,8 @@ def main():
             with open(info_path, "w") as f:
                 json.dump(response_data, f)
 
+            g_app.on_cache_saved_filters({"url": url, "info": response_data})
+
             return web.json_response(response_data)
 
         app.router.add_post("/upload", upload_handler)
@@ -2877,7 +3041,7 @@ def main():
 
                 # Check for directory traversal for info path
                 try:
-                    cache_root = Path(get_cache_path(""))
+                    cache_root = Path(get_cache_path())
                     requested_path = Path(info_path).resolve()
                     if not str(requested_path).startswith(str(cache_root)):
                         return web.Response(text="403: Forbidden", status=403)
@@ -2893,7 +3057,7 @@ def main():
 
             # Check for directory traversal
             try:
-                cache_root = Path(get_cache_path(""))
+                cache_root = Path(get_cache_path())
                 requested_path = Path(full_path).resolve()
                 if not str(requested_path).startswith(str(cache_root)):
                     return web.Response(text="403: Forbidden", status=403)
@@ -2912,7 +3076,7 @@ def main():
         async def github_auth_handler(request):
             """Initiate GitHub OAuth flow"""
             if "auth" not in g_config or "github" not in g_config["auth"]:
-                return web.json_response({"error": "GitHub OAuth not configured"}, status=500)
+                return web.json_response(create_error_response("GitHub OAuth not configured"), status=500)
 
             auth_config = g_config["auth"]["github"]
             client_id = auth_config.get("client_id", "")
@@ -2924,11 +3088,11 @@ def main():
             if redirect_uri.startswith("$"):
                 redirect_uri = redirect_uri[1:]
 
-            client_id = os.environ.get(client_id, client_id)
-            redirect_uri = os.environ.get(redirect_uri, redirect_uri)
+            client_id = os.getenv(client_id, client_id)
+            redirect_uri = os.getenv(redirect_uri, redirect_uri)
 
             if not client_id:
-                return web.json_response({"error": "GitHub client_id not configured"}, status=500)
+                return web.json_response(create_error_response("GitHub client_id not configured"), status=500)
 
             # Generate CSRF state token
             state = secrets.token_urlsafe(32)
@@ -2960,7 +3124,7 @@ def main():
             if restrict_to.startswith("$"):
                 restrict_to = restrict_to[1:]
 
-            restrict_to = os.environ.get(restrict_to, None if restrict_to == "GITHUB_USERS" else restrict_to)
+            restrict_to = os.getenv(restrict_to, None if restrict_to == "GITHUB_USERS" else restrict_to)
 
             # If restrict_to is configured, validate the user
             if restrict_to:
@@ -2999,7 +3163,7 @@ def main():
             g_oauth_states.pop(state)
 
             if "auth" not in g_config or "github" not in g_config["auth"]:
-                return web.json_response({"error": "GitHub OAuth not configured"}, status=500)
+                return web.json_response(create_error_response("GitHub OAuth not configured"), status=500)
 
             auth_config = g_config["auth"]["github"]
             client_id = auth_config.get("client_id", "")
@@ -3014,12 +3178,12 @@ def main():
             if redirect_uri.startswith("$"):
                 redirect_uri = redirect_uri[1:]
 
-            client_id = os.environ.get(client_id, client_id)
-            client_secret = os.environ.get(client_secret, client_secret)
-            redirect_uri = os.environ.get(redirect_uri, redirect_uri)
+            client_id = os.getenv(client_id, client_id)
+            client_secret = os.getenv(client_secret, client_secret)
+            redirect_uri = os.getenv(redirect_uri, redirect_uri)
 
             if not client_id or not client_secret:
-                return web.json_response({"error": "GitHub OAuth credentials not configured"}, status=500)
+                return web.json_response(create_error_response("GitHub OAuth credentials not configured"), status=500)
 
             # Exchange code for access token
             async with aiohttp.ClientSession() as session:
@@ -3038,7 +3202,7 @@ def main():
 
                     if not access_token:
                         error = token_response.get("error_description", "Failed to get access token")
-                        return web.Response(text=f"OAuth error: {error}", status=400)
+                        return web.json_response(create_error_response(f"OAuth error: {error}"), status=400)
 
                 # Fetch user info
                 user_url = "https://api.github.com/user"
@@ -3073,7 +3237,7 @@ def main():
             session_token = get_session_token(request)
 
             if not session_token or session_token not in g_sessions:
-                return web.json_response({"error": "Invalid or expired session"}, status=401)
+                return web.json_response(create_error_response("Invalid or expired session"), status=401)
 
             session_data = g_sessions[session_token]
 
@@ -3129,9 +3293,7 @@ def main():
             #         })
 
             # Not authenticated - return error in expected format
-            return web.json_response(
-                {"responseStatus": {"errorCode": "Unauthorized", "message": "Not authenticated"}}, status=401
-            )
+            return web.json_response(error_auth_required, status=401)
 
         app.router.add_get("/auth", auth_handler)
         app.router.add_get("/auth/github", github_auth_handler)
@@ -3191,9 +3353,55 @@ def main():
 
         # go through and register all g_app extensions
         for handler in g_app.server_add_get:
-            app.router.add_get(handler[0], handler[1], **handler[2])
+            handler_fn = handler[1]
+
+            async def managed_handler(request, handler_fn=handler_fn):
+                try:
+                    return await handler_fn(request)
+                except Exception as e:
+                    return web.json_response(to_error_response(e, stacktrace=g_verbose), status=500)
+
+            app.router.add_get(handler[0], managed_handler, **handler[2])
         for handler in g_app.server_add_post:
-            app.router.add_post(handler[0], handler[1], **handler[2])
+            handler_fn = handler[1]
+
+            async def managed_handler(request, handler_fn=handler_fn):
+                try:
+                    return await handler_fn(request)
+                except Exception as e:
+                    return web.json_response(to_error_response(e, stacktrace=g_verbose), status=500)
+
+            app.router.add_post(handler[0], managed_handler, **handler[2])
+        for handler in g_app.server_add_put:
+            handler_fn = handler[1]
+
+            async def managed_handler(request, handler_fn=handler_fn):
+                try:
+                    return await handler_fn(request)
+                except Exception as e:
+                    return web.json_response(to_error_response(e, stacktrace=g_verbose), status=500)
+
+            app.router.add_put(handler[0], managed_handler, **handler[2])
+        for handler in g_app.server_add_delete:
+            handler_fn = handler[1]
+
+            async def managed_handler(request, handler_fn=handler_fn):
+                try:
+                    return await handler_fn(request)
+                except Exception as e:
+                    return web.json_response(to_error_response(e, stacktrace=g_verbose), status=500)
+
+            app.router.add_delete(handler[0], managed_handler, **handler[2])
+        for handler in g_app.server_add_patch:
+            handler_fn = handler[1]
+
+            async def managed_handler(request, handler_fn=handler_fn):
+                try:
+                    return await handler_fn(request)
+                except Exception as e:
+                    return web.json_response(to_error_response(e, stacktrace=g_verbose), status=500)
+
+            app.router.add_patch(handler[0], managed_handler, **handler[2])
 
         # Serve index.html from root
         async def index_handler(request):
@@ -3236,7 +3444,7 @@ def main():
 
         for provider in enable_providers:
             if provider not in g_config["providers"]:
-                print(f"Provider {provider} not found")
+                print(f"Provider '{provider}' not found")
                 print(f"Available providers: {', '.join(g_config['providers'].keys())}")
                 exit(1)
             if provider in g_config["providers"]:
@@ -3324,6 +3532,9 @@ def main():
 
             if len(extra_args) > 0:
                 prompt = " ".join(extra_args)
+                if not chat["messages"] or len(chat["messages"]) == 0:
+                    chat["messages"] = [{"role": "user", "content": [{"type": "text", "text": ""}]}]
+
                 # replace content of last message if exists, else add
                 last_msg = chat["messages"][-1] if "messages" in chat else None
                 if last_msg and last_msg["role"] == "user":