meshagent-tools 0.24.0__py3-none-any.whl → 0.24.3__py3-none-any.whl

meshagent/tools/script.py

@@ -0,0 +1,313 @@
+from meshagent.api import RoomClient
+from meshagent.tools import Toolkit, ToolContext, Tool
+
+from meshagent.agents.adapter import (
+    ToolkitBuilder,
+)
+
+from meshagent.api.specs.service import ContainerMountSpec, RoomStorageMountSpec
+from typing import Literal
+import os
+from typing import Optional
+
+import logging
+import asyncio
+from pydantic import BaseModel
+
+logger = logging.getLogger("script_tool")
+
+
+DEFAULT_CONTAINER_MOUNT_SPEC = ContainerMountSpec(
+    room=[RoomStorageMountSpec(path="/data")]
+)
+
+
+class ScriptToolConfig(BaseModel):
+    name: Literal["script"] = "script"
+    service_id: Optional[str] = None
+    commands: list[str] = None
+    description: Optional[str] = None
+    title: Optional[str] = None
+    tool_name: str
+
+
+class ScriptToolkitBuilder(ToolkitBuilder):
+    def __init__(
+        self,
+        *,
+        name: str = "script",
+        commands: Optional[list[str]] = None,
+        working_directory: Optional[str] = None,
+        image: Optional[str] = "python:3.13",
+        mounts: Optional[ContainerMountSpec] = DEFAULT_CONTAINER_MOUNT_SPEC,
+        input_schema: Optional[dict] = None,
+    ):
+        super().__init__(name=name, type=ScriptToolConfig)
+
+        self.working_directory = working_directory
+        self.image = image
+        self.mounts = mounts
+        self.commands = commands
+        self.input_schema = input_schema
+
+    async def make(self, *, room: RoomClient, model: str, config: ScriptToolConfig):
+        return Toolkit(
+            name=self.name,
+            tools=[
+                ScriptTool(
+                    name=config.tool_name,
+                    description=config.description,
+                    title=config.title,
+                    service_id=config.service_id,
+                    working_directory=self.working_directory,
+                    image=self.image,
+                    commands=self.commands or config.commands,
+                    mounts=self.mounts,
+                    input_schema=self.input_schema,
+                )
+            ],
+        )
+
+
+class ScriptTool(Tool):
+    def __init__(
+        self,
+        *,
+        name: str,
+        commands: list[str],
+        description: Optional[str] = None,
+        title: Optional[str] = None,
+        service_id: Optional[str] = None,
+        working_directory: Optional[str] = None,
+        image: Optional[str] = "python:3.13",
+        mounts: Optional[ContainerMountSpec] = DEFAULT_CONTAINER_MOUNT_SPEC,
+        env: Optional[dict[str, str]] = None,
+        input_schema: Optional[dict] = None,
+        max_output_length: int = 32000,
+        timeout_ms: int = 30 * 60 * 1000,
+    ):
+        self.service_id = service_id
+        self.working_directory = working_directory
+        self.image = image
+        self.mounts = mounts
+        self._container_id = None
+        self.env = env
+        self.max_output_length = max_output_length
+        self.timeout_ms = timeout_ms
+        self.service_id = service_id
+        self.commands = commands
+
+        super().__init__(
+            name=name,
+            description=description,
+            title=title,
+            input_schema=input_schema
+            or {
+                "type": "object",
+                "required": ["prompt"],
+                "additionalProperties": False,
+                "properties": {"prompt": {"type": "string"}},
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        **kwargs,
+    ):
+        merged_env = {**os.environ}
+
+        results = []
+        encoding = os.device_encoding(1) or "utf-8"
+
+        left = self.max_output_length
+
+        def limit(s: str):
+            nonlocal left
+            if left is not None:
+                s = s[0:left]
+                left -= len(s)
+                return s
+            else:
+                return s
+
+        timeout = float(self.timeout_ms) / 1000.0 if self.timeout_ms else 20 * 1000.0
+
+        if self.image is not None or self.service_id is not None:
+            running = False
+
+            if self._container_id:
+                # make sure container is still running
+
+                for c in await context.room.containers.list():
+                    if c.id == self._container_id or (
+                        self.service_id is not None and c.service_id == self.service_id
+                    ):
+                        running = True
+
+            if not running:
+                if self.service_id is not None:
+                    env = {}
+
+                    for k, v in kwargs.items():
+                        env[k.upper()] = v
+
+                        logger.info(
+                            f"executing shell script in container with env {env}"
+                        )
+
+                    self._container_id = await context.room.containers.run_service(
+                        service_id=self.service_id,
+                        env=env,
+                    )
+
+                else:
+                    self._container_id = await context.room.containers.run(
+                        command="sleep infinity",
+                        image=self.image,
+                        mounts=self.mounts,
+                        writable_root_fs=True,
+                        env=self.env,
+                    )
+
+            container_id = self._container_id
+            commands = self.commands
+            logger.info(
+                f"executing shell script in container {container_id} with timeout {timeout}: {commands}"
+            )
+            import shlex
+
+            for line in commands:
+                try:
+                    # TODO: what if container start fails
+
+                    exec = await context.room.containers.exec(
+                        container_id=container_id,
+                        command=shlex.join(["bash", "-c", line]),
+                        tty=False,
+                    )
+
+                    stdout = bytearray()
+                    stderr = bytearray()
+
+                    try:
+                        async with asyncio.timeout(timeout):
+                            async for se in exec.stderr():
+                                stderr.extend(se)
+
+                            async for so in exec.stdout():
+                                stdout.extend(so)
+
+                            exit_code = await exec.result
+
+                            return {
+                                "outcome": {
+                                    "type": "exit",
+                                    "exit_code": exit_code,
+                                },
+                                "stdout": stdout.decode(),
+                                "stderr": stderr.decode(),
+                            }
+
+                    except asyncio.TimeoutError:
+                        logger.info(f"The command timed out after {timeout}s")
+                        await exec.kill()
+
+                        results.append(
+                            {
+                                "outcome": {"type": "timeout"},
+                                "stdout": limit(
+                                    stdout.decode(encoding, errors="replace")
+                                ),
+                                "stderr": limit(
+                                    stderr.decode(encoding, errors="replace")
+                                ),
+                            }
+                        )
+                        break
+
+                    except Exception as ex:
+                        results.append(
+                            {
+                                "outcome": {
+                                    "type": "exit",
+                                    "exit_code": 1,
+                                },
+                                "stdout": "",
+                                "stderr": f"{ex}",
+                            }
+                        )
+                        break
+
+                except Exception as ex:
+                    results.append(
+                        {
+                            "outcome": {
+                                "type": "exit",
+                                "exit_code": 1,
+                            },
+                            "stdout": "",
+                            "stderr": f"{ex}",
+                        }
+                    )
+                    break
+        else:
+            for line in self.commands:
+                logger.info(f"executing command {line} with timeout: {timeout}s")
+
+                # Spawn the process
+                try:
+                    import shlex
+
+                    proc = await asyncio.create_subprocess_shell(
+                        shlex.join(["bash", "-c", line]),
+                        cwd=self.working_directory or os.getcwd(),
+                        env=merged_env,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                    )
+
+                    stdout, stderr = await asyncio.wait_for(
+                        proc.communicate(),
+                        timeout=timeout,
+                    )
+                except asyncio.TimeoutError:
+                    logger.info(f"The command timed out after {timeout}s")
+                    proc.kill()  # send SIGKILL / TerminateProcess
+
+                    stdout, stderr = await proc.communicate()
+
+                    results.append(
+                        {
+                            "outcome": {"type": "timeout"},
+                            "stdout": limit(stdout.decode(encoding, errors="replace")),
+                            "stderr": limit(stderr.decode(encoding, errors="replace")),
+                        }
+                    )
+                    break
+
+                except Exception as ex:
+                    results.append(
+                        {
+                            "outcome": {
+                                "type": "exit",
+                                "exit_code": 1,
+                            },
+                            "stdout": "",
+                            "stderr": f"{ex}",
+                        }
+                    )
+                    break
+
+                results.append(
+                    {
+                        "outcome": {
+                            "type": "exit",
+                            "exit_code": proc.returncode,
+                        },
+                        "stdout": limit(stdout.decode(encoding, errors="replace")),
+                        "stderr": limit(stderr.decode(encoding, errors="replace")),
+                    }
+                )
+
+        return {"results": results}

meshagent/tools/storage.py

@@ -1,19 +1,470 @@
+import asyncio
+import json
+import mimetypes
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
 from meshagent.api.messaging import JsonResponse, LinkResponse, FileResponse
-from meshagent.api import RoomClient
+from meshagent.api import RoomClient, RoomException
+from meshagent.api.room_server_client import StorageEntry
+
 from .config import ToolkitConfig
 from .tool import Tool
 from .toolkit import ToolContext, ToolkitBuilder
 from .hosting import RemoteToolkit, Toolkit
-import os
-from meshagent.api import RoomException
 from .blob import get_bytes_from_url
-from typing import Literal
-import json
-import os.path
 
 
-class ReadFileTool(Tool):
-    def __init__(self):
+class StorageToolMount(BaseModel):
+    path: str
+    read_only: bool = False
+
+    model_config = ConfigDict(extra="forbid")
+
+    def _ensure_writable(self, path: str) -> None:
+        if self.read_only:
+            raise RoomException(f"storage mount is read-only: {path}")
+
+    async def read_file(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+    ) -> FileResponse:
+        raise NotImplementedError
+
+    async def write_text(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+        text: str,
+        overwrite: bool,
+    ) -> None:
+        raise NotImplementedError
+
+    async def write_bytes(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+        data: bytes,
+        overwrite: bool,
+    ) -> None:
+        raise NotImplementedError
+
+    async def list_entries(
+        self, *, context: ToolContext, resolved: "_ResolvedStoragePath"
+    ) -> list[StorageEntry]:
+        raise NotImplementedError
+
+    async def get_download_url(
+        self, *, context: ToolContext, resolved: "_ResolvedStoragePath", path: str
+    ) -> LinkResponse:
+        raise NotImplementedError
+
+
+class StorageToolLocalMount(StorageToolMount):
+    local_path: str
+
+    async def read_file(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+    ) -> FileResponse:
+        local_path = _require_local_path(resolved)
+        filename = os.path.basename(path)
+        mime_type, _ = mimetypes.guess_type(local_path)
+        if mime_type is None:
+            mime_type = "application/octet-stream"
+        data = await _read_local_file(local_path)
+        return FileResponse(mime_type=mime_type, name=filename, data=data)
+
+    async def write_text(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+        text: str,
+        overwrite: bool,
+    ) -> None:
+        self._ensure_writable(path)
+        local_path = _require_local_path(resolved)
+        await _write_local_text(local_path, text, overwrite)
+
+    async def write_bytes(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+        data: bytes,
+        overwrite: bool,
+    ) -> None:
+        self._ensure_writable(path)
+        local_path = _require_local_path(resolved)
+        await _write_local_bytes(local_path, data, overwrite)
+
+    async def list_entries(
+        self, *, context: ToolContext, resolved: "_ResolvedStoragePath"
+    ) -> list[StorageEntry]:
+        local_path = _require_local_path(resolved)
+        return await _list_local_entries(local_path)
+
+    async def get_download_url(
+        self, *, context: ToolContext, resolved: "_ResolvedStoragePath", path: str
+    ) -> LinkResponse:
+        local_path = _require_local_path(resolved)
+        file_path = Path(local_path)
+        if not file_path.exists():
+            raise RoomException(f"file not found: {local_path}")
+        if not file_path.is_file():
+            raise RoomException(f"path is not a file: {local_path}")
+        name = os.path.basename(path)
+        return LinkResponse(name=name, url=file_path.resolve().as_uri())
+
+
+class StorageToolRoomMount(StorageToolMount):
+    subpath: Optional[str] = None
+
+    async def read_file(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+    ) -> FileResponse:
+        room_path = _require_room_path(resolved)
+        filename = os.path.basename(path)
+        _, extension = os.path.splitext(path)
+        if extension:
+            schema_path = _make_room_path(
+                resolved.room_root, f".schemas/{extension.lstrip('.')}" + ".json"
+            )
+            if await context.room.storage.exists(path=schema_path):
+                return FileResponse(
+                    mime_type="application/json",
+                    name=filename,
+                    data=json.dumps(
+                        await context.room.sync.describe(path=room_path)
+                    ).encode(),
+                )
+        return await context.room.storage.download(path=room_path)
+
+    async def write_text(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+        text: str,
+        overwrite: bool,
+    ) -> None:
+        self._ensure_writable(path)
+        room_path = _require_room_path(resolved)
+        handle = await context.room.storage.open(path=room_path, overwrite=overwrite)
+        await context.room.storage.write(handle=handle, data=text.encode("utf-8"))
+        await context.room.storage.close(handle=handle)
+
+    async def write_bytes(
+        self,
+        *,
+        context: ToolContext,
+        resolved: "_ResolvedStoragePath",
+        path: str,
+        data: bytes,
+        overwrite: bool,
+    ) -> None:
+        self._ensure_writable(path)
+        room_path = _require_room_path(resolved)
+        if not overwrite:
+            result = await context.room.storage.exists(path=room_path)
+            if result:
+                raise RoomException(
+                    f"a file already exists at the path: {path}, try another filename"
+                )
+        handle = await context.room.storage.open(path=room_path, overwrite=overwrite)
+        try:
+            await context.room.storage.write(handle=handle, data=data)
+        finally:
+            await context.room.storage.close(handle=handle)
+
+    async def list_entries(
+        self, *, context: ToolContext, resolved: "_ResolvedStoragePath"
+    ) -> list[StorageEntry]:
+        room_path = _require_room_path(resolved)
+        return await context.room.storage.list(path=room_path)
+
+    async def get_download_url(
+        self, *, context: ToolContext, resolved: "_ResolvedStoragePath", path: str
+    ) -> LinkResponse:
+        room_path = _require_room_path(resolved)
+        name = os.path.basename(path)
+        url = await context.room.storage.download_url(path=room_path)
+        return LinkResponse(name=name, url=url)
+
+
+@dataclass(frozen=True)
+class _PreparedMount:
+    mount: StorageToolMount
+    virtual_path: str
+    local_root: Optional[str]
+    room_root: Optional[str]
+
+
+@dataclass(frozen=True)
+class _ResolvedStoragePath:
+    mount: StorageToolMount
+    virtual_path: str
+    relative_path: str
+    local_path: Optional[str]
+    room_path: Optional[str]
+    room_root: Optional[str]
+
+
+def _normalize_mount_path(path: str) -> str:
+    if path is None:
+        raise RoomException("mount path must be set")
+
+    cleaned = path.strip()
+    if cleaned in ("", "/", "."):
+        return "/"
+
+    cleaned = cleaned.lstrip("/")
+    if cleaned == "":
+        return "/"
+
+    parts = cleaned.split("/")
+    if any(part in {".", ".."} for part in parts):
+        raise RoomException(f"invalid mount path: {path}")
+
+    return f"/{'/'.join(parts)}"
+
+
+def _normalize_virtual_path(path: str) -> str:
+    if path is None:
+        raise RoomException("path must be set")
+
+    cleaned = path.strip()
+    if cleaned in ("", "."):
+        return "/"
+
+    cleaned = cleaned.lstrip("/")
+    if cleaned == "":
+        return "/"
+
+    parts = cleaned.split("/")
+    if any(part in {".", ".."} for part in parts):
+        raise RoomException(f"dot segments not allowed: {path}")
+
+    return f"/{'/'.join(parts)}"
+
+
+def _normalize_room_root(subpath: Optional[str]) -> str:
+    if subpath is None:
+        return ""
+
+    cleaned = subpath.strip()
+    if cleaned in ("", "/", "."):
+        return ""
+
+    cleaned = cleaned.strip("/")
+    parts = cleaned.split("/")
+    if any(part in {".", ".."} for part in parts):
+        raise RoomException(f"dot segments not allowed: {subpath}")
+
+    return "/".join(parts)
+
+
+def _prepare_mounts(
+    mounts: Optional[list[StorageToolMount]],
+) -> list[_PreparedMount]:
+    if not mounts:
+        mounts = [StorageToolRoomMount(path="/")]
+
+    prepared = []
+    for mount in mounts:
+        virtual_path = _normalize_mount_path(mount.path)
+        if isinstance(mount, StorageToolLocalMount):
+            local_root = os.path.abspath(mount.local_path)
+            room_root = None
+        else:
+            local_root = None
+            room_root = _normalize_room_root(mount.subpath)
+
+        prepared.append(
+            _PreparedMount(
+                mount=mount,
+                virtual_path=virtual_path,
+                local_root=local_root,
+                room_root=room_root,
+            )
+        )
+
+    return prepared
+
+
+def _resolve_storage_path(
+    mounts: list[_PreparedMount], path: str
+) -> _ResolvedStoragePath:
+    virtual_path = _normalize_virtual_path(path)
+
+    matches = []
+    for mount in mounts:
+        if mount.virtual_path == "/":
+            matches.append(mount)
+            continue
+
+        if virtual_path == mount.virtual_path or virtual_path.startswith(
+            f"{mount.virtual_path}/"
+        ):
+            matches.append(mount)
+
+    if not matches:
+        raise RoomException(f"path is not within a storage mount: {path}")
+
+    selected = max(matches, key=lambda m: len(m.virtual_path))
+    relative_path = virtual_path[len(selected.virtual_path) :].lstrip("/")
+
+    local_path = None
+    room_path = None
+    room_root = selected.room_root
+
+    if selected.local_root is not None:
+        local_path = os.path.normpath(os.path.join(selected.local_root, relative_path))
+        if os.path.commonpath([selected.local_root, local_path]) != selected.local_root:
+            raise RoomException(f"path escapes the storage mount: {path}")
+    else:
+        if room_root and relative_path:
+            room_path = f"{room_root}/{relative_path}"
+        elif room_root:
+            room_path = room_root
+        else:
+            room_path = relative_path
+
+    return _ResolvedStoragePath(
+        mount=selected.mount,
+        virtual_path=virtual_path,
+        relative_path=relative_path,
+        local_path=local_path,
+        room_path=room_path,
+        room_root=room_root,
+    )
+
+
+def _make_room_path(room_root: Optional[str], relative_path: str) -> str:
+    room_root = room_root or ""
+    relative_path = relative_path.lstrip("/")
+
+    if room_root and relative_path:
+        return f"{room_root}/{relative_path}"
+
+    return room_root or relative_path
+
+
+def _require_local_path(resolved: _ResolvedStoragePath) -> str:
+    if resolved.local_path is None:
+        raise RoomException("local path is not available for this mount")
+    return resolved.local_path
+
+
+def _require_room_path(resolved: _ResolvedStoragePath) -> str:
+    if resolved.room_path is None:
+        raise RoomException("room path is not available for this mount")
+    return resolved.room_path
+
+
+async def _read_local_file(path: str) -> bytes:
+    def _read() -> bytes:
+        return Path(path).read_bytes()
+
+    try:
+        return await asyncio.to_thread(_read)
+    except FileNotFoundError:
+        raise RoomException(f"file not found: {path}")
+    except IsADirectoryError:
+        raise RoomException(f"path is a directory: {path}")
+
+
+async def _write_local_bytes(path: str, data: bytes, overwrite: bool) -> None:
+    def _write() -> None:
+        if not overwrite and os.path.exists(path):
+            raise RoomException(
+                f"a file already exists at the path: {path}, try another filename"
+            )
+        directory = os.path.dirname(path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+        with open(path, "wb") as handle:
+            handle.write(data)
+
+    await asyncio.to_thread(_write)
+
+
+async def _write_local_text(path: str, text: str, overwrite: bool) -> None:
+    def _write() -> None:
+        if not overwrite and os.path.exists(path):
+            raise RoomException(
+                f"a file already exists at the path: {path}, try another filename"
+            )
+        directory = os.path.dirname(path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as handle:
+            handle.write(text)
+
+    await asyncio.to_thread(_write)
+
+
+async def _list_local_entries(path: str) -> list[StorageEntry]:
+    def _list() -> list[StorageEntry]:
+        try:
+            entries = []
+            for entry in os.scandir(path):
+                stat_info = entry.stat()
+                entries.append(
+                    StorageEntry(
+                        name=entry.name,
+                        is_folder=entry.is_dir(),
+                        created_at=datetime.fromtimestamp(
+                            stat_info.st_ctime, tz=timezone.utc
+                        ),
+                        updated_at=datetime.fromtimestamp(
+                            stat_info.st_mtime, tz=timezone.utc
+                        ),
+                    )
+                )
+            return entries
+        except FileNotFoundError:
+            return []
+        except NotADirectoryError:
+            return []
+
+    return await asyncio.to_thread(_list)
+
+
+class _StorageTool(Tool):
+    def __init__(self, *, mounts: list[_PreparedMount], **kwargs):
+        super().__init__(**kwargs)
+        self._mounts = mounts
+
+    def _resolve_path(self, path: str) -> _ResolvedStoragePath:
+        return _resolve_storage_path(self._mounts, path)
+
+
+class ReadFileTool(_StorageTool):
+    def __init__(self, *, mounts: list[_PreparedMount]):
         super().__init__(
             name="read_file",
             title="read a file file",
@@ -29,25 +480,19 @@ class ReadFileTool(Tool):
                     }
                 },
             },
+            mounts=mounts,
         )
 
