llms-py 3.0.10__py3-none-any.whl → 3.0.18__py3-none-any.whl

llms/extensions/app/__init__.py

@@ -199,7 +199,6 @@ def install(ctx):
             "model": thread.get("model"),
             "messages": thread.get("messages"),
             "modalities": thread.get("modalities"),
-            "systemPrompt": thread.get("systemPrompt"),
             "tools": thread.get("tools"),  # tools request
             "metadata": metadata,
         }

llms/extensions/app/db.py

@@ -1,5 +1,6 @@
 import json
 import os
+import time
 from datetime import datetime, timedelta
 from typing import Any, Dict
 
@@ -344,9 +345,12 @@ class AppDB:
         else:
             thread["createdAt"] = now
         thread["updatedAt"] = now
+        initial_timestamp = int(time.time() * 1000) + 1
         if "messages" in thread:
-            for m in thread["messages"]:
+            for idx, m in enumerate(thread["messages"]):
                 self.ctx.cache_message_inline_data(m)
+                if "timestamp" not in m:
+                    m["timestamp"] = initial_timestamp + idx
         return with_user(thread, user=user)
 
     def create_thread(self, thread: Dict[str, Any], user=None):
@@ -528,9 +532,9 @@ class AppDB:
         with self.db.create_writer_connection() as conn:
             conn.execute(
                 "UPDATE thread SET completedAt = :completedAt, error = :error WHERE completedAt IS NULL",
-                {"completedAt": datetime.now(), "error": "Server Shutdown"},
+                {"completedAt": datetime.now().isoformat(" "), "error": "Server Shutdown"},
             )
             conn.execute(
                 "UPDATE request SET completedAt = :completedAt, error = :error WHERE completedAt IS NULL",
-                {"completedAt": datetime.now(), "error": "Server Shutdown"},
+                {"completedAt": datetime.now().isoformat(" "), "error": "Server Shutdown"},
             )

llms/extensions/app/ui/threadStore.mjs

