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

llms/extensions/app/ui/threadStore.mjs

@@ -0,0 +1,440 @@
+import { ref, computed } from 'vue'
+import { appendQueryString } from '@servicestack/client'
+
+/**
+ * Returns an ever-increasing unique integer id.
+ */
+export const nextId = (() => {
+    let last = 0               // cache of the last id that was handed out
+    return () => {
+        const now = Date.now() // current millisecond timestamp
+        last = (now > last) ? now : last + 1
+        return last
+    }
+})();
+
+
+const threads = ref([])
+const threadDetails = ref({})
+const currentThread = ref(null)
+const isLoading = ref(false)
+
+let ctx = null
+let ext = null
+
+function setError(error, msg = null) {
+    ctx?.setError(error, msg)
+}
+
+async function query(query) {
+    return (await ext.getJson(appendQueryString(`/threads`, query))).response || []
+}
+
+let watchThreadTimeout = ref(null)
+async function watchThreadUpdates() {
+    const thread = currentThread.value
+    // console.debug('watchThreadUpdates', thread?.id, thread?.messages?.length, thread?.completedAt)
+    if (thread && thread?.messages?.length && !thread.completedAt) {
+        const api = await ext.getJson(appendQueryString(`/threads/${thread.id}/updates`, { after: thread.updatedAt }))
+        // console.log('watchThreadUpdates', api)
+        if (api.response) {
+            replaceThread(api.response)
+            return
+        } else {
+            setError(api.error, `watching thread ${thread.id}`)
+        }
+    }
+    stopWatchingThread()
+}
+
+function startWatchingThread() {
+    stopWatchingThread()
+    const thread = currentThread.value
+    if (thread && thread?.messages?.length && !thread.completedAt) {
+        watchThreadTimeout.value = setTimeout(watchThreadUpdates, 100)
+    }
+}
+
+function stopWatchingThread() {
+    console.debug('stopWatchingThread')
+    if (watchThreadTimeout.value) {
+        clearTimeout(watchThreadTimeout.value)
+    }
+    watchThreadTimeout.value = null
+}
+
+const isWatchingThread = computed(() => watchThreadTimeout.value != null)
+
+async function cancelThread() {
+    console.log('cancelThread')
+    stopWatchingThread()
+    const thread = currentThread.value
+    if (!thread) return
+    const api = await ext.postJson(`/threads/${thread.id}/cancel`)
+    if (api.response) {
+        replaceThread(api.response)
+    } else {
+        setError(api.error, `Canceling thread ${thread.id}`)
+    }
+}
+
+// Create a new thread
+async function createThread(args = {}) {
+    const thread = {
+        messages: [],
+        ...args
+    }
+    if (!thread.title) {
+        thread.title = 'New Chat'
+    }
+    if (thread.title.length > 200) {
+        thread.title = thread.title.slice(0, 200) + '...'
+    }
+
+    ctx.createThreadFilters.forEach(f => f(thread))
+
+    const api = await ext.postJson("/threads", thread)
+    if (api.response) {
+        threads.value.unshift(api.response)
+        return api.response
+    } else {
+        setError(api.error, `Creating thread ${thread.title}`)
+    }
+
+    return thread
+}
+
+function replaceThread(thread) {
+    if (!thread) {
+        console.error('replaceThread(null)')
+        return
+    }
+    const index = threads.value.findIndex(t => t.id === thread.id)
+    if (index !== -1) {
+        threads.value[index] = thread
+    }
+    if (currentThread.value?.id === thread.id) {
+        currentThread.value = thread
+    }
+    if (thread.completedAt || thread.error) {
+        threadDetails.value[thread.id] = thread
+    }
+    startWatchingThread()
+    return thread
+}
+
+// Update thread
+async function updateThread(threadId, updates) {
+
+    if (!threadId)
+        throw new Error('threadId is required')
+
+    ctx.updateThreadFilters.forEach(f => f(updates))
+
+    const api = await ext.patchJson(`/threads/${threadId}`, updates)
+    if (api.response) {
+        return replaceThread(api.response)
+    } else {
+        setError(api.error, `Updating thread ${threadId}`)
+    }
+}
+
+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.timestamp !== timestamp)
+    console.log('deleteMessageFromThread', threadId, timestamp, updatedMessages)
+    await updateThread(threadId, { messages: updatedMessages })
+}
+
+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.timestamp === messageId)
+    if (messageIndex === -1) throw new Error('Message not found')
+
+    const updatedMessages = [...thread.messages]
+    updatedMessages[messageIndex] = {
+        ...updatedMessages[messageIndex],
+        ...updates
+    }
+
+    await updateThread(threadId, { messages: updatedMessages })
+}
+
+async function redoMessageFromThread(threadId, timestamp) {
+    const thread = await getThread(threadId)
+    if (!thread) throw new Error('Thread not found')
+
+    // Find the index of the message to redo
+    const messageIndex = thread.messages.findIndex(m => m.timestamp === timestamp)
+    if (messageIndex === -1) {
+        setError({ message: `Message not found for timestamp ${timestamp}` })
+        return
+    }
+
+    // setError({
+    //     errorCode: 'TestError',
+    //     message: `Error redoing message ${timestamp} in thread ${threadId}`,
+    //     stackTrace: `Error in page.mjs
+    //         at Line 1
+    //         at Line 2
+    //         at Line 3`,
+    // })
+    // return
+
+    // Keep only messages up to and including the target message
+    const updatedMessages = thread.messages.slice(0, messageIndex + 1)
+
+    // Update the thread with the new messages
+    const request = { messages: updatedMessages }
+    const api = await queueChat({ request, thread })
+    if (api.response) {
+        replaceThread(api.response)
+    } else {
+        setError(api.error, `Redoing message ${timestamp} in thread ${threadId}`)
+    }
+}
+
+async function loadThreads() {
+    isLoading.value = true
+
+    try {
+        const api = await ext.getJson('/threads?take=30')
+        threads.value = api.response || []
+        return threads.value
+    } finally {
+        isLoading.value = false
+    }
+}
+
+async function getThread(threadId) {
+    const cachedThread = threads.value.find(t => t.id == threadId)
+    if (cachedThread) return cachedThread
+    const api = await ext.getJson(`/threads?id=${threadId}`)
+    return api.response && api.response[0] || null
+}
+
+// Delete thread
+async function deleteThread(threadId) {
+    await ext.delete(`/threads/${threadId}`)
+
+    threads.value = threads.value.filter(t => t.id !== threadId)
+
+    if (currentThread.value?.id === threadId) {
+        currentThread.value = null
+    }
+}
+
+// Set current thread
+async function setCurrentThread(threadId) {
+    const thread = await getThread(threadId)
+    if (thread) {
+        currentThread.value = thread
+        startWatchingThread()
+    }
+    return thread
+}
+
+// Set current thread from router params (router-aware version)
+async function setCurrentThreadFromRoute(threadId, router) {
+    if (!threadId) {
+        currentThread.value = null
+        return null
+    }
+
+    loadThreadDetails(threadId)
+    const thread = setCurrentThread(threadId)
+    if (thread) {
+        return thread
+    } else {
+        // Thread not found, redirect to home
+        if (router) {
+            router.push((globalThis.ai?.base || '') + '/')
+        }
+        currentThread.value = null
+        return null
+    }
+}
+
+// Clear current thread (go back to initial state)
+function clearCurrentThread() {
+    currentThread.value = null
+}
+
+function getGroupedThreads(total) {
+    const now = new Date()
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
+    const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000)
+    const lastWeek = new Date(today.getTime() - 7 * 24 * 60 * 60 * 1000)
+    const lastMonth = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000)
+
+    const groups = {
+        today: [],
+        yesterday: [],
+        lastWeek: [],
+        lastMonth: [],
+        older: {}
+    }
+
+    const takeThreads = threads.value.slice(0, total)
+
+    takeThreads.forEach(thread => {
+        const threadDate = new Date(thread.updatedAt)
+
+        if (threadDate >= today) {
+            groups.today.push(thread)
+        } else if (threadDate >= yesterday) {
+            groups.yesterday.push(thread)
+        } else if (threadDate >= lastWeek) {
+            groups.lastWeek.push(thread)
+        } else if (threadDate >= lastMonth) {
+            groups.lastMonth.push(thread)
+        } else {
+            const year = threadDate.getFullYear()
+            const month = threadDate.toLocaleString('default', { month: 'long' })
+            const key = `${month} ${year}`
+
+            if (!groups.older[key]) {
+                groups.older[key] = []
+            }
+            groups.older[key].push(thread)
+        }
+    })
+
+    return groups
+}
+
+// Group threads by time periods
+const groupedThreads = computed(() => getGroupedThreads(threads.value.length))
+
+function getLatestCachedThread() {
+    return threads.value[0]
+}
+
+async function startNewThread({ title, model, tools, redirect }) {
+    if (!model) {
+        console.error('No model selected')
+        return
+    }
+    if (!title) {
+        title = 'New Chat'
+    }
+    const latestThread = getLatestCachedThread()
+
+    console.log('startNewThread', title, model.name, ctx.router.currentRoute.value?.path, latestThread?.messages?.length)
+    ctx.setLayout({ left: 'ThreadsSidebar' })
+
+    if (latestThread && latestThread.title == title && !latestThread.messages?.length) {
+        if (ctx.router.currentRoute.value?.path != `/c/${latestThread.id}`) {
+            ctx.to(`/c/${latestThread.id}`)
+        }
+        return latestThread
+    }
+    const newThread = await createThread({
+        title,
+        model: model.name,
+        info: ctx.utils.toModelInfo(model),
+        tools,
+    })
+
+    console.log('newThread', newThread, model)
+    if (redirect) {
+        // Navigate to the new thread URL
+        ctx.to(`/c/${newThread.id}`)
+    }
+
+    // Get the thread to check for duplicates
+    let thread = await getThread(newThread.id)
+    console.log('thread', thread)
+    return thread
+}
+
+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' })
+    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'
+            ? request
+            : JSON.stringify(request),
+    })
+    return api
+}
+
+async function loadThreadDetails(id, opt = null) {
+    if (!threadDetails.value[id] || opt?.force) {
+        const api = await ctx.getJson(`/ext/app/threads/${id}`)
+        if (api.response) {
+            threadDetails.value[id] = api.response
+        }
+        if (api.error) {
+            console.error(api.error)
+        }
+    }
+    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 {
+        // State
+        threads,
+        currentThread,
+        isLoading,
+        groupedThreads,
+
+        // Actions
+        getCurrentThreadSystemPrompt,
+        query,
+        createThread,
+        updateThread,
+        deleteMessageFromThread,
+        updateMessageInThread,
+        redoMessageFromThread,
+        loadThreads,
+        getThread,
+        deleteThread,
+        setCurrentThread,
+        setCurrentThreadFromRoute,
+        clearCurrentThread,
+        getGroupedThreads,
+        getLatestCachedThread,
+        startNewThread,
+        replaceThread,
+        queueChat,
+        threadDetails,
+        loadThreadDetails,
+        isWatchingThread,
+        startWatchingThread,
+        stopWatchingThread,
+        cancelThread,
+        get watchingThread() {
+            return isWatchingThread.value
+        },
+    }
+}
+
+export default {
+    install(context) {
+        ctx = context
+        ext = ctx.scope('app')
+        ctx.setGlobals({ threads: useThreadStore() })
+    },
+
+    async load() {
+        await ctx.threads.loadThreads()
+    }
+}

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