llms-py 3.0.6__tar.gz → 3.0.8__tar.gz

{llms_py-3.0.6/llms_py.egg-info → llms_py-3.0.8}/PKG-INFO

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

{llms_py-3.0.6 → llms_py-3.0.8}/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_py-3.0.6 → llms_py-3.0.8}/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_py-3.0.6 → llms_py-3.0.8}/llms/extensions/app/ui/Recents.mjs

@@ -67,7 +67,7 @@ const RecentResults = {
 
         const normalized = (s) => (s || '').toString().toLowerCase()
         const replaceChars = new Set('<>`*|#'.split(''))
-        const clean = s => [...s].map(c => replaceChars.has(c) ? ' ' : c).join('')
+        const clean = s => [...(s || '')].map(c => replaceChars.has(c) ? ' ' : c).join('')
 
         const loadMore = async (reset = false) => {
             if (reset) {

{llms_py-3.0.6 → llms_py-3.0.8}/llms/extensions/app/ui/threadStore.mjs

@@ -139,10 +139,11 @@ async function updateThread(threadId, updates) {
     }
 }
 
-async function deleteMessageFromThread(threadId, messageId) {
+async function deleteMessageFromThread(threadId, timestamp) {
     const thread = await getThread(threadId)
     if (!thread) throw new Error('Thread not found')
-    const updatedMessages = thread.messages.filter(m => m.id !== messageId)
+    const updatedMessages = thread.messages.filter(m => m.timestamp !== timestamp)
+    console.log('deleteMessageFromThread', threadId, timestamp, updatedMessages)
     await updateThread(threadId, { messages: updatedMessages })
 }
 
@@ -150,7 +151,7 @@ async function updateMessageInThread(threadId, messageId, updates) {
     const thread = await getThread(threadId)
     if (!thread) throw new Error('Thread not found')
 
-    const messageIndex = thread.messages.findIndex(m => m.id === messageId)
+    const messageIndex = thread.messages.findIndex(m => m.timestamp === messageId)
     if (messageIndex === -1) throw new Error('Message not found')
 
     const updatedMessages = [...thread.messages]

{llms_py-3.0.6 → llms_py-3.0.8}/llms/extensions/core_tools/__init__.py

@@ -538,12 +538,13 @@ def get_current_time(tz_name: Optional[str] = None) -> str:
 def install(ctx):
     global g_ctx
     g_ctx = ctx
+    group = "core_tools"
     # Examples of registering tools using automatic definition generation
-    ctx.register_tool(memory_read)
-    ctx.register_tool(memory_write)
+    ctx.register_tool(memory_read, group=group)
+    ctx.register_tool(memory_write, group=group)
     # ctx.register_tool(semantic_search) # TODO: implement
-    ctx.register_tool(read_file)
-    ctx.register_tool(write_file)
+    ctx.register_tool(read_file, group=group)
+    ctx.register_tool(write_file, group=group)
     ctx.register_tool(
         edit_file,
         {
@@ -562,15 +563,16 @@ def install(ctx):
                 },
             },
         },
+        group=group,
     )
-    ctx.register_tool(list_directory)
-    ctx.register_tool(glob_paths)
-    ctx.register_tool(calc)
-    ctx.register_tool(run_python)
-    ctx.register_tool(run_typescript)
-    ctx.register_tool(run_javascript)
-    ctx.register_tool(run_csharp)
-    ctx.register_tool(get_current_time)
+    ctx.register_tool(list_directory, group=group)
+    ctx.register_tool(glob_paths, group=group)
+    ctx.register_tool(calc, group=group)
+    ctx.register_tool(run_python, group=group)
+    ctx.register_tool(run_typescript, group=group)
+    ctx.register_tool(run_javascript, group=group)
+    ctx.register_tool(run_csharp, group=group)
+    ctx.register_tool(get_current_time, group=group)
 
     def exec_language(language: str, code: str) -> Dict[str, Any]:
         if language == "python":

{llms_py-3.0.6 → llms_py-3.0.8}/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_py-3.0.6 → llms_py-3.0.8}/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_py-3.0.6 → llms_py-3.0.8}/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_py-3.0.6 → llms_py-3.0.8}/llms/extensions/providers/google.py

@@ -471,9 +471,9 @@ def install_google(ctx):
                 if "usageMetadata" in obj:
                     usage = obj["usageMetadata"]
                     response["usage"] = {
-                        "completion_tokens": usage["candidatesTokenCount"],
-                        "total_tokens": usage["totalTokenCount"],
-                        "prompt_tokens": usage["promptTokenCount"],
+                        "completion_tokens": usage.get("candidatesTokenCount", 0),
+                        "total_tokens": usage.get("totalTokenCount", 0),
+                        "prompt_tokens": usage.get("promptTokenCount", 0),
                     }
 
                 return ctx.log_json(self.to_response(response, chat, started_at))

