llms-py 3.0.0b4__tar.gz → 3.0.0b6__tar.gz

{llms_py-3.0.0b4/llms_py.egg-info → llms_py-3.0.0b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llms-py
-Version: 3.0.0b4
+Version: 3.0.0b6
 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.0b4 → llms_py-3.0.0b6}/llms/main.py

@@ -11,6 +11,7 @@ import asyncio
 import base64
 import hashlib
 import importlib.util
+import inspect
 import json
 import mimetypes
 import os
@@ -26,6 +27,7 @@ from datetime import datetime
 from importlib import resources  # Py≥3.9  (pip install importlib_resources for 3.7/3.8)
 from io import BytesIO
 from pathlib import Path
+from typing import get_type_hints
 from urllib.parse import parse_qs, urlencode
 
 import aiohttp
@@ -38,7 +40,7 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.0b4"
+VERSION = "3.0.0b6"
 _ROOT = None
 DEBUG = True  # os.getenv("PYPI_SERVICESTACK") is not None
 MOCK = False
@@ -322,6 +324,35 @@ def convert_image_if_needed(image_bytes, mimetype="image/png"):
         return image_bytes, mimetype
 
 
+def function_to_tool_definition(func):
+    type_hints = get_type_hints(func)
+    signature = inspect.signature(func)
+    parameters = {"type": "object", "properties": {}, "required": []}
+
+    for name, param in signature.parameters.items():
+        param_type = type_hints.get(name, str)
+        param_type_name = "string"
+        if param_type == int:
+            param_type_name = "integer"
+        elif param_type == float:
+            param_type_name = "number"
+        elif param_type == bool:
+            param_type_name = "boolean"
+
+        parameters["properties"][name] = {"type": param_type_name}
+        if param.default == inspect.Parameter.empty:
+            parameters["required"].append(name)
+
+    return {
+        "type": "function",
+        "function": {
+            "name": func.__name__,
+            "description": func.__doc__ or "",
+            "parameters": parameters,
+        },
+    }
+
+
 async def process_chat(chat, provider_id=None):
     if not chat:
         raise Exception("No chat provided")
@@ -1034,8 +1065,74 @@ async def chat_completion(chat):
         provider = g_handlers[name]
         _log(f"provider: {name} {type(provider).__name__}")
         try:
-            response = await provider.chat(chat.copy())
-            return response
+            # Inject global tools if present
+            current_chat = chat.copy()
+            # 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(",")
+
+                if include_all_tools or len(only_tools) > 0:
+                    if "tools" not in current_chat:
+                        current_chat["tools"] = []
+
+                    existing_tools = {t["function"]["name"] for t in current_chat["tools"]}
+                    for tool_def in g_app.tool_definitions:
+                        name = tool_def["function"]["name"]
+                        if name not in existing_tools and (include_all_tools or name in only_tools):
+                            current_chat["tools"].append(tool_def)
+
+            # Tool execution loop
+            max_iterations = 5
+            tool_history = []
+            for _ in range(max_iterations):
+                response = await provider.chat(current_chat)
+
+                # Check for tool_calls in the response
+                choice = response.get("choices", [])[0] if response.get("choices") else {}
+                message = choice.get("message", {})
+                tool_calls = message.get("tool_calls")
+
+                if tool_calls:
+                    # Append the assistant's message with tool calls to history
+                    if "messages" not in current_chat:
+                        current_chat["messages"] = []
+                    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}"
+
+                        # Append tool result to history
+                        tool_msg = {"role": "tool", "tool_call_id": tool_call["id"], "content": str(tool_result)}
+                        current_chat["messages"].append(tool_msg)
+                        tool_history.append(tool_msg)
+
+                    # Continue loop to send tool results back to LLM
+                    continue
+
+                # If no tool calls, return the response
+                if tool_history:
+                    response["tool_history"] = tool_history
+                return response
+
         except Exception as e:
             if first_exception is None:
                 first_exception = e
@@ -1121,15 +1218,23 @@ 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)
+
+        # 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)
         else:
             msg = response["choices"][0]["message"]
-            if "answer" in msg:
-                answer = msg["content"]
-                print(answer)
+            if "content" in msg or "answer" in msg:
+                print(msg["content"])
 
             generated_files = []
             for choice in response["choices"]:
@@ -1851,6 +1956,9 @@ class AppExtensions:
         self.chat_response_filters = []
         self.server_add_get = []
         self.server_add_post = []