-    async def execute(self, *, context: ToolContext, path: str):
-        filename = os.path.basename(path)
-        _, extension = os.path.splitext(path)
-        if await context.room.storage.exists(
-            path=f".schemas/{extension.lstrip('.')}.json"
-        ):
-            return FileResponse(
-                mime_type="application/json",
-                name=filename,
-                data=json.dumps(await context.room.sync.describe(path=path)).encode(),
-            )
-        else:
-            return await context.room.storage.download(path=path)
+    async def execute(self, context: ToolContext, **kwargs):
+        path = kwargs["path"]
+        resolved = self._resolve_path(path)
+        return await resolved.mount.read_file(
+            context=context, resolved=resolved, path=path
+        )
 
 
-class WriteFileTool(Tool):
-    def __init__(self):
+class WriteFileTool(_StorageTool):
+    def __init__(self, *, mounts: list[_PreparedMount]):
         super().__init__(
             name="write_file",
             title="write text file",
@@ -71,19 +516,26 @@ class WriteFileTool(Tool):
                     },
                 },
             },
+            mounts=mounts,
         )
 
-    async def execute(
-        self, *, context: ToolContext, path: str, text: str, overwrite: bool
-    ):
-        handle = await context.room.storage.open(path=path, overwrite=overwrite)
-        await context.room.storage.write(handle=handle, data=text.encode("utf-8"))
-        await context.room.storage.close(handle=handle)
+    async def execute(self, context: ToolContext, **kwargs):
+        path = kwargs["path"]
+        text = kwargs["text"]
+        overwrite = kwargs["overwrite"]
+        resolved = self._resolve_path(path)
+        await resolved.mount.write_text(
+            context=context,
+            resolved=resolved,
+            path=path,
+            text=text,
+            overwrite=overwrite,
+        )
         return "the file was saved"
 
 
