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

llms/main.py

@@ -9,6 +9,7 @@
 import argparse
 import asyncio
 import base64
+import contextlib
 import hashlib
 import importlib.util
 import inspect
@@ -40,12 +41,12 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.0b6"
+VERSION = "3.0.0b8"
 _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
@@ -324,6 +325,15 @@ def convert_image_if_needed(image_bytes, mimetype="image/png"):
         return image_bytes, mimetype
 
 
+def to_content(result):
+    if isinstance(result, (str, int, float, bool)):
+        return str(result)
+    elif isinstance(result, (list, set, tuple, dict)):
+        return json.dumps(result)
+    else:
+        return str(result)
+
+
 def function_to_tool_definition(func):
     type_hints = get_type_hints(func)
     signature = inspect.signature(func)
@@ -332,11 +342,11 @@ def function_to_tool_definition(func):
     for name, param in signature.parameters.items():
         param_type = type_hints.get(name, str)
         param_type_name = "string"
-        if param_type == int:
+        if param_type is int:
             param_type_name = "integer"
-        elif param_type == float:
+        elif param_type is float:
             param_type_name = "number"
-        elif param_type == bool:
+        elif param_type is bool:
             param_type_name = "boolean"
 
         parameters["properties"][name] = {"type": param_type_name}
@@ -484,6 +494,92 @@ async def process_chat(chat, provider_id=None):
     return chat
 
 
+def image_ext_from_mimetype(mimetype, default="png"):
+    if "/" in mimetype:
+        _ext = mimetypes.guess_extension(mimetype)
+        if _ext:
+            return _ext.lstrip(".")
+    return default
+
+
+def audio_ext_from_format(format, default="mp3"):
+    if format == "mpeg":
+        return "mp3"
+    return format or default
+
+
+def file_ext_from_mimetype(mimetype, default="pdf"):
+    if "/" in mimetype:
+        _ext = mimetypes.guess_extension(mimetype)
+        if _ext:
+            return _ext.lstrip(".")
+    return default
+
+
+def cache_message_inline_data(m):
+    """
+    Replaces and caches any inline data URIs in the message content.
+    """
+    if "content" not in m:
+        return
+
+    content = m["content"]
+    if isinstance(content, list):
+        for item in content:
+            if item.get("type") == "image_url":
+                image_url = item.get("image_url", {})
+                url = image_url.get("url")
+                if url and url.startswith("data:"):
+                    # Extract base64 and mimetype
+                    try:
+                        header, base64_data = url.split(";base64,")
+                        # header is like "data:image/png"
+                        ext = image_ext_from_mimetype(header.split(":")[1])
+                        filename = f"image.{ext}"  # Hash will handle uniqueness
+
+                        cache_url, _ = save_image_to_cache(base64_data, filename, {}, ignore_info=True)
+                        image_url["url"] = cache_url
+                    except Exception as e:
+                        _log(f"Error caching inline image: {e}")
+
+            elif item.get("type") == "input_audio":
+                input_audio = item.get("input_audio", {})
+                data = input_audio.get("data")
+                if data:
+                    # Handle data URI or raw base64
+                    base64_data = data
+                    if data.startswith("data:"):
+                        with contextlib.suppress(ValueError):
+                            header, base64_data = data.split(";base64,")
+
+                    fmt = audio_ext_from_format(input_audio.get("format"))
+                    filename = f"audio.{fmt}"
+
+                    try:
+                        cache_url, _ = save_bytes_to_cache(base64_data, filename, {}, ignore_info=True)
+                        input_audio["data"] = cache_url
+                    except Exception as e:
+                        _log(f"Error caching inline audio: {e}")
+
+            elif item.get("type") == "file":
+                file_info = item.get("file", {})
+                file_data = file_info.get("file_data")
+                if file_data and file_data.startswith("data:"):
+                    try:
+                        header, base64_data = file_data.split(";base64,")
+                        mimetype = header.split(":")[1]
+                        # Try to get extension from filename if available, else mimetype
+                        filename = file_info.get("filename", "file")
+                        if "." not in filename:
+                            ext = file_ext_from_mimetype(mimetype)
+                            filename = f"{filename}.{ext}"
+
+                        cache_url, _ = save_bytes_to_cache(base64_data, filename, {}, ignore_info=True)
+                        file_info["file_data"] = cache_url
+                    except Exception as e:
+                        _log(f"Error caching inline file: {e}")
+
+
 class HTTPError(Exception):
     def __init__(self, status, reason, body, headers=None):
         self.status = status
