llms-py 3.0.12__tar.gz → 3.0.14__tar.gz

{llms_py-3.0.12 → llms_py-3.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llms-py
-Version: 3.0.12
+Version: 3.0.14
 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.14/llms/extensions/computer_use/__init__.py

@@ -0,0 +1,27 @@
+"""
+Anthropic's Computer Use Tools
+https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo
+"""
+
+import os
+
+from .bash import open, run_bash
+from .computer import computer
+from .edit import edit
+from .platform import get_display_num, get_screen_resolution
+
+width, height = get_screen_resolution()
+# set enviroment variables
+os.environ["WIDTH"] = str(width)
+os.environ["HEIGHT"] = str(height)
+os.environ["DISPLAY_NUM"] = str(get_display_num())
+
+
+def install(ctx):
+    ctx.register_tool(run_bash, group="computer_use")
+    ctx.register_tool(open, group="computer_use")
+    ctx.register_tool(edit, group="computer_use")
+    ctx.register_tool(computer, group="computer_use")
+
+
+__install__ = install

llms_py-3.0.14/llms/extensions/computer_use/base.py

@@ -0,0 +1,80 @@
+from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass, fields, replace
+from typing import Any
+
+
+class BaseTool(metaclass=ABCMeta):
+    """Abstract base class"""
+
+    @abstractmethod
+    def __call__(self, **kwargs) -> Any:
+        """Executes the tool with the given arguments."""
+        ...
+
+    @abstractmethod
+    def to_params(
+        self,
+    ) -> Any:
+        raise NotImplementedError
+
+
+@dataclass(kw_only=True, frozen=True)
+class ToolResult:
+    """Represents the result of a tool execution."""
+
+    output: str | None = None
+    error: str | None = None
+    base64_image: str | None = None
+    system: str | None = None
+
+    def __bool__(self):
+        return any(getattr(self, field.name) for field in fields(self))
+
+    def __add__(self, other: "ToolResult"):
+        def combine_fields(field: str | None, other_field: str | None, concatenate: bool = True):
+            if field and other_field:
+                if concatenate:
+                    return field + other_field
+                raise ValueError("Cannot combine tool results")
+            return field or other_field
+
+        return ToolResult(
+            output=combine_fields(self.output, other.output),
+            error=combine_fields(self.error, other.error),
+            base64_image=combine_fields(self.base64_image, other.base64_image, False),
+            system=combine_fields(self.system, other.system),
+        )
+
+    def replace(self, **kwargs):
+        """Returns a new ToolResult with the given fields replaced."""
+        return replace(self, **kwargs)
+
+    def to_tool_results(self) -> list[dict[str, Any]]:
+        text = ""
+        if self.output:
+            text += f"{self.output}\n"
+        if self.error:
+            text += f"stderr: {self.error}\n"
+        if self.system:
+            text += f"system: {self.system}\n"
+        ret = []
+        if text:
+            ret.append({"type": "text", "text": text})
+        if self.base64_image:
+            ret.append({"type": "image", "format": "png", "data": self.base64_image})
+        return ret
+
+
+class CLIResult(ToolResult):
+    """A ToolResult that can be rendered as a CLI output."""
+
+
+class ToolFailure(ToolResult):
+    """A ToolResult that represents a failure."""
+
+
+class ToolError(Exception):
+    """Raised when a tool encounters an error."""
+
+    def __init__(self, message):
+        self.message = message

llms_py-3.0.14/llms/extensions/computer_use/bash.py

@@ -0,0 +1,185 @@
+import asyncio
+import os
+import sys
+from typing import Annotated, Any, Literal
+
+from .base import BaseTool, CLIResult, ToolError, ToolResult
+
+
+class _BashSession:
+    """A session of a bash shell."""
+
+    _started: bool
+    _process: asyncio.subprocess.Process
+
+    command: str = "/bin/bash"
+    _output_delay: float = 0.2  # seconds
+    _timeout: float = 120.0  # seconds
+    _sentinel: str = "<<exit>>"
+
+    def __init__(self):
+        self._started = False
+        self._timed_out = False
+
+    async def start(self):
+        if self._started:
+            return
+
+        self._process = await asyncio.create_subprocess_shell(
+            self.command,
+            preexec_fn=os.setsid,
+            shell=True,
+            bufsize=0,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        self._started = True
+
+    def stop(self):
+        """Terminate the bash shell."""
+        if not self._started:
+            raise ToolError("Session has not started.")
+        if self._process.returncode is not None:
+            return
+        self._process.terminate()
+
+    async def run(self, command: str):
+        """Execute a command in the bash shell."""
+        if not self._started:
+            raise ToolError("Session has not started.")
+        if self._process.returncode is not None:
+            return ToolResult(
+                system="tool must be restarted",
+                error=f"bash has exited with returncode {self._process.returncode}",
+            )
+        if self._timed_out:
+            raise ToolError(
+                f"timed out: bash has not returned in {self._timeout} seconds and must be restarted",
+            )
+
+        # we know these are not None because we created the process with PIPEs
+        assert self._process.stdin
+        assert self._process.stdout
+        assert self._process.stderr
+
+        # send command to the process
+        self._process.stdin.write(command.encode() + f"; echo '{self._sentinel}'\n".encode())
+        await self._process.stdin.drain()
+
+        # read output from the process, until the sentinel is found
+        try:
+            async with asyncio.timeout(self._timeout):
+                while True:
+                    await asyncio.sleep(self._output_delay)
+                    # if we read directly from stdout/stderr, it will wait forever for
+                    # EOF. use the StreamReader buffer directly instead.
+                    output = self._process.stdout._buffer.decode()  # pyright: ignore[reportAttributeAccessIssue]
+                    if self._sentinel in output:
+                        # strip the sentinel and break
+                        output = output[: output.index(self._sentinel)]
+                        break
+        except asyncio.TimeoutError:
+            self._timed_out = True
+            raise ToolError(
+                f"timed out: bash has not returned in {self._timeout} seconds and must be restarted",
+            ) from None
+
+        if output.endswith("\n"):
+            output = output[:-1]
+
+        error = self._process.stderr._buffer.decode()  # pyright: ignore[reportAttributeAccessIssue]
+        if error.endswith("\n"):
+            error = error[:-1]
+
+        # clear the buffers so that the next output can be read correctly
+        self._process.stdout._buffer.clear()  # pyright: ignore[reportAttributeAccessIssue]
+        self._process.stderr._buffer.clear()  # pyright: ignore[reportAttributeAccessIssue]
+
+        return CLIResult(output=output, error=error)
+
+
+class BashTool20250124(BaseTool):
+    """
+    A tool that allows the agent to run bash commands.
+    The tool parameters are defined by Anthropic and are not editable.
+    """
+
+    _session: _BashSession | None
+
+    api_type: Literal["bash_20250124"] = "bash_20250124"
+    name: Literal["bash"] = "bash"
+
+    def __init__(self):
+        self._session = None
+        super().__init__()
+
+    def to_params(self) -> Any:
+        return {
+            "type": self.api_type,
+            "name": self.name,
+        }
+
+    async def __call__(self, command: str | None = None, restart: bool = False, **kwargs):
+        if restart:
+            if self._session:
+                self._session.stop()
+            self._session = _BashSession()
+            await self._session.start()
+
+            return ToolResult(system="tool has been restarted.")
+
+        if self._session is None:
+            self._session = _BashSession()
+            await self._session.start()
+
+        if command is not None:
+            return await self._session.run(command)
+
+        raise ToolError("no command provided.")
+
+
+class BashTool20241022(BashTool20250124):
+    api_type: Literal["bash_20250124"] = "bash_20250124"  # pyright: ignore[reportIncompatibleVariableOverride]
+
+
+g_tool = None
+
+
+async def run_bash(
+    command: Annotated[str | None, "Command to run"],
+    restart: Annotated[bool, "Restart the bash session"] = False,
+) -> list[dict[str, Any]]:
+    """
+    A tool that allows the agent to run bash commands.
+    """
+    global g_tool
+    if g_tool is None:
+        g_tool = BashTool20241022()
+
+    result = await g_tool(command, restart)
+    if isinstance(result, Exception):
+        raise result
+    else:
+        return result.to_tool_results()
+
+
+async def open(target: Annotated[str, "URL or file path to open"]) -> list[dict[str, Any]]:
+    """
+    Open a URL or file using the appropriate system opener, uses `xdg-open` on Linux, `open` on macOS, and `start` on Windows.
+    """
+    target = target.strip()
+    if not target:
+        raise ValueError("No target specified")
+
+    platform = sys.platform
+
+    if platform == "darwin":
+        cmd = ["open", target]
+    elif platform == "win32":
+        cmd = ["cmd", "/c", "start", "", target]
+    else:  # Linux and other Unix-like
+        cmd = ["xdg-open", target]
+
+    return await run_bash(" ".join(cmd))