-class GetFileDownloadUrl(Tool):
-    def __init__(self):
+class GetFileDownloadUrl(_StorageTool):
+    def __init__(self, *, mounts: list[_PreparedMount]):
         super().__init__(
             name="get_file_download_url",
             title="get file download url",
@@ -99,16 +551,19 @@ class GetFileDownloadUrl(Tool):
                     }
                 },
             },
+            mounts=mounts,
         )
 
-    async def execute(self, *, context: ToolContext, path: str):
-        name = os.path.basename(path)
-        url = await context.room.storage.download_url(path=path)
-        return LinkResponse(name=name, url=url)
+    async def execute(self, context: ToolContext, **kwargs):
+        path = kwargs["path"]
+        resolved = self._resolve_path(path)
+        return await resolved.mount.get_download_url(
+            context=context, resolved=resolved, path=path
+        )
 
 
-class ListFilesTool(Tool):
-    def __init__(self):
+class ListFilesTool(_StorageTool):
+    def __init__(self, *, mounts: list[_PreparedMount]):
         super().__init__(
             name="list_files_in_room",
             title="list files in room",
@@ -119,17 +574,20 @@ class ListFilesTool(Tool):
                 "required": ["path"],
                 "properties": {"path": {"type": "string"}},
             },
+            mounts=mounts,
         )
 