{llms_py-3.0.6 → llms_py-3.0.8}/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_py-3.0.6 → llms_py-3.0.8}/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_py-3.0.8/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_py-3.0.8/llms/extensions/tools/__init__.py

@@ -0,0 +1,144 @@
+import json
+
+from aiohttp import web
+
+
+def install(ctx):
+    async def tools_handler(request):
+        return web.json_response(
+            {
+                "groups": ctx.app.tool_groups,
+                "definitions": ctx.app.tool_definitions,
+            }
+        )
+
+    ctx.add_get("", tools_handler)
+
+    def prop_def_types(prop_def):
+        prop_type = prop_def.get("type")
+        if not prop_type:
+            any_of = prop_def.get("anyOf")
+            if any_of:
+                return [item.get("type") for item in any_of]
+            else:
+                return []
+        return [prop_type]
+
+    def tool_prop_value(value, prop_def):
+        """
+        Convert a value to the specified type.
+        types: string, number, integer, boolean, object, array, null
+        example prop_def = [
+            {
+                "type": "string"
+            },
+            {
+                "default": "name",
+                "type": "string",
+                "enum": ["name", "size"]
+            },
+            {
+                "default": [],
+                "type": "array",
+                "items": {
+                    "type": "string"
+                }
+            },
+            {
+                "anyOf": [
+                    {
+                        "type": "string"
+                    },
+                    {
+                        "type": "null"
+                    }
+                ],
+                "default": null,
+            },
+        ]
+        """
+        if value is None:
+            default = prop_def.get("default")
+            if default is not None:
+                default = tool_prop_value(default, prop_def)
+            return default
+
+        prop_types = prop_def_types(prop_def)
+        if "integer" in prop_types:
+            return int(value)
+        elif "number" in prop_types:
+            return float(value)
+        elif "boolean" in prop_types:
+            return bool(value)
+        elif "object" in prop_types:
+            return value if isinstance(value, dict) else json.loads(value)
+        elif "array" in prop_types:
+            return value if isinstance(value, list) else value.split(",")
+        else:
+            enum = prop_def.get("enum")
+            if enum and value not in enum:
+                raise Exception(f"'{value}' is not in {enum}")
+            return value
+
+    async def exec_handler(request):
+        name = request.match_info.get("name")
+        args = await request.json()
+
+        tool_def = ctx.get_tool_definition(name)
+        if not tool_def:
+            raise Exception(f"Tool '{name}' not found")
+
+        type = tool_def.get("type")
+        if type != "function":
+            raise Exception(f"Tool '{name}' of type '{type}' is not supported")
+
+        ctx.dbg(f"Executing tool '{name}' with args:\n{json.dumps(args, indent=2)}")
+        function_args = {}
+        parameters = tool_def.get("function", {}).get("parameters")
+        if parameters:
+            properties = parameters.get("properties")
+            required_props = parameters.get("required", [])
+            if properties:
+                for prop_name, prop_def in properties.items():
+                    prop_title = prop_def.get("title", prop_name)
+                    prop_types = prop_def_types(prop_def)
+                    value = None
+                    if prop_name in args:
+                        value = tool_prop_value(args[prop_name], prop_def)
+                    elif prop_name in required_props:
+                        if "null" in prop_types:
+                            value = None
+                        elif "default" in prop_def:
+                            value = tool_prop_value(prop_def["default"], prop_def)
+                        else:
+                            raise Exception(f"Missing required parameter '{prop_title}' for tool '{name}'")
+                    if value is not None or "null" in prop_types:
+                        function_args[prop_name] = value
+            else:
+                ctx.dbg(f"tool '{name}' has no properties:\n{json.dumps(tool_def, indent=2)}")
+        else:
+            ctx.dbg(f"tool '{name}' has no parameters:\n{json.dumps(tool_def, indent=2)}")
+
+        try:
+            text, resources = await ctx.exec_tool(name, function_args)
+
+            results = []
+            if text:
+                results.append(
+                    {
+                        "type": "text",
+                        "text": text,
+                    }
+                )
+            if resources:
+                results.extend(resources)
+
+            return web.json_response(results)
+        except Exception as e:
+            ctx.err(f"Failed to execute tool '{name}' with args:\n{json.dumps(function_args, indent=2)}", e)
+            raise e
+
+    ctx.add_post("exec/{name}", exec_handler)
+
+
+__install__ = install