@@ -493,7 +589,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, ignore_info=False):
     ext = filename.split(".")[-1]
     mimetype = get_file_mime_type(filename)
     content = base64.b64decode(base64_data) if isinstance(base64_data, str) else base64_data
@@ -505,12 +601,61 @@ 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}"
+
+    # if file and its .info.json already exists, return it
+    info_path = os.path.splitext(full_path)[0] + ".info.json"
+    if os.path.exists(full_path) and os.path.exists(info_path):
+        _dbg(f"Cached bytes exists: {relative_path}")
+        if ignore_info:
+            return url, None
+        return url, json.load(open(info_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)
+
+    # Save metadata
+    info_path = os.path.splitext(full_path)[0] + ".info.json"
+    with open(info_path, "w") as f:
+        json.dump(info, f)
+
+    _dbg(f"Saved cached bytes and info: {relative_path}")
+
+    g_app.on_cache_saved_filters({"url": url, "info": info})
+
+    return url, info
+
+
+def save_image_to_cache(base64_data, filename, image_info, ignore_info=False):
+    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"
     if os.path.exists(full_path) and os.path.exists(info_path):
+        _dbg(f"Saved image exists: {relative_path}")
+        if ignore_info:
+            return url, None
         return url, json.load(open(info_path))
 
     os.makedirs(os.path.dirname(full_path), exist_ok=True)
@@ -545,6 +690,10 @@ def save_image_to_cache(base64_data, filename, image_info):
     with open(info_path, "w") as f:
         json.dump(info, f)
 
+    _dbg(f"Saved image and info: {relative_path}")
+
+    g_app.on_cache_saved_filters({"url": url, "info": info})
+
     return url, info
 
 
@@ -577,6 +726,27 @@ def chat_to_prompt(chat):
     return prompt
 
 
+def chat_to_system_prompt(chat):
+    if "messages" in chat:
+        for message in chat["messages"]:
+            if message["role"] == "system":
+                # if content is string
+                if isinstance(message["content"], str):
+                    return message["content"]
+                elif isinstance(message["content"], list):
+                    # if content is array of objects
+                    for part in message["content"]:
+                        if part["type"] == "text":
+                            return part["text"]
+    return None
+
+
+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 +763,49 @@ def last_user_prompt(chat):
     return prompt
 
 
+def chat_response_to_message(openai_response):
+    """
+    Returns an assistant message from the OpenAI Response.
+    Handles normalizing text, image, and audio responses into the message content.
+    """
+    timestamp = int(time.time() * 1000)  # openai_response.get("created")
+    choices = openai_response
+    if isinstance(openai_response, dict) and "choices" in openai_response:
+        choices = openai_response["choices"]
+
+    choice = choices[0] if isinstance(choices, list) and choices else choices
+
+    if isinstance(choice, str):
+        return {"role": "assistant", "content": choice, "timestamp": timestamp}
+
+    if isinstance(choice, dict):
+        message = choice.get("message", choice)
+    else:
+        return {"role": "assistant", "content": str(choice), "timestamp": timestamp}
+
+    # Ensure message is a dict
+    if not isinstance(message, dict):
+        return {"role": "assistant", "content": message, "timestamp": timestamp}
+
+    message.update({"timestamp": timestamp})
+    return message
+
+
+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):
@@ -755,13 +968,17 @@ class OpenAiCompatible:
         if not self.models:
             await self.load_models()
 
