llms-py 3.0.13__py3-none-any.whl → 3.0.14__py3-none-any.whl

llms/extensions/computer_use/platform.py

@@ -0,0 +1,461 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from typing import Optional, Tuple
+
+
+def get_screen_resolution() -> Tuple[int, int]:
+    """
+    Get the current screen resolution (width, height).
+
+    Supports Linux (Wayland/Hyprland, X11), macOS, and Windows.
+    Returns the primary monitor's resolution.
+
+    Returns:
+        Tuple[int, int]: (width, height) in pixels
+
+    Raises:
+        RuntimeError: If unable to determine screen resolution
+    """
+    if sys.platform == "linux":
+        return _get_linux_resolution()
+    elif sys.platform == "darwin":
+        return _get_macos_resolution()
+    elif sys.platform == "win32":
+        return _get_windows_resolution()
+    else:
+        raise RuntimeError(f"Unsupported platform: {sys.platform}")
+
+
+def get_display_num() -> int:
+    """
+    Get the display number for the current session.
+
+    On Linux (X11): Returns the X display number from $DISPLAY (e.g., :0 -> 0)
+    On Linux (Wayland): Returns the Wayland display number from $WAYLAND_DISPLAY (e.g., wayland-0 -> 0)
+    On macOS: Returns the display ID of the main display
+    On Windows: Returns the index of the primary monitor (typically 0)
+
+    Returns:
+        int: The display number
+
+    Raises:
+        RuntimeError: If unable to determine display number
+    """
+    if sys.platform == "linux":
+        return _get_linux_display_num()
+    elif sys.platform == "darwin":
+        return _get_macos_display_num()
+    elif sys.platform == "win32":
+        return _get_windows_display_num()
+    else:
+        raise RuntimeError(f"Unsupported platform: {sys.platform}")
+
+
+def _get_linux_display_num() -> int:
+    """Get display number on Linux (X11 or Wayland)."""
+
+    # Try X11 DISPLAY environment variable first
+    display = os.environ.get("DISPLAY")
+    if display:
+        # DISPLAY format: [hostname]:displaynumber[.screennumber]
+        # Examples: :0, :1, localhost:0, :0.0
+        match = re.search(r":(\d+)", display)
+        if match:
+            return int(match.group(1))
+
+    # Try Wayland display
+    wayland_display = os.environ.get("WAYLAND_DISPLAY")
+    if wayland_display:
+        # WAYLAND_DISPLAY format: wayland-N or just a socket name
+        # Examples: wayland-0, wayland-1
+        match = re.search(r"wayland-(\d+)", wayland_display)
+        if match:
+            return int(match.group(1))
+        # If it's just "wayland-0" style, try to extract number
+        match = re.search(r"(\d+)", wayland_display)
+        if match:
+            return int(match.group(1))
+        # Default to 0 if we have a Wayland display but can't parse number
+        return 0
+
+    # Try Hyprland-specific: get focused monitor ID
+    if shutil.which("hyprctl"):
+        try:
+            result = subprocess.run(["hyprctl", "monitors", "-j"], capture_output=True, text=True, timeout=5)
+            if result.returncode == 0:
+                import json
+
+                monitors = json.loads(result.stdout)
+                if monitors:
+                    # Return focused monitor ID or first monitor's ID
+                    monitor = next((m for m in monitors if m.get("focused")), monitors[0])
+                    return monitor.get("id", 0)
+        except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError):
+            pass
+
+    raise RuntimeError("Could not determine display number. Neither DISPLAY nor WAYLAND_DISPLAY is set.")
+
+
+def _get_macos_display_num() -> int:
+    """Get display number on macOS."""
+
+    # Try using CoreGraphics via ctypes
+    try:
+        import ctypes
+        import ctypes.util
+
+        cg_path = ctypes.util.find_library("CoreGraphics")
+        if cg_path:
+            cg = ctypes.CDLL(cg_path)
+            # CGMainDisplayID returns the display ID of the main display
+            cg.CGMainDisplayID.restype = ctypes.c_uint32
+            return cg.CGMainDisplayID()
+    except (OSError, AttributeError):
+        pass
+
+    # Try using AppKit
+    try:
+        from AppKit import NSScreen
+
+        main_screen = NSScreen.mainScreen()
+        # Get the display ID from the screen's deviceDescription
+        device_desc = main_screen.deviceDescription()
+        display_id = device_desc.get("NSScreenNumber", 0)
+        return int(display_id)
+    except ImportError:
+        pass
+
+    # Try using system_profiler
+    try:
+        result = subprocess.run(["system_profiler", "SPDisplaysDataType"], capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            # Look for Display ID or just return 0 for main display
+            match = re.search(r"Display ID:\s*(\d+)", result.stdout)
+            if match:
+                return int(match.group(1))
+            # If we found display info but no ID, assume main display is 0
+            if "Resolution:" in result.stdout:
+                return 0
+    except subprocess.TimeoutExpired:
+        pass
+
+    # Default to 0 for main display
+    return 0
+
+
+def _get_windows_display_num() -> int:
+    """Get display number on Windows."""
+
+    # Method 1: Try ctypes to enumerate monitors
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        user32 = ctypes.windll.user32
+
+        # Get the primary monitor handle
+        # MonitorFromPoint with MONITOR_DEFAULTTOPRIMARY (0x00000001)
+        primary_monitor = user32.MonitorFromPoint(
+            ctypes.wintypes.POINT(0, 0),
+            1,  # MONITOR_DEFAULTTOPRIMARY
+        )
+
+        # Enumerate all monitors to find the index of the primary
+        monitors = []
+
+        def callback(hMonitor, hdcMonitor, lprcMonitor, dwData):
+            monitors.append(hMonitor)
+            return True
+
+        MONITORENUMPROC = ctypes.WINFUNCTYPE(
+            ctypes.c_bool,
+            ctypes.wintypes.HMONITOR,
+            ctypes.wintypes.HDC,
+            ctypes.POINTER(ctypes.wintypes.RECT),
+            ctypes.wintypes.LPARAM,
+        )
+
+        user32.EnumDisplayMonitors(None, None, MONITORENUMPROC(callback), 0)
+
+        # Find the index of the primary monitor
+        for i, mon in enumerate(monitors):
+            if mon == primary_monitor:
+                return i
+
+        # Primary not found in list, return 0
+        return 0
+
+    except (AttributeError, OSError):
+        pass
+
+    # Method 2: Try win32api
+    try:
+        import win32api
+
+        # Get all monitors
+        monitors = win32api.EnumDisplayMonitors()
+        # Find primary (usually the first one, or check flags)
+        for i, (handle, dc, rect) in enumerate(monitors):
+            info = win32api.GetMonitorInfo(handle)
+            if info.get("Flags", 0) & 1:  # MONITORINFOF_PRIMARY
+                return i
+        return 0
+    except ImportError:
+        pass
+
+    # Method 3: PowerShell to get monitor index
+    try:
+        ps_script = """
+        Add-Type -AssemblyName System.Windows.Forms
+        $screens = [System.Windows.Forms.Screen]::AllScreens
+        for ($i = 0; $i -lt $screens.Count; $i++) {
+            if ($screens[$i].Primary) {
+                Write-Output $i
+                break
+            }
+        }
+        """
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", ps_script], capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            return int(result.stdout.strip())
+    except (subprocess.TimeoutExpired, FileNotFoundError, ValueError):
+        pass
+
+    # Default to 0 (primary monitor)
+    return 0
+
+
+def _get_linux_resolution() -> Tuple[int, int]:
+    """Get resolution on Linux, trying Wayland first, then X11."""
+
+    # Try Hyprland first
+    resolution = _try_hyprctl()
+    if resolution:
+        return resolution
+
+    # Try wlr-randr (generic Wayland)
+    resolution = _try_wlr_randr()
+    if resolution:
+        return resolution
+
+    # Try xrandr (X11)
+    resolution = _try_xrandr()
+    if resolution:
+        return resolution
+
+    # Try xdpyinfo (X11 fallback)
+    resolution = _try_xdpyinfo()
+    if resolution:
+        return resolution
+
+    raise RuntimeError("Could not determine screen resolution. No supported display server found.")
+
+
+def _try_hyprctl() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via hyprctl (Hyprland)."""
+    if not shutil.which("hyprctl"):
+        return None
+
+    try:
+        result = subprocess.run(["hyprctl", "monitors", "-j"], capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            import json
+
+            monitors = json.loads(result.stdout)
+            if monitors:
+                # Get the focused monitor or first one
+                monitor = next((m for m in monitors if m.get("focused")), monitors[0])
+                return (monitor["width"], monitor["height"])
+    except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError):
+        pass
+    return None
+
+
+def _try_wlr_randr() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via wlr-randr (Wayland)."""
+    if not shutil.which("wlr-randr"):
+        return None
+
+    try:
+        result = subprocess.run(["wlr-randr"], capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            # Parse output like: "  3840x2160 px, 60.000000 Hz (current)"
+            match = re.search(r"(\d+)x(\d+)\s+px.*current", result.stdout)
+            if match:
+                return (int(match.group(1)), int(match.group(2)))
+    except subprocess.TimeoutExpired:
+        pass
+    return None
+
+
+def _try_xrandr() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via xrandr (X11)."""
+    if not shutil.which("xrandr"):
+        return None
+
+    try:
+        result = subprocess.run(["xrandr", "--current"], capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            # Look for current resolution marked with *
+            match = re.search(r"(\d+)x(\d+).*\*", result.stdout)
+            if match:
+                return (int(match.group(1)), int(match.group(2)))
+    except subprocess.TimeoutExpired:
+        pass
+    return None
+
+
+def _try_xdpyinfo() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via xdpyinfo (X11)."""
+    if not shutil.which("xdpyinfo"):
+        return None
+
+    try:
+        result = subprocess.run(["xdpyinfo"], capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            match = re.search(r"dimensions:\s+(\d+)x(\d+)", result.stdout)
+            if match:
+                return (int(match.group(1)), int(match.group(2)))
+    except subprocess.TimeoutExpired:
+        pass
+    return None
+
+
+def _get_macos_resolution() -> Tuple[int, int]:
+    """Get resolution on macOS using system_profiler."""
+    try:
+        result = subprocess.run(["system_profiler", "SPDisplaysDataType"], capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            # Look for "Resolution: 2560 x 1440" or similar
+            match = re.search(r"Resolution:\s+(\d+)\s*x\s*(\d+)", result.stdout)
+            if match:
+                return (int(match.group(1)), int(match.group(2)))
+    except subprocess.TimeoutExpired:
+        pass
+
+    # Fallback: try using AppKit via Python (if available)
+    try:
+        from AppKit import NSScreen
+
+        frame = NSScreen.mainScreen().frame()
+        return (int(frame.size.width), int(frame.size.height))
+    except ImportError:
+        pass
+
+    raise RuntimeError("Could not determine screen resolution on macOS")
+
+
+def _get_windows_resolution() -> Tuple[int, int]:
+    """Get resolution on Windows."""
+
+    # Method 1: Try ctypes (no external dependencies)
+    resolution = _try_windows_ctypes()
+    if resolution:
+        return resolution
+
+    # Method 2: Try win32api (pywin32)
+    resolution = _try_windows_win32api()
+    if resolution:
+        return resolution
+
+    # Method 3: Try PowerShell
+    resolution = _try_windows_powershell()
+    if resolution:
+        return resolution
+
+    # Method 4: Try wmic (deprecated but still works on older systems)
+    resolution = _try_windows_wmic()
+    if resolution:
+        return resolution
+
+    raise RuntimeError("Could not determine screen resolution on Windows")
+
+
+def _try_windows_ctypes() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via ctypes (built-in)."""
+    try:
+        import ctypes
+
+        user32 = ctypes.windll.user32
+        user32.SetProcessDPIAware()  # Handle DPI scaling
+        width = user32.GetSystemMetrics(0)  # SM_CXSCREEN
+        height = user32.GetSystemMetrics(1)  # SM_CYSCREEN
+        if width > 0 and height > 0:
+            return (width, height)
+    except (AttributeError, OSError):
+        pass
+    return None
+
+
+def _try_windows_win32api() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via win32api (pywin32)."""
+    try:
+        import win32api
+
+        width = win32api.GetSystemMetrics(0)
+        height = win32api.GetSystemMetrics(1)
+        if width > 0 and height > 0:
+            return (width, height)
+    except ImportError:
+        pass
+    return None
+
+
+def _try_windows_powershell() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via PowerShell."""
+    try:
+        # Using Add-Type to access System.Windows.Forms
+        ps_script = """
+        Add-Type -AssemblyName System.Windows.Forms
+        $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+        "$($screen.Width)x$($screen.Height)"
+        """
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", ps_script], capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            match = re.match(r"(\d+)x(\d+)", result.stdout.strip())
+            if match:
+                return (int(match.group(1)), int(match.group(2)))
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass
+    return None
+
+
+def _try_windows_wmic() -> Optional[Tuple[int, int]]:
+    """Try getting resolution via wmic (legacy, but works on older Windows)."""
+    try:
+        result = subprocess.run(
+            ["wmic", "path", "Win32_VideoController", "get", "CurrentHorizontalResolution,CurrentVerticalResolution"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            lines = result.stdout.strip().split("\n")
+            for line in lines[1:]:  # Skip header
+                match = re.match(r"(\d+)\s+(\d+)", line.strip())
+                if match:
+                    return (int(match.group(1)), int(match.group(2)))
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass
+    return None
+
+
+if __name__ == "__main__":
+    try:
+        width, height = get_screen_resolution()
+        print(f"Screen resolution: {width}x{height}")
+
+        display_num = get_display_num()
+        print(f"Display number: {display_num}")
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)

llms/extensions/computer_use/run.py

@@ -0,0 +1,37 @@
+"""Utility to run shell commands asynchronously with a timeout."""
+
+import asyncio
+import contextlib
+
+TRUNCATED_MESSAGE: str = "<response clipped><NOTE>To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with `grep -n` in order to find the line numbers of what you are looking for.</NOTE>"
+MAX_RESPONSE_LEN: int = 16000
+
+
+def maybe_truncate(content: str, truncate_after: int | None = MAX_RESPONSE_LEN):
+    """Truncate content and append a notice if content exceeds the specified length."""
+    return (
+        content
+        if not truncate_after or len(content) <= truncate_after
+        else content[:truncate_after] + TRUNCATED_MESSAGE
+    )
+
+
+async def run(
+    cmd: str,
+    timeout: float | None = 120.0,  # seconds
+    truncate_after: int | None = MAX_RESPONSE_LEN,
+):
+    """Run a shell command asynchronously with a timeout."""
+    process = await asyncio.create_subprocess_shell(cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+
+    try:
+        stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
+        return (
+            process.returncode or 0,
+            maybe_truncate(stdout.decode(), truncate_after=truncate_after),
+            maybe_truncate(stderr.decode(), truncate_after=truncate_after),
+        )
+    except asyncio.TimeoutError as exc:
+        with contextlib.suppress(ProcessLookupError):
+            process.kill()
+        raise TimeoutError(f"Command '{cmd}' timed out after {timeout} seconds") from exc

llms/extensions/providers/anthropic.py

@@ -83,9 +83,10 @@ def install_anthropic(ctx):
 
                 content = message.get("content", "")
                 if isinstance(content, str):
-                    if anthropic_message["content"]:
-                        # If we have thinking, we must use blocks for text
-                        anthropic_message["content"].append({"type": "text", "text": content})
+                    if anthropic_message["content"] or message.get("tool_calls"):
+                        # If we have thinking or tools, we must use blocks for text
+                        if content:
+                            anthropic_message["content"].append({"type": "text", "text": content})
                     else:
                         anthropic_message["content"] = content
                 elif isinstance(content, list):
@@ -108,6 +109,24 @@ def install_anthropic(ctx):
                                         }
                                     )
 
+                # Handle tool_calls
+                if "tool_calls" in message and message["tool_calls"]:
+                    # specific check for content being a string and not empty, because we might have converted it above
+                    if isinstance(anthropic_message["content"], str):
+                        anthropic_message["content"] = []
+                        if content:
+                            anthropic_message["content"].append({"type": "text", "text": content})
+
+                    for tool_call in message["tool_calls"]:
+                        function = tool_call.get("function", {})
+                        tool_use = {
+                            "type": "tool_use",
+                            "id": tool_call.get("id"),
+                            "name": function.get("name"),
+                            "input": json.loads(function.get("arguments", "{}")),
+                        }
+                        anthropic_message["content"].append(tool_use)
+
                 anthropic_request["messages"].append(anthropic_message)
 
             # Handle max_tokens (required by Anthropic, uses max_tokens not max_completion_tokens)

llms/main.py

@@ -26,11 +26,24 @@ import sys
 import time
 import traceback
 from datetime import datetime
-from enum import IntEnum
+from enum import Enum, IntEnum
 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 Any, Callable, Dict, List, Optional, Tuple, Union, get_type_hints
+from typing import (
+    Annotated,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 from urllib.parse import parse_qs, urlencode, urljoin
 
 import aiohttp
@@ -43,7 +56,7 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.13"
+VERSION = "3.0.14"
 _ROOT = None
 DEBUG = os.getenv("DEBUG") == "1"
 MOCK = os.getenv("MOCK") == "1"
@@ -348,22 +361,75 @@ def to_content(result):
         return str(result)
 
 
+def get_literal_values(typ):
+    """Recursively extract values from Literal and Union types."""
+    origin = get_origin(typ)
+    if origin is Literal:
+        return list(get_args(typ))
+    elif origin is Union:
+        values = []
+        for arg in get_args(typ):
+            # Recurse for nested Unions or Literals
+            nested_values = get_literal_values(arg)
+            if nested_values:
+                for v in nested_values:
+                    if v not in values:
+                        values.append(v)
+        return values
+    return None
+
+
 def function_to_tool_definition(func):
-    type_hints = get_type_hints(func)
+    type_hints = get_type_hints(func, include_extras=True)
     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 is int:
+        enum_values = None
+        description = None
+
+        # Check for Annotated (for description)
+        if get_origin(param_type) is Annotated:
+            args = get_args(param_type)
+            param_type = args[0]
+            for arg in args[1:]:
+                if isinstance(arg, str):
+                    description = arg
+                    break
+
+        # Check for Enum
+        if inspect.isclass(param_type) and issubclass(param_type, Enum):
+            enum_values = [e.value for e in param_type]
+        else:
+            # Check for Literal / Union[Literal]
+            enum_values = get_literal_values(param_type)
+
+        if enum_values:
+            # Infer type from the first value
+            value_type = type(enum_values[0])
+            if value_type is int:
+                param_type_name = "integer"
+            elif value_type is float:
+                param_type_name = "number"
+            elif value_type is bool:
+                param_type_name = "boolean"
+
+        elif param_type is int:
             param_type_name = "integer"
         elif param_type is float:
             param_type_name = "number"
         elif param_type is bool:
             param_type_name = "boolean"
 
-        parameters["properties"][name] = {"type": param_type_name}
+        prop = {"type": param_type_name}
+        if description:
+            prop["description"] = description
+        if enum_values:
+            prop["enum"] = enum_values
+        parameters["properties"][name] = prop
+
         if param.default == inspect.Parameter.empty:
             parameters["required"].append(name)
 
@@ -371,7 +437,7 @@ def function_to_tool_definition(func):
         "type": "function",
         "function": {
             "name": func.__name__,
-            "description": func.__doc__ or "",
+            "description": (func.__doc__ or "").strip(),
             "parameters": parameters,
         },
     }
@@ -1585,6 +1651,9 @@ async def g_chat_completion(chat, context=None):
         if context is None:
             context = {"chat": chat, "tools": "all"}
 
+        if "request_id" not in context:
+            context["request_id"] = str(int(time.time() * 1000))
+
         # 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:
@@ -1736,7 +1805,9 @@ async def g_chat_completion(chat, context=None):
             continue
 
     # If we get here, all providers failed
-    raise first_exception
+    if first_exception:
+        raise first_exception
+    raise Exception("All providers failed")
 
 
 async def cli_chat(chat, tools=None, image=None, audio=None, file=None, args=None, raw=False):
@@ -2918,6 +2989,9 @@ class ExtensionContext:
     def add_index_footer(self, html: str):
         self.app.index_footers.append(html)
 
+    def get_home_path(self, name: str = "") -> str:
+        return home_llms_path(name)
+
     def get_config(self) -> Optional[Dict[str, Any]]:
         return g_config
 

llms/ui/ai.mjs

@@ -6,7 +6,7 @@ const headers = { 'Accept': 'application/json' }
 const prefsKey = 'llms.prefs'
 
 export const o = {
-    version: '3.0.13',
+    version: '3.0.14',
     base,
     prefsKey,
     welcome: 'Welcome to llms.py',