-    async def execute(self, *, context: ToolContext, path: str):
-        files = await context.room.storage.list(path=path)
+    async def execute(self, context: ToolContext, **kwargs):
+        path = kwargs["path"]
+        resolved = self._resolve_path(path)
+        files = await resolved.mount.list_entries(context=context, resolved=resolved)
         return JsonResponse(
             json={"files": list([f.model_dump(mode="json") for f in files])}
         )
 
 
-class SaveFileFromUrlTool(Tool):
-    def __init__(self):
+class SaveFileFromUrlTool(_StorageTool):
+    def __init__(self, *, mounts: list[_PreparedMount]):
         super().__init__(
             name="save_file_from_url",
             title="save file from url",
@@ -153,40 +611,48 @@ class SaveFileFromUrlTool(Tool):
                     },
                 },
             },
+            mounts=mounts,
         )
 
-    async def execute(
-        self, *, context: ToolContext, url: str, path: str, overwrite: bool
-    ):
+    async def execute(self, context: ToolContext, **kwargs):
+        url = kwargs["url"]
+        path = kwargs["path"]
+        overwrite = kwargs["overwrite"]
+        resolved = self._resolve_path(path)
         blob = await get_bytes_from_url(url=url)
-
-        if not overwrite:
-            result = await context.room.storage.exists(path=path)
-            if result:
-                raise RoomException(
-                    f"a file already exists at the path: {path}, try another filename"
-                )
-
-        handle = await context.room.storage.open(path=path, overwrite=overwrite)
-        try:
-            await context.room.storage.write(handle=handle, data=blob.data)
-        finally:
-            await context.room.storage.close(handle=handle)
+        await resolved.mount.write_bytes(
+            context=context,
+            resolved=resolved,
+            path=path,
+            data=blob.data,
+            overwrite=overwrite,
+        )
 
 
 class StorageToolkit(RemoteToolkit):
