llms-py 3.0.5__py3-none-any.whl → 3.0.7__py3-none-any.whl

llms/extensions/analytics/ui/index.mjs

@@ -370,7 +370,7 @@ export const Analytics = {
                                                 </div>
                                                 <div>
                                                     <div class="text-xs text-gray-500 dark:text-gray-400 font-medium">Duration</div>
-                                                    <div v-if="request.duration" class="text-sm font-semibold text-gray-900 dark:text-gray-100">{{ $fmt.humanifyMs(request.duration) }}</div>
+                                                    <div v-if="request.duration" class="text-sm font-semibold text-gray-900 dark:text-gray-100">{{ $fmt.humanifyMs(request.duration * 1000) }}</div>
                                                 </div>
                                                 <div>
                                                     <div class="text-xs text-gray-500 dark:text-gray-400 font-medium">Speed</div>

llms/extensions/app/__init__.py

@@ -444,7 +444,9 @@ def install(ctx):
         input_tokens = usage.get("prompt_tokens", 0)
         output_tokens = usage.get("completion_tokens", 0)
         total_tokens = usage.get("total_tokens", input_tokens + output_tokens)
-        cost = o.get("cost", ((input_price * input_tokens) + (output_price * output_tokens)) / 1000000)
+        cost = usage.get("cost") or o.get(
+            "cost", ((input_price * input_tokens) + (output_price * output_tokens)) / 1000000
+        )
 
         request = {
             "user": user,

llms/extensions/providers/__init__.py

@@ -5,6 +5,7 @@ from .google import install_google
 from .nvidia import install_nvidia
 from .openai import install_openai
 from .openrouter import install_openrouter
+from .zai import install_zai
 
 
 def install(ctx):
@@ -15,6 +16,7 @@ def install(ctx):
     install_nvidia(ctx)
     install_openai(ctx)
     install_openrouter(ctx)
+    install_zai(ctx)
 
 
 __install__ = install

llms/extensions/providers/anthropic.py

@@ -221,7 +221,7 @@ def install_anthropic(ctx):
             # Add metadata
             if "metadata" not in ret:
                 ret["metadata"] = {}
-            ret["metadata"]["duration"] = int((time.time() - started_at) * 1000)
+            ret["metadata"]["duration"] = int(time.time() - started_at)
 
             if chat is not None and "model" in chat:
                 cost = self.model_cost(chat["model"])

llms/extensions/providers/chutes.py

@@ -66,15 +66,13 @@ def install_chutes(ctx):
             if chat["model"] in self.model_negative_prompt:
                 payload["negative_prompt"] = self.negative_prompt
 
-            image_config = chat.get("image_config", {})
-            aspect_ratio = image_config.get("aspect_ratio")
-            if aspect_ratio:
-                dimension = ctx.app.aspect_ratios.get(aspect_ratio)
-                if dimension:
-                    w, h = dimension.split("×")
-                    width, height = int(w), int(h)
-                    payload["width"] = width
-                    payload["height"] = height
+            aspect_ratio = ctx.chat_to_aspect_ratio(chat) or "1:1"
+            dimension = ctx.app.aspect_ratios.get(aspect_ratio)
+            if dimension:
+                w, h = dimension.split("×")
+                width, height = int(w), int(h)
+                payload["width"] = width
+                payload["height"] = height
 
             if chat["model"] in self.model_resolutions:
                 # if models use resolution, remove width and height

llms/extensions/providers/nvidia.py

@@ -66,17 +66,15 @@ def install_nvidia(ctx):
             }
             modalities = chat.get("modalities", ["text"])
             if "image" in modalities:
-                image_config = chat.get("image_config", {})
-                aspect_ratio = image_config.get("aspect_ratio")
-                if aspect_ratio:
-                    dimension = ctx.app.aspect_ratios.get(aspect_ratio)
-                    if dimension:
-                        width, height = dimension.split("×")
-                        gen_request["width"] = int(width)
-                        gen_request["height"] = int(height)
-                    else:
-                        gen_request["width"] = self.width
-                        gen_request["height"] = self.height
+                aspect_ratio = ctx.chat_to_aspect_ratio(chat) or "1:1"
+                dimension = ctx.app.aspect_ratios.get(aspect_ratio)
+                if dimension:
+                    width, height = dimension.split("×")
+                    gen_request["width"] = int(width)
+                    gen_request["height"] = int(height)
+                else:
+                    gen_request["width"] = self.width
+                    gen_request["height"] = self.height
 
                 gen_request["mode"] = self.mode
                 gen_request["cfg_scale"] = self.cfg_scale

llms/extensions/providers/openai.py

@@ -119,9 +119,7 @@ def install_openai(ctx):
             if chat["model"] in self.map_image_models:
                 chat["model"] = self.map_image_models[chat["model"]]
 
-            aspect_ratio = "1:1"
-            if "image_config" in chat and "aspect_ratio" in chat["image_config"]:
-                aspect_ratio = chat["image_config"].get("aspect_ratio", "1:1")
+            aspect_ratio = ctx.chat_to_aspect_ratio(chat) or "1:1"
             payload = {
                 "model": chat["model"],
                 "prompt": ctx.last_user_prompt(chat),

llms/extensions/providers/zai.py

@@ -0,0 +1,182 @@
+import json
+import time
+from typing import Optional
+
+import aiohttp
+
+
+def install_zai(ctx):
+    from llms.main import GeneratorBase
+
+    # https://docs.z.ai/guides/image/glm-image
+    class ZaiGenerator(GeneratorBase):
+        sdk = "zai/image"
+
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            self.aspect_ratios = {
+                "1:1": "1280×1280",
+                "2:3": "1056×1568",
+                "3:2": "1568×1056",
+                "3:4": "1088×1472",
+                "4:3": "1472×1088",
+                "4:5": "1088×1472",
+                "5:4": "1472×1088",
+                "9:16": "960×1728",
+                "16:9": "1728×960",
+                "21:9": "1728×960",
+            }
+            self.model: str = kwargs.get("model", "glm-image")
+            self.n: Optional[int] = kwargs.get("n")
+            self.quality: Optional[str] = kwargs.get("quality")
+            self.response_format: Optional[str] = kwargs.get("response_format")
+            self.size: Optional[str] = kwargs.get("size")
+            self.style: Optional[str] = kwargs.get("style")
+            self.sensitive_word_check: Optional[str] = kwargs.get("sensitive_word_check")
+            self.user: Optional[str] = kwargs.get("user")
+            self.request_id: Optional[str] = kwargs.get("request_id")
+            self.user_id: Optional[str] = kwargs.get("user_id")
+            self.extra_headers: Optional[dict] = kwargs.get("extra_headers")
+            self.extra_body: Optional[dict] = kwargs.get("extra_body")
+            self.disable_strict_validation: Optional[bool] = kwargs.get("disable_strict_validation")
+            self.timeout: Optional[float] = float(kwargs.get("timeout") or 300)
+            self.watermark_enabled: Optional[bool] = kwargs.get("watermark_enabled")
+
+        async def chat(self, chat, provider=None, context=None):
+            headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+            if self.extra_headers:
+                headers.update(self.extra_headers)
+
+            chat_url = "https://api.z.ai/api/paas/v4/images/generations"
+            if provider is not None:
+                headers["Authorization"] = f"Bearer {provider.api_key}"
+                chat["model"] = provider.provider_model(chat["model"]) or chat["model"]
+                chat_url = provider.api + "/images/generations"
+
+            body = {}
+            attrs = [
+                "model",
+                "n",
+                "quality",
+                "response_format",
+                "size",
+                "style",
+                "sensitive_word_check",
+                "user",
+                "request_id",
+                "user_id",
+                "disable_strict_validation",
+                "watermark_enabled",
+            ]
+            for attr in attrs:
+                if hasattr(self, attr) and getattr(self, attr) is not None:
+                    body[attr] = getattr(self, attr)
+
+            if self.extra_body:
+                body.update(self.extra_body)
+
+            if "model" in chat:
+                body["model"] = chat["model"]
+
+            body["prompt"] = ctx.last_user_prompt(chat)
+
+            aspect_ratio = ctx.chat_to_aspect_ratio(chat) or "1:1"
+            size = self.aspect_ratios.get(aspect_ratio, "1280x1280").replace("×", "x")
+            body["size"] = size
+
+            username = ctx.context_to_username(context)
+            if username:
+                body["user"] = username
+
+            ctx.dbg(f"ZaiProvider.chat: {chat_url}")
+            ctx.dbg(json.dumps(body, indent=2))
+            started_at = time.time()
+            async with aiohttp.ClientSession() as session, session.post(
+                chat_url,
+                headers=headers,
+                data=json.dumps(body),
+                timeout=aiohttp.ClientTimeout(total=self.timeout),
+            ) as response:
+                # Example Response
+                # {
+                #   "created": 1768451303,
+                #   "data": [
+                #     {
+                #       "url": "https://mfile.z.ai/1768451374203-b334959408a643a8a6c74eb104746dcb.png?ufileattname=202601151228236805d575507d4570_watermark.png"
+                #     }
+                #   ],
+                #   "id": "202601151228236805d575507d4570",
+                #   "request_id": "202601151228236805d575507d4570",
+                #   "usage": {
+                #     "tokens": 0,
+                #     "price": 0,
+                #     "cost": 0.0,
+                #     "duration": 71
+                #   },
+                #   "timestamp": 1768451374519,
+                #   "model": "GLM-Image"
+                # }
+
+                response_json = await self.response_json(response)
+                duration = int(time.time() - started_at)
+                usage = response_json.get("usage", {})
+                if context is not None:
+                    context["providerResponse"] = response_json
+                    if "cost" in usage:
+                        context["cost"] = usage.get("cost")
+
+                images = []
+                for image in response_json.get("data", []):
+                    url = image.get("url")
+                    if not url:
+                        continue
+                    # download url with aiohttp
+                    async with session.get(url) as image_response:
+                        headers = image_response.headers
+                        # get filename from Content-Disposition
+                        # attachment; filename="202601151228236805d575507d4570_watermark.png"
+                        mime_type = headers.get("Content-Type") or "image/png"
+                        disposition = headers.get("Content-Disposition")
+                        if disposition:
+                            start = disposition.index('filename="') + len('filename="')
+                            end = disposition.index('"', start)
+                            filename = disposition[start:end]
+                        else:
+                            ext = mime_type.split("/")[1]
+                            filename = f"{body['model'].lower()}-{response_json.get('id', int(started_at))}.{ext}"
+                        image_bytes = await image_response.read()
+
+                        info = {
+                            "prompt": body["prompt"],
+                            "type": mime_type,
+                            "width": int(size.split("x")[0]),
+                            "height": int(size.split("x")[1]),
+                            "duration": duration,
+                        }
+                        info.update(usage)
+                        cache_url, info = ctx.save_image_to_cache(
+                            image_bytes, filename, image_info=info, ignore_info=True
+                        )
+
+                    images.append(
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": cache_url,
+                            },
+                        }
+                    )
+
+                chat_response = {
+                    "choices": [{"message": {"role": "assistant", "content": self.default_content, "images": images}}],
+                    "created": int(time.time()),
+                    "usage": {
+                        "prompt_tokens": 0,
+                        "completion_tokens": 1_000_000,  # Price per image is 0.015, so 1M token is 0.015
+                    },
+                }
+                if "cost" in usage:
+                    chat_response["cost"] = usage["cost"]
+                return ctx.log_json(chat_response)
+
+    ctx.add_provider(ZaiGenerator)

llms/llms.json

@@ -16,7 +16,7 @@
             "User-Agent": "llmspy.org/3.0"
         },
         "text": {
-            "model": "kimi-k2",
+            "model": "Kimi K2 Instruct",
             "messages": [
                 {
                     "role": "user",
@@ -223,7 +223,13 @@
         },
         "zai-coding-plan": {
             "enabled": true,
-            "temperature": 0.7
+            "temperature": 0.7,
+            "modalities": {
+                "image": {
+                    "name": "Z.ai Image",
+                    "npm": "zai/image"
+                }
+            }
         },
         "minimax": {
             "enabled": true,
@@ -314,7 +320,13 @@
         },
         "zai": {
             "enabled": true,
-            "temperature": 0.7
+            "temperature": 0.7,
+            "modalities": {
+                "image": {
+                    "name": "Z.ai Image",
+                    "npm": "zai/image"
+                }
+            }
         },
         "mistral": {
             "enabled": true,

llms/main.py

@@ -41,7 +41,7 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.5"
+VERSION = "3.0.7"
 _ROOT = None
 DEBUG = os.getenv("DEBUG") == "1"
 MOCK = os.getenv("MOCK") == "1"
@@ -757,6 +757,12 @@ def chat_to_username(chat):
     return None
 
 
+def chat_to_aspect_ratio(chat):
+    if "image_config" in chat and "aspect_ratio" in chat["image_config"]:
+        return chat["image_config"]["aspect_ratio"]
+    return None
+
+
 def last_user_prompt(chat):
     prompt = ""
     if "messages" in chat:
@@ -1829,7 +1835,10 @@ def print_status():
 
 
 def home_llms_path(filename):
-    return f"{os.getenv('HOME')}/.llms/{filename}"
+    home_dir = os.getenv("LLMS_HOME", os.path.join(os.getenv("HOME"), ".llms"))
+    relative_path = os.path.join(home_dir, filename)
+    # return resolved full absolute path
+    return os.path.abspath(os.path.normpath(relative_path))
 
 
 def get_cache_path(path=""):
@@ -2536,8 +2545,8 @@ class ExtensionContext:
     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_image_to_cache(self, base64_data, filename, image_info, ignore_info=False):
+        return save_image_to_cache(base64_data, filename, image_info, ignore_info=ignore_info)
 
     def save_bytes_to_cache(self, bytes_data, filename, file_info):
         return save_bytes_to_cache(bytes_data, filename, file_info)
@@ -2689,6 +2698,11 @@ class ExtensionContext:
     def get_user_path(self, username=None):
         return self.app.get_user_path(username)
 
+    def context_to_username(self, context):
+        if context and "request" in context:
+            return self.get_username(context["request"])
+        return None
+
     def should_cancel_thread(self, context):
         return should_cancel_thread(context)
 
@@ -2701,9 +2715,12 @@ class ExtensionContext:
     def create_chat_with_tools(self, chat, use_tools="all"):
         return self.app.create_chat_with_tools(chat, use_tools)
 
+    def chat_to_aspect_ratio(self, chat):
+        return chat_to_aspect_ratio(chat)
+
 
 def get_extensions_path():
-    return os.getenv("LLMS_EXTENSIONS_DIR", os.path.join(Path.home(), ".llms", "extensions"))
+    return os.getenv("LLMS_EXTENSIONS_DIR", home_llms_path("extensions"))
 
 
 def get_disabled_extensions():
@@ -2731,6 +2748,11 @@ def get_extensions_dirs():
     disabled_extensions = get_disabled_extensions()
 
     builtin_extensions_dir = _ROOT / "extensions"
+    if not os.path.exists(builtin_extensions_dir):
+        # look for local ./extensions dir from script
+        builtin_extensions_dir = os.path.join(os.path.dirname(__file__), "extensions")
+
+    _dbg(f"Loading extensions from {builtin_extensions_dir}")
     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)):
@@ -3463,8 +3485,10 @@ def main():
                     cache_root = Path(get_cache_path())
                     requested_path = Path(info_path).resolve()
                     if not str(requested_path).startswith(str(cache_root)):
+                        _dbg(f"Forbidden: {requested_path} is not in {cache_root}")
                         return web.Response(text="403: Forbidden", status=403)
-                except Exception:
+                except Exception as e:
+                    _err(f"Forbidden: {requested_path} is not in {cache_root}", e)
                     return web.Response(text="403: Forbidden", status=403)
 
                 with open(info_path) as f:
@@ -3479,8 +3503,10 @@ def main():
                 cache_root = Path(get_cache_path())
                 requested_path = Path(full_path).resolve()
                 if not str(requested_path).startswith(str(cache_root)):
+                    _dbg(f"Forbidden: {requested_path} is not in {cache_root}")
                     return web.Response(text="403: Forbidden", status=403)
             except Exception:
+                _err(f"Forbidden: {requested_path} is not in {cache_root}", e)
                 return web.Response(text="403: Forbidden", status=403)
 
             mimetype = get_file_mime_type(full_path)

llms/providers-extra.json

@@ -352,5 +352,43 @@
                 }
             }
         }
+    },
+    "zai": {
+        "models": {
+            "glm-image": {
+                "name": "GLM-Image",
+                "modalities": {
+                    "input": [
+                        "text"
+                    ],
+                    "output": [
+                        "image"
+                    ]
+                },
+                "cost": {
+                    "input": 0,
+                    "output": 0.015
+                }
+            }
+        }
+    },
+    "zai-coding-plan": {
+        "models": {
+            "glm-image": {
+                "name": "GLM-Image",
+                "modalities": {
+                    "input": [
+                        "text"
+                    ],
+                    "output": [
+                        "image"
+                    ]
+                },
+                "cost": {
+                    "input": 0,
+                    "output": 0.015
+                }
+            }
+        }
     }
 }