@@ -354,11 +354,11 @@ async function startNewThread({ title, model, tools, redirect }) {
 async function queueChat(ctxRequest, options = {}) {
     if (!ctxRequest.request) return ctx.createErrorResult({ message: 'No request provided' })
     if (!ctxRequest.thread) return ctx.createErrorResult({ message: 'No thread provided' })
-    if (!ctxRequest.request.metadata) {
-        ctxRequest.request.metadata = {}
-    }
+    ctxRequest = ctx.createChatContext(ctxRequest)
     ctx.chatRequestFilters.forEach(f => f(ctxRequest))
     const { thread, request } = ctxRequest
+    ctx.completeChatContext(ctxRequest)
+
     const api = await ctx.postJson(`/ext/app/threads/${thread.id}/chat`, {
         ...options,
         body: typeof request == 'string'
@@ -381,6 +381,12 @@ async function loadThreadDetails(id, opt = null) {
     return threadDetails.value[id]
 }
 
+function getCurrentThreadSystemPrompt() {
+    return currentThread.value?.systemPrompt
+        ?? currentThread.value?.messages?.find(m => m.role == 'system')?.content
+        ?? ''
+}
+
 // Export the store
 export function useThreadStore() {
     return {
@@ -391,6 +397,7 @@ export function useThreadStore() {
         groupedThreads,
 
         // Actions
+        getCurrentThreadSystemPrompt,
         query,
         createThread,
         updateThread,

llms/extensions/computer/README.md

@@ -0,0 +1,96 @@
+# Computer Use Tools
+
+This extension provides a set of tools that allow an Agent to interact with a computer environment in a way similar to a human user. It includes capabilities for screen interaction (mouse/keyboard), shell execution, and file editing. Based on [Anthropic's computer use tools](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo).
+
+## Available Tools
+
+### 1. Computer Tool (`computer`)
+Allows interaction with the screen, keyboard, and mouse.
+
+**Capabilities:**
+- **Mouse Interaction**: Move cursor, click (left, right, middle, double, triple), click & drag.
+- **Keyboard Interaction**: Type text, press specific keys or key combinations.
+- **Screen**: Take screenshots, get cursor position.
+- **Zooming**: Zoom into specific regions of the screen (Action: `zoom`).
+
+**Key Parameters:**
+- `action`: The action to perform (e.g., `mouse_move`, `left_click`, `type`, `screenshot`, `zoom`).
+- `coordinate`: `(x, y)` coordinates for mouse actions.
+- `text`: Text to type.
+- `key`: Key sequence to press (e.g., `Return`, `Control+c`).
+- `region`: `(x0, y0, x1, y1)` region for zooming.
+
+### 2. Bash Tool (`bash`)
+Provides a persistent shell session to execute command-line instructions.
+
+**Capabilities:**
+- **Execute Commands**: Run any bash command.
+- **Persistent Session**: State (like environment variables, working directory) is preserved between calls within the same session.
+- **Process Management**: Can restart the session if needed.
+- **Open Files/URLs**: Helper function `open` allows opening files or URLs using the system's default handler (`xdg-open`, `open`, or `start`).
+
+**Key Parameters:**
+- `command`: The bash command to execute.
+- `restart`: Boolean to restart the session.
+
+### 3. Edit Tool (`str_replace_editor`)
+A filesystem editor for viewing and modifying files.
+
+**Capabilities:**
+- **View**: Read file contents or list directories.
+- **Create**: Create new files with content.
+- **String Replace**: Replace unique strings in a file (robust for LLM editing).
+- **Insert**: Insert text at specific line numbers.
+- **Undo**: Undo the last edit to a file.
+
+**Key Parameters:**
+- `command`: The edit command (`view`, `create`, `str_replace`, `insert`, `undo_edit`).
+- `path`: Absolute path to the file or directory.
+- `file_text`: Content for file creation.
+- `old_str` / `new_str`: Strings for replacement.
+
+---
+
+## Capabilities & Workflows
+
+These tools are designed to work together to enable complex end-to-end tasks. An Agent can act as a developer, tester, or general user.
+
+### Example: "Build a Tetris web app in a tetris folder, open it then take a screenshot"
+
+To achieve this high-level task, the Agent would sequence the tools as follows:
+
+1.  **Create the Project Structure**
+    *   **Tool**: `bash`
+    *   **Command**: `mkdir -p tetris`
+    *   *Result*: Creates the folder.
+
+2.  **Create the Application Files**
+    *   **Tool**: `edit` (command: `create`)
+    *   **Path**: `/path/to/tetris/index.html`
+    *   **Content**: (HTML code for Tetris game)
+    *   *Result*: Writes the HTML file.
+
+3.  **Open the Application**
+    *   **Tool**: `bash` (via helper `open`) or `bash` directly.
+    *   **Command**: `xdg-open /path/to/tetris/index.html` (Linux) or just `python -m http.server` and open localhost.
+    *   *Result*: Opens the file in the default web browser.
+
+4.  **Wait & Verify**
+    *   **Tool**: `computer`
+    *   **Action**: `wait` or `screenshot` to see if it loaded.
+
+5.  **Take a Screenshot**
+    *   **Tool**: `computer`
+    *   **Action**: `screenshot`
+    *   *Result*: Captures the visual state of the running Tetris app for the user to see.
+
+### How it handles the "Build a Tetris..." request:
+When a user gives the command:
+> "Build a Tetris web app in a tetris folder, open it then take a screenshot"
+
+The Agent decomposes this into:
+1.  **"Build... in a tetris folder"** -> Uses `bash` to make the directory and `edit` to write the `index.html` / `style.css` / `script.js` files.
+2.  **"Open it"** -> Uses `bash` to run a server or open the file in a browser.
+3.  **"Take a screenshot"** -> Uses `computer` to verify the visual output.
+
+This combination allows the Agent to not just generate code, but **verify** it visually and interactively, closing the loop on development tasks.

llms/extensions/computer/__init__.py

@@ -0,0 +1,59 @@
+"""
+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 .filesystem import (
+    create_directory,
+    directory_tree,
+    edit_file,
+    filesystem_init,
+    get_file_info,
+    list_allowed_directories,
+    list_directory,
+    list_directory_with_sizes,
+    move_file,
+    read_media_file,
+    read_multiple_files,
+    read_text_file,
+    search_files,
+    write_file,
+)
+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):
+    filesystem_init(ctx)
+
+    ctx.register_tool(run_bash, group="computer")
+    ctx.register_tool(open, group="computer")
+    ctx.register_tool(edit, group="computer")
+    ctx.register_tool(computer, group="computer")
+
+    ctx.register_tool(read_text_file, group="filesystem")
+    ctx.register_tool(read_media_file, group="filesystem")
+    ctx.register_tool(read_multiple_files, group="filesystem")
+    ctx.register_tool(write_file, group="filesystem")
+    ctx.register_tool(edit_file, group="filesystem")
+    ctx.register_tool(create_directory, group="filesystem")
+    ctx.register_tool(list_directory, group="filesystem")
+    ctx.register_tool(list_directory_with_sizes, group="filesystem")
+    ctx.register_tool(directory_tree, group="filesystem")
+    ctx.register_tool(move_file, group="filesystem")
+    ctx.register_tool(search_files, group="filesystem")
+    ctx.register_tool(get_file_info, group="filesystem")
+    ctx.register_tool(list_allowed_directories, group="filesystem")
+
+
+__install__ = install

llms/extensions/computer/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/extensions/computer/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=command, restart=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(command=" ".join(cmd))