-    def __init__(self, read_only: bool = False):
-        if not read_only:
+    def __init__(
+        self,
+        read_only: bool = False,
+        mounts: Optional[list[StorageToolMount]] = None,
+    ):
+        prepared_mounts = _prepare_mounts(mounts)
+        self._mounts = prepared_mounts
+        self._read_only = read_only
+        has_writable_mount = any(
+            not prepared.mount.read_only for prepared in prepared_mounts
+        )
+
+        if read_only or not has_writable_mount:
             tools = [
-                ListFilesTool(),
-                WriteFileTool(),
-                ReadFileTool(),
-                SaveFileFromUrlTool(),
+                ListFilesTool(mounts=prepared_mounts),
+                ReadFileTool(mounts=prepared_mounts),
             ]
         else:
             tools = [
-                ListFilesTool(),
-                ReadFileTool(),
+                ListFilesTool(mounts=prepared_mounts),
+                WriteFileTool(mounts=prepared_mounts),
+                ReadFileTool(mounts=prepared_mounts),
+                SaveFileFromUrlTool(mounts=prepared_mounts),
             ]
         super().__init__(
             name="storage",
@@ -195,16 +661,84 @@ class StorageToolkit(RemoteToolkit):
             tools=tools,
         )
 
+    def _ensure_writable(self, path: str) -> None:
+        if self._read_only:
+            raise RoomException(f"storage toolkit is read-only: {path}")
+
+    def _resolve_path(self, path: str) -> _ResolvedStoragePath:
+        return _resolve_storage_path(self._mounts, path)
+
+    async def read_file(self, *, context: ToolContext, path: str) -> FileResponse:
+        resolved = self._resolve_path(path)
+        return await resolved.mount.read_file(
+            context=context,
+            resolved=resolved,
+            path=path,
+        )
+
+    async def list_entries(
+        self, *, context: ToolContext, path: str
+    ) -> list[StorageEntry]:
+        resolved = self._resolve_path(path)
+        return await resolved.mount.list_entries(context=context, resolved=resolved)
+
+    async def get_download_url(
+        self, *, context: ToolContext, path: str
+    ) -> LinkResponse:
+        resolved = self._resolve_path(path)
+        return await resolved.mount.get_download_url(
+            context=context,
+            resolved=resolved,
+            path=path,
+        )
+
+    async def write_text(
+        self,
+        *,
+        context: ToolContext,
+        path: str,
+        text: str,
+        overwrite: bool,
+    ) -> None:
+        self._ensure_writable(path)
+        resolved = self._resolve_path(path)
+        await resolved.mount.write_text(
+            context=context,
+            resolved=resolved,
+            path=path,
+            text=text,
+            overwrite=overwrite,
+        )
+
+    async def write_bytes(
+        self,
+        *,
+        context: ToolContext,
+        path: str,
+        data: bytes,
+        overwrite: bool,
+    ) -> None:
+        self._ensure_writable(path)
+        resolved = self._resolve_path(path)
+        await resolved.mount.write_bytes(
+            context=context,
+            resolved=resolved,
+            path=path,
+            data=data,
+            overwrite=overwrite,
+        )
+
 
 class StorageToolkitConfig(ToolkitConfig):
-    name: Literal["storage"] = "storage"
+    name: str = "storage"
 
 
 class StorageToolkitBuilder(ToolkitBuilder):
-    def __init__(self):
+    def __init__(self, *, mounts: Optional[list[StorageToolMount]] = None):
         super().__init__(name="storage", type=StorageToolkitConfig)
+        self.mounts = mounts
 
     async def make(
-        self, *, room: RoomClient, model: str, config: ToolkitConfig
+        self, *, room: RoomClient, model: str, config: StorageToolkitConfig
     ) -> Toolkit:
-        return StorageToolkit()
+        return StorageToolkit(mounts=self.mounts)

meshagent/tools/version.py

@@ -1 +1 @@
-__version__ = "0.24.0"
+__version__ = "0.24.3"

{meshagent_tools-0.24.0.dist-info → meshagent_tools-0.24.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-tools
-Version: 0.24.0
+Version: 0.24.3
 Summary: Tools for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,7 +12,7 @@ License-File: LICENSE
 Requires-Dist: pyjwt~=2.10
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: meshagent-api~=0.24.0
+Requires-Dist: meshagent-api~=0.24.3
 Requires-Dist: aiohttp~=3.10
 Requires-Dist: opentelemetry-distro~=0.54b1
 Dynamic: license-file

{meshagent_tools-0.24.0.dist-info → meshagent_tools-0.24.3.dist-info}/RECORD

@@ -8,15 +8,16 @@ meshagent/tools/document_tools.py,sha256=LMULXOSBjsvhKjqzxUxe8586t0Vol0v1Btu5v6o
 meshagent/tools/hosting.py,sha256=l1BCgnSrCJQsWU9Kycq3hEI4ZlYxffDfde6QeJUfko0,10678
 meshagent/tools/multi_tool.py,sha256=hmWZO18Y2tuFG_7rvUed9er29aXleAC-r3YpXBCZWUY,4040
 meshagent/tools/pydantic.py,sha256=n-MD0gC-oRtHSTUDD5IV2dP-xIk-zjcDgHfgjqMgiqM,1161
-meshagent/tools/storage.py,sha256=Y79G__Mp4swJ3tnm-zXtD-SqDeKU9kqHEVoUQH_QedA,7212
+meshagent/tools/script.py,sha256=uHrJynzM0SwUHM1qXIjt-UhZLG4AQtFw-yyLv4lxGGw,10589
+meshagent/tools/storage.py,sha256=NVpi9CZKSZUh8PTxxCdJhJy7Gzmdp55-zo2yHYGod_E,23340
 meshagent/tools/strict_schema.py,sha256=IytdAANa6lsfrsg5FsJuqYrxH9D_fayl-Lc9EwgLJSM,6277
 meshagent/tools/tool.py,sha256=9OAlbfaHqfgJnCDBSW-8PS0Z1K1KjWGD3JBUyiHOxAk,3131
 meshagent/tools/toolkit.py,sha256=rCCkpQBoSkmmhjnRGA4jx0QP-ds6WTJ0PkQVnf1Ls7s,3843
 meshagent/tools/uuid.py,sha256=mzRwDmXy39U5lHhd9wqV4r-ZdS8jPfDTTs4UfW4KHJQ,1342
-meshagent/tools/version.py,sha256=DxtMZD542lg_xb6icrE2d5JOY8oUi-v34i2Ar63ddvs,23
+meshagent/tools/version.py,sha256=FVT3zgMnGxhctio1D7Bj2hvIqrqQQ-a9tvDQYKSSekk,23
 meshagent/tools/web_toolkit.py,sha256=IoOYjOBmcbQsqWT14xYg02jjWpWmGOkDSxt2U-LQoaA,1258
-meshagent_tools-0.24.0.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_tools-0.24.0.dist-info/METADATA,sha256=D8WWKfMis7eEiRprZ2WZTCMyAlSiArWxlD00-VXpGaQ,2878
-meshagent_tools-0.24.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-meshagent_tools-0.24.0.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_tools-0.24.0.dist-info/RECORD,,
+meshagent_tools-0.24.3.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_tools-0.24.3.dist-info/METADATA,sha256=lBDQ02Y_Xaty4w6N018An8Rwg7OQHTSYajbalKekVUo,2878
+meshagent_tools-0.24.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meshagent_tools-0.24.3.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_tools-0.24.3.dist-info/RECORD,,

{meshagent_tools-0.24.0.dist-info → meshagent_tools-0.24.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any