+        self.server_add_post = []
+        self.tools = {}
+        self.tool_definitions = []
         self.all_providers = [
             OpenAiCompatible,
             MistralProvider,
@@ -1982,6 +2090,15 @@ class ExtensionContext:
             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)
+
+        name = tool_def["function"]["name"]
+        self.log(f"Registered tool: {name}")
+        self.app.tools[name] = func
+        self.app.tool_definitions.append(tool_def)
+
 
 def load_builtin_extensions():
     providers_path = _ROOT / "providers"
@@ -2011,7 +2128,7 @@ def load_builtin_extensions():
 
 
 def get_extensions_path():
-    return os.path.join(Path.home(), ".llms", "extensions")
+    return os.environ.get("LLMS_EXTENSIONS_DIR", os.path.join(Path.home(), ".llms", "extensions"))
 
 
 def init_extensions(parser):
@@ -2336,9 +2453,29 @@ def main():
                 requirements_path = os.path.join(target_path, "requirements.txt")
                 if os.path.exists(requirements_path):
                     print(f"Installing dependencies from {requirements_path}...")
-                    subprocess.run(
-                        [sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], cwd=target_path, check=True
-                    )
+
+                    # Check if uv is installed
+                    has_uv = False
+                    try:
+                        subprocess.run(
+                            ["uv", "--version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True
+                        )
+                        has_uv = True
+                    except (subprocess.CalledProcessError, FileNotFoundError):
+                        pass
+
+                    if has_uv:
+                        subprocess.run(
+                            ["uv", "pip", "install", "-p", sys.executable, "-r", "requirements.txt"],
+                            cwd=target_path,
+                            check=True,
+                        )
+                    else:
+                        subprocess.run(
+                            [sys.executable, "-m", "pip", "install", "-r", "requirements.txt"],
+                            cwd=target_path,
+                            check=True,
+                        )
                     print("Dependencies installed successfully.")
 
                 print(f"Extension {target_name} installed successfully.")
@@ -2569,9 +2706,7 @@ def main():
                 chat = await request.json()
 
                 # Apply pre-chat filters
-                context = {"request": request}
-                # Apply pre-chat filters
-                context = {"request": request}
+                context = {"request": request, "chat": chat}
                 for filter_func in g_app.chat_request_filters:
                     chat = await filter_func(chat, context)
 
@@ -2588,16 +2723,6 @@ def main():
 
         app.router.add_post("/v1/chat/completions", chat_handler)
 
-        async def extensions_handler(request):
-            return web.json_response(g_app.ui_extensions)
-
-        app.router.add_get("/ext", extensions_handler)
-
-        async def models_handler(request):
-            return web.json_response(get_models())
-
-        app.router.add_get("/models/list", models_handler)
-
         async def active_models_handler(request):
             return web.json_response(get_active_models())
 
@@ -2731,6 +2856,16 @@ def main():
 
         app.router.add_post("/upload", upload_handler)
 
+        async def extensions_handler(request):
+            return web.json_response(g_app.ui_extensions)
+
+        app.router.add_get("/ext", extensions_handler)
+
+        async def tools_handler(request):
+            return web.json_response(g_app.tool_definitions)
+
+        app.router.add_get("/ext/tools", tools_handler)
+
         async def cache_handler(request):
             path = request.match_info["tail"]
             full_path = get_cache_path(path)

{llms_py-3.0.0b4 → llms_py-3.0.0b6}/llms/providers-extra.json

@@ -1,4 +1,36 @@
 {
+    "minimax": {
+        "models": {
+            "MiniMax-M2.1": {
+                "id": "MiniMax-M2.1",
+                "name": "MiniMax M2.1",
+                "family": "minimax",
+                "attachment": false,
+                "reasoning": true,
+                "tool_call": true,
+                "temperature": true,
+                "release_date": "2025-12-23",
+                "last_updated": "2025-12-23",
+                "modalities": {
+                    "input": [
+                        "text"
+                    ],
+                    "output": [
+                        "text"
+                    ]
+                },
+                "open_weights": true,
+                "cost": {
+                    "input": 0.3,
+                    "output": 1.2
+                },
+                "limit": {
+                    "context": 204800,
+                    "output": 128000
+                }
+            }
+        }
+    },
     "openrouter": {
         "models": {
             "google/gemini-2.5-flash-image": {