-    def model_cost(self, model):
+    def model_info(self, model):
         provider_model = self.provider_model(model) or model
         for model_id, model_info in self.models.items():
             if model_id.lower() == provider_model.lower():
-                return model_info.get("cost")
+                return model_info
         return None
 
+    def model_cost(self, model):
+        model_info = self.model_info(model)
+        return model_info.get("cost") if model_info else None
+
     def provider_model(self, model):
         # convert model to lowercase for case-insensitive comparison
         model_lower = model.lower()
@@ -823,7 +1040,7 @@ class OpenAiCompatible:
         chat["model"] = self.provider_model(chat["model"]) or chat["model"]
 
         if "modalities" in chat:
-            for modality in chat["modalities"]:
+            for modality in chat.get("modalities", []):
                 # use default implementation for text modalities
                 if modality == "text":
                     continue
@@ -875,13 +1092,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,29 +1271,105 @@ def api_providers():
     return ret
 
 
-async def chat_completion(chat):
-    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)]
-    if len(candidate_providers) == 0:
-        raise (Exception(f"Model {model} not found"))
+def to_error_message(e):
+    return str(e)
+
+
+def to_error_response(e, stacktrace=False):
+    status = {"errorCode": "Error", "message": to_error_message(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 should_cancel_thread(context):
+    ret = context.get("cancelled", False)
+    if ret:
+        thread_id = context.get("threadId")
+        _dbg(f"Thread cancelled {thread_id}")
+    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):
+    try:
+        model = chat.get("model")
+        if not model:
+            raise Exception("Model not specified")
+
+        if context is None:
+            context = {"chat": chat, "tools": "all"}
 
+        # get first provider that has the model
+        candidate_providers = [name for name, provider in g_handlers.items() if provider.provider_model(model)]
+        if len(candidate_providers) == 0:
+            raise (Exception(f"Model {model} not found"))
+    except Exception as e:
+        await g_app.on_chat_error(e, context or {"chat": chat})
+        raise e
+
+    started_at = time.time()
     first_exception = None
+    provider_name = "Unknown"
     for name in candidate_providers:
-        provider = g_handlers[name]
-        _log(f"provider: {name} {type(provider).__name__}")
         try:
-            # Inject global tools if present
-            current_chat = chat.copy()
+            provider_name = name
+            provider = g_handlers[name]
+            _log(f"provider: {name} {type(provider).__name__}")
+            started_at = time.time()
+            context["startedAt"] = datetime.now()
+            context["provider"] = name
+            model_info = provider.model_info(model)
+            context["modelCost"] = model_info.get("cost", provider.model_cost(model)) or {"input": 0, "output": 0}
+            context["modelInfo"] = model_info
+
+            # Accumulate usage across tool calls
+            total_usage = {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0,
+            }
+            accumulated_cost = 0.0
+
             # Inject global tools if present
             current_chat = chat.copy()
             if g_app.tool_definitions:
-                include_all_tools = False
-                only_tools = []
-                if "metadata" in chat:
-                    only_tools_str = chat["metadata"].get("only_tools", "")
-                    include_all_tools = only_tools_str == "all"
-                    only_tools = only_tools_str.split(",")
+                only_tools_str = context.get("tools", "all")
+                include_all_tools = only_tools_str == "all"
+                only_tools = only_tools_str.split(",")
 
                 if include_all_tools or len(only_tools) > 0:
                     if "tools" not in current_chat:
@@ -1087,12 +1381,38 @@ async def chat_completion(chat):
                         if name not in existing_tools and (include_all_tools or name in only_tools):
                             current_chat["tools"].append(tool_def)
 
+            # Apply pre-chat filters ONCE
+            context["chat"] = current_chat
+            for filter_func in g_app.chat_request_filters:
+                await filter_func(current_chat, context)
+
             # Tool execution loop
-            max_iterations = 5
+            max_iterations = 10
             tool_history = []
+            final_response = None
+
             for _ in range(max_iterations):
+                if should_cancel_thread(context):
+                    return
+
                 response = await provider.chat(current_chat)
 
+                if should_cancel_thread(context):
+                    return
+
+                # Aggregate usage
+                if "usage" in response:
+                    usage = response["usage"]
+                    total_usage["prompt_tokens"] += usage.get("prompt_tokens", 0)
+                    total_usage["completion_tokens"] += usage.get("completion_tokens", 0)
+                    total_usage["total_tokens"] += usage.get("total_tokens", 0)
+
+                    # Calculate cost for this step if available
+                    if "cost" in response and isinstance(response["cost"], (int, float)):
+                        accumulated_cost += response["cost"]
+                    elif "cost" in usage and isinstance(usage["cost"], (int, float)):
+                        accumulated_cost += usage["cost"]
+
                 # Check for tool_calls in the response
                 choice = response.get("choices", [])[0] if response.get("choices") else {}
                 message = choice.get("message", {})
@@ -1102,48 +1422,85 @@ async def chat_completion(chat):
                     # Append the assistant's message with tool calls to history
                     if "messages" not in current_chat:
                         current_chat["messages"] = []
+                    if "timestamp" not in message:
+                        message["timestamp"] = int(time.time() * 1000)
                     current_chat["messages"].append(message)
                     tool_history.append(message)
 
                     for tool_call in tool_calls:
                         function_name = tool_call["function"]["name"]
-                        function_args = json.loads(tool_call["function"]["arguments"])
-
-                        tool_result = f"Error: Tool {function_name} not found"
-                        if function_name in g_app.tools:
-                            try:
-                                func = g_app.tools[function_name]
-                                if inspect.iscoroutinefunction(func):
-                                    tool_result = await func(**function_args)
-                                else:
-                                    tool_result = func(**function_args)
-                            except Exception as e:
-                                tool_result = f"Error executing tool {function_name}: {e}"
+                        try:
+                            function_args = json.loads(tool_call["function"]["arguments"])
+                        except Exception as e:
+                            tool_result = f"Error parsing JSON arguments for tool {function_name}: {e}"
+                        else:
+                            tool_result = f"Error: Tool {function_name} not found"
+                            if function_name in g_app.tools:
+                                try:
+                                    func = g_app.tools[function_name]
+                                    if inspect.iscoroutinefunction(func):
+                                        tool_result = await func(**function_args)
+                                    else:
+                                        tool_result = func(**function_args)
+                                except Exception as e:
+                                    tool_result = f"Error executing tool {function_name}: {e}"
 
                         # Append tool result to history
-                        tool_msg = {"role": "tool", "tool_call_id": tool_call["id"], "content": str(tool_result)}
+                        tool_msg = {"role": "tool", "tool_call_id": tool_call["id"], "content": to_content(tool_result)}
                         current_chat["messages"].append(tool_msg)
                         tool_history.append(tool_msg)
 
+                    for filter_func in g_app.chat_tool_filters:
+                        await filter_func(current_chat, context)
+
+                    if should_cancel_thread(context):
+                        return
+
                     # Continue loop to send tool results back to LLM
                     continue
 
-                # If no tool calls, return the response
+                # If no tool calls, this is the final response
                 if tool_history:
                     response["tool_history"] = tool_history
-                return response
+
+                # Update final response with aggregated usage
+                if "usage" not in response:
+                    response["usage"] = {}
+                # convert to int seconds
+                context["duration"] = duration = int(time.time() - started_at)
+                total_usage.update({"duration": duration})
+                response["usage"].update(total_usage)
+                # If we accumulated cost, set it on the response
+                if accumulated_cost > 0:
+                    response["cost"] = accumulated_cost
+
+                final_response = response
+                break  # Exit tool loop
+
+            if final_response:
+                # Apply post-chat filters ONCE on final response
+                for filter_func in g_app.chat_response_filters:
+                    await filter_func(final_response, context)
+
+                if DEBUG:
+                    _dbg(json.dumps(final_response, indent=2))
+
+                return final_response
 
         except Exception as e:
             if first_exception is None:
                 first_exception = e
-            _log(f"Provider {name} failed: {e}")
+                context["stackTrace"] = traceback.format_exc()
+            _err(f"Provider {provider_name} failed", first_exception)
+            await g_app.on_chat_error(e, context)
+
             continue
 
     # If we get here, all providers failed
     raise first_exception
 
 
-async def cli_chat(chat, image=None, audio=None, file=None, args=None, raw=False):
+async def cli_chat(chat, tools=None, image=None, audio=None, file=None, args=None, raw=False):
     if g_default_model:
         chat["model"] = g_default_model
 
@@ -1218,16 +1575,11 @@ 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 chat_completion(chat)
+        context = {
+            "tools": tools or "all",
+        }
+        response = await g_app.chat_completion(chat, context=context)
 
-        # 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,28 +1596,32 @@ 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)
 
     except HTTPError as e:
         # HTTP error (4xx, 5xx)
         print(f"{e}:\n{e.body}")
-        exit(1)
+        g_app.exit(1)
     except aiohttp.ClientConnectionError as e:
         # Connection issues
         print(f"Connection error: {e}")
-        exit(1)
+        g_app.exit(1)
     except asyncio.TimeoutError as e:
         # Timeout
         print(f"Timeout error: {e}")
-        exit(1)
+        g_app.exit(1)
 
 
 def config_str(key):
@@ -1288,7 +1644,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 +1682,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 +1823,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 +1836,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))
@@ -1951,14 +2307,41 @@ class AppExtensions:
     def __init__(self, cli_args, extra_args):
         self.cli_args = cli_args
         self.extra_args = extra_args
+        self.config = None
+        self.error_auth_required = create_error_response("Authentication required", "Unauthorized")
         self.ui_extensions = []
         self.chat_request_filters = []
+        self.chat_tool_filters = []
         self.chat_response_filters = []
+        self.chat_error_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.shutdown_handlers = []
         self.tools = {}
         self.tool_definitions = []
+        self.index_headers = []
+        self.index_footers = []
+        self.request_args = {
+            "image_config": dict,  # e.g. { "aspect_ratio": "1:1" }
+            "temperature": float,  # e.g: 0.7
+            "max_completion_tokens": int,  # e.g: 2048
+            "seed": int,  # e.g: 42
+            "top_p": float,  # e.g: 0.9
+            "frequency_penalty": float,  # e.g: 0.5
+            "presence_penalty": float,  # e.g: 0.5
+            "stop": list,  # e.g: ["Stop"]
+            "reasoning_effort": str,  # e.g: minimal, low, medium, high
+            "verbosity": str,  # e.g: low, medium, high
+            "service_tier": str,  # e.g: auto, default
+            "top_logprobs": int,
+            "safety_identifier": str,
+            "store": bool,
+            "enable_thinking": bool,
+        }
         self.all_providers = [
             OpenAiCompatible,
             MistralProvider,
@@ -1980,11 +2363,108 @@ class AppExtensions:
             "16:9": "1344×768",
             "21:9": "1536×672",
         }
+        self.import_maps = {
+            "vue-prod": "/ui/lib/vue.min.mjs",
+            "vue": "/ui/lib/vue.mjs",
+            "vue-router": "/ui/lib/vue-router.min.mjs",
+            "@servicestack/client": "/ui/lib/servicestack-client.mjs",
+            "@servicestack/vue": "/ui/lib/servicestack-vue.mjs",
+            "idb": "/ui/lib/idb.min.mjs",
+            "marked": "/ui/lib/marked.min.mjs",
+            "highlight.js": "/ui/lib/highlight.min.mjs",
+            "chart.js": "/ui/lib/chart.js",
+            "color.js": "/ui/lib/color.js",
+            "ctx.mjs": "/ui/ctx.mjs",
+        }
+
+    def set_config(self, config):
+        self.config = config
+        self.auth_enabled = self.config.get("auth", {}).get("enabled", False)
+
+    # Authentication middleware helper
+    def check_auth(self, request):
+        """Check if request is authenticated. Returns (is_authenticated, user_data)"""
+        if not self.auth_enabled:
+            return True, None
+
+        # Check for OAuth session token
+        session_token = get_session_token(request)
+        if session_token and session_token in g_sessions:
+            return True, g_sessions[session_token]
+
+        # Check for API key
+        auth_header = request.headers.get("Authorization", "")
+        if auth_header.startswith("Bearer "):
+            api_key = auth_header[7:]
+            if api_key:
+                return True, {"authProvider": "apikey"}
+
+        return False, None
+
+    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):
+        response = await g_chat_completion(chat, 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)
+
+    async def on_chat_error(self, e, context):
+        # Apply chat error filters
+        if "stackTrace" not in context:
+            context["stackTrace"] = traceback.format_exc()
+        for filter_func in self.chat_error_filters:
+            try:
+                await filter_func(e, context)
+            except Exception as e:
+                _err("chat error filter failed", e)
+
+    def exit(self, exit_code=0):
+        if len(self.shutdown_handlers) > 0:
+            _dbg(f"running {len(self.shutdown_handlers)} shutdown handlers...")
+            for handler in self.shutdown_handlers:
+                handler()
+
+        _dbg(f"exit({exit_code})")
+        sys.exit(exit_code)
+
+
+def handler_name(handler):
+    if hasattr(handler, "__name__"):
+        return handler.__name__
+    return "unknown"
 
 
 class ExtensionContext:
     def __init__(self, app, path):
         self.app = app
+        self.cli_args = app.cli_args
+        self.extra_args = app.extra_args
+        self.error_auth_required = app.error_auth_required
         self.path = path
         self.name = os.path.basename(path)
         if self.name.endswith(".py"):
@@ -1994,16 +2474,30 @@ class ExtensionContext:
         self.MOCK_DIR = MOCK_DIR
         self.debug = DEBUG
         self.verbose = g_verbose
+        self.aspect_ratios = app.aspect_ratios
+        self.request_args = app.request_args
 
     def chat_to_prompt(self, chat):
         return chat_to_prompt(chat)
 
+    def chat_to_system_prompt(self, chat):
+        return chat_to_system_prompt(chat)
+
+    def chat_response_to_message(self, response):
+        return chat_response_to_message(response)
+
     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)
 
@@ -2026,8 +2520,14 @@ class ExtensionContext:
         if self.verbose:
             print(traceback.format_exc(), flush=True)
 
+    def error_message(self, e):
+        return to_error_message(e)
+
+    def error_response(self, e, stacktrace=False):
+        return to_error_response(e, stacktrace=stacktrace)
+
     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 +2536,29 @@ 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_tool_filter(self, handler):
+        self.log(f"Registered chat tool filter: {handler_name(handler)}")
+        self.app.chat_tool_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_chat_error_filter(self, handler):
+        self.log(f"Registered chat error filter: {handler_name(handler)}")
+        self.app.chat_error_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 register_shutdown_handler(self, handler):
+        self.log(f"Registered shutdown handler: {handler_name(handler)}")
+        self.app.shutdown_handlers.append(handler)
+
     def add_static_files(self, ext_dir):
         self.log(f"Registered static files: {ext_dir}")
 
@@ -2063,11 +2579,38 @@ 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 add_importmaps(self, dict):
+        self.app.import_maps.update(dict)
+
+    def add_index_header(self, html):
+        self.app.index_headers.append(html)
+
+    def add_index_footer(self, html):
+        self.app.index_footers.append(html)
+
     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 +2618,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 +2627,83 @@ class ExtensionContext:
         self.app.tools[name] = func
         self.app.tool_definitions.append(tool_def)
 
+    def check_auth(self, request):
+        return self.app.check_auth(request)
 
-def load_builtin_extensions():
-    providers_path = _ROOT / "providers"
-    if not providers_path.exists():
-        return
+    def get_session(self, request):
+        return self.app.get_session(request)
 
-    for item in os.listdir(providers_path):
-        if not item.endswith(".py") or item == "__init__.py":
-            continue
+    def get_username(self, request):
+        return self.app.get_username(request)
 
-        item_path = providers_path / item
-        module_name = item[:-3]
+    def get_user_path(self, username=None):
+        return self.app.get_user_path(username)
 
-        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 should_cancel_thread(self, context):
+        return should_cancel_thread(context)
+
+    def cache_message_inline_data(self, message):
+        return cache_message_inline_data(message)
+
+    def to_content(self, result):
+        return to_content(result)
 
 
 def get_extensions_path():
-    return os.environ.get("LLMS_EXTENSIONS_DIR", os.path.join(Path.home(), ".llms", "extensions"))
+    return os.getenv("LLMS_EXTENSIONS_DIR", os.path.join(Path.home(), ".llms", "extensions"))
 
 
-def init_extensions(parser):
+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 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 +2728,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 +2764,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 +2786,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 +2803,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 +2815,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")
@@ -2256,6 +2829,9 @@ def main():
     parser.add_argument(
         "-s", "--system", default=None, help="System prompt to use for chat completion", metavar="PROMPT"
     )
+    parser.add_argument(
+        "--tools", default=None, help="Tools to use for chat completion (all|none|<tool>,<tool>...)", metavar="TOOLS"
+    )
     parser.add_argument("--image", default=None, help="Image input to use in chat completion")
     parser.add_argument("--audio", default=None, help="Audio input to use in chat completion")
     parser.add_argument("--file", default=None, help="File input to use in chat completion")
@@ -2283,9 +2859,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 +2897,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 +2906,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")
@@ -2385,6 +2954,8 @@ def main():
         g_config_path = home_config_path
         g_config = load_config_json(text_from_file(g_config_path))
 
+    g_app.set_config(g_config)
+
     if not g_providers:
         g_providers = json.loads(text_from_file(home_providers_path))
 
@@ -2397,7 +2968,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 +3125,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())}")
 
@@ -2605,14 +3174,14 @@ def main():
         print(f"\n{model_count} models available from {provider_count} providers")
 
         print_status()
-        exit(0)
+        g_app.exit(0)
 
     if cli_args.check is not None:
         # Check validity of models for a provider
         provider_name = cli_args.check
         model_names = extra_args if len(extra_args) > 0 else None
         asyncio.run(check_models(provider_name, model_names))
-        exit(0)
+        g_app.exit(0)
 
     if cli_args.serve is not None:
         # Disable inactive providers and save to config before starting server
@@ -2645,8 +3214,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
@@ -2667,59 +3236,22 @@ def main():
         _log(f"client_max_size set to {client_max_size} bytes ({client_max_size / 1024 / 1024:.1f}MB)")
         app = web.Application(client_max_size=client_max_size)
 
-        # Authentication middleware helper
-        def check_auth(request):
-            """Check if request is authenticated. Returns (is_authenticated, user_data)"""
-            if not auth_enabled:
-                return True, None
-
-            # Check for OAuth session token
-            session_token = get_session_token(request)
-            if session_token and session_token in g_sessions:
-                return True, g_sessions[session_token]
-
-            # Check for API key
-            auth_header = request.headers.get("Authorization", "")
-            if auth_header.startswith("Bearer "):
-                api_key = auth_header[7:]
-                if api_key:
-                    return True, {"authProvider": "apikey"}
-
-            return False, None
-
         async def chat_handler(request):
             # Check authentication if enabled
-            is_authenticated, user_data = check_auth(request)
+            is_authenticated, user_data = g_app.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(g_app.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)
-
+                context = {"chat": chat, "request": request, "user": g_app.get_username(request)}
+                metadata = chat.get("metadata", {})
+                context["threadId"] = metadata.get("threadId", None)
+                context["tools"] = metadata.get("tools", "all")
+                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)
 
@@ -2771,18 +3303,9 @@ def main():
 
         async def upload_handler(request):
             # Check authentication if enabled
-            is_authenticated, user_data = check_auth(request)
+            is_authenticated, user_data = g_app.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(g_app.error_auth_required, status=401)
 
             reader = await request.multipart()
 
@@ -2792,7 +3315,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 +3353,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 +3376,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 +3403,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 +3419,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 +3438,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 +3450,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 +3486,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 +3525,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 +3540,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 +3564,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 +3599,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 +3655,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(g_app.error_auth_required, status=401)
 
         app.router.add_get("/auth", auth_handler)
         app.router.add_get("/auth/github", github_auth_handler)
@@ -3191,15 +3715,81 @@ 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):
             index_content = read_resource_file_bytes("index.html")
-            if index_content is None:
-                raise web.HTTPNotFound
+
+            importmaps = {"imports": g_app.import_maps}
+            importmaps_script = '<script type="importmap">\n' + json.dumps(importmaps, indent=4) + "\n</script>"
+            index_content = index_content.replace(
+                b'<script type="importmap"></script>',
+                importmaps_script.encode("utf-8"),
+            )
+
+            if len(g_app.index_headers) > 0:
+                html_header = ""
+                for header in g_app.index_headers:
+                    html_header += header
+                # replace </head> with html_header
+                index_content = index_content.replace(b"</head>", html_header.encode("utf-8") + b"\n</head>")
+
+            if len(g_app.index_footers) > 0:
+                html_footer = ""
+                for footer in g_app.index_footers:
+                    html_footer += footer
+                # replace </body> with html_footer
+                index_content = index_content.replace(b"</body>", html_footer.encode("utf-8") + b"\n</body>")
+
             return web.Response(body=index_content, content_type="text/html")
 
         app.router.add_get("/", index_handler)
@@ -3219,7 +3809,7 @@ def main():
 
         print(f"Starting server on port {port}...")
         web.run_app(app, host="0.0.0.0", port=port, print=_log)
-        exit(0)
+        g_app.exit(0)
 
     if cli_args.enable is not None:
         if cli_args.enable.endswith(","):
@@ -3236,7 +3826,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"]:
@@ -3249,7 +3839,7 @@ def main():
         print_status()
         if len(msgs) > 0:
             print("\n" + "\n".join(msgs))
-        exit(0)
+        g_app.exit(0)
 
     if cli_args.disable is not None:
         if cli_args.disable.endswith(","):
@@ -3272,7 +3862,7 @@ def main():
             print(f"\nDisabled provider {provider}")
 
         print_status()
-        exit(0)
+        g_app.exit(0)
 
     if cli_args.default is not None:
         default_model = cli_args.default
@@ -3284,7 +3874,7 @@ def main():
         default_text["model"] = default_model
         save_config(g_config)
         print(f"\nDefault model set to: {default_model}")
-        exit(0)
+        g_app.exit(0)
 
     if (
         cli_args.chat is not None
@@ -3324,6 +3914,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":
@@ -3341,21 +3934,28 @@ def main():
 
             asyncio.run(
                 cli_chat(
-                    chat, image=cli_args.image, audio=cli_args.audio, file=cli_args.file, args=args, raw=cli_args.raw
+                    chat,
+                    tools=cli_args.tools,
+                    image=cli_args.image,
+                    audio=cli_args.audio,
+                    file=cli_args.file,
+                    args=args,
+                    raw=cli_args.raw,
                 )
             )
-            exit(0)
+            g_app.exit(0)
         except Exception as e:
             print(f"{cli_args.logprefix}Error: {e}")
             if cli_args.verbose:
                 traceback.print_exc()
-            exit(1)
+            g_app.exit(1)
 
     handled = run_extension_cli()
 
     if not handled:
         # show usage from ArgumentParser
         parser.print_help()
+        g_app.exit(0)
 
 
 if __name__ == "__main__":