meshagent-tools 0.24.6__py3-none-any.whl → 0.25.1__py3-none-any.whl

meshagent/tools/__init__.py

@@ -16,6 +16,7 @@ from .tool import (
     ToolContext,
     Tool,
     BaseTool,
+    tool,
 )
 
 from .config import ToolkitConfig
@@ -30,6 +31,19 @@ from .hosting import (
 )
 from .multi_tool import MultiTool, MultiToolkit
 from .version import __version__
+from .web_toolkit import (
+    WebFetchConfig,
+    WebFetchTool,
+    WebFetchToolkitBuilder,
+    WebToolkit,
+)
+from .container_shell import (
+    ContainerShellToolConfig,
+    ContainerShellToolkitBuilder,
+    ContainerShellTool,
+)
+
+from .script import ScriptTool, ScriptToolConfig, ScriptToolkitBuilder
 
 from meshagent.api import websocket_protocol, RoomClient, ParticipantToken
 from meshagent.api.websocket_protocol import WebSocketClientProtocol
@@ -52,6 +66,7 @@ __all__ = [
     ToolContext,
     Toolkit,
     Response,
+    tool,
     LinkResponse,
     BaseTool,
     RemoteToolkit,
@@ -64,5 +79,15 @@ __all__ = [
     make_toolkits,
     ToolkitConfig,
     get_bytes_from_url,
+    WebFetchConfig,
+    WebFetchTool,
+    WebFetchToolkitBuilder,
+    WebToolkit,
+    ContainerShellToolConfig,
+    ContainerShellToolkitBuilder,
+    ContainerShellTool,
+    ScriptTool,
+    ScriptToolConfig,
+    ScriptToolkitBuilder,
     __version__,
 ]

meshagent/tools/blob.py

@@ -1,6 +1,6 @@
 from uuid import uuid4
 import base64
-import aiohttp
+from meshagent.api.http import new_client_session
 
 
 class Blob:
@@ -48,7 +48,7 @@ async def get_bytes_from_url(*, url: str) -> Blob:
         # file_name = str(uuid.uuid4())+extension
         return Blob(mime_type=mime_type, data=content)
     else:
-        async with aiohttp.ClientSession() as session:
+        async with new_client_session() as session:
             async with session.get(url=url) as response:
                 content = await response.content.read()
                 return Blob(mime_type=response.content_type, data=content)

meshagent/tools/container_shell.py

@@ -0,0 +1,226 @@
+from meshagent.api import RoomClient
+from .tool import ToolContext, Tool
+from .toolkit import Toolkit, ToolkitBuilder
+
+from meshagent.api.specs.service import ContainerMountSpec, RoomStorageMountSpec
+from typing import Literal, Optional
+import os
+
+import logging
+import asyncio
+from pydantic import BaseModel
+
+logger = logging.getLogger("container_shell_tool")
+
+
+DEFAULT_CONTAINER_MOUNT_SPEC = ContainerMountSpec(
+    room=[RoomStorageMountSpec(path="/data")]
+)
+
+
+class ContainerShellToolConfig(BaseModel):
+    name: Literal["container_shell"] = "container_shell"
+
+
+class ContainerShellToolkitBuilder(ToolkitBuilder):
+    def __init__(
+        self,
+        *,
+        name: str = "container_shell",
+        working_directory: Optional[str] = None,
+        image: Optional[str] = "python:3.13",
+        mounts: Optional[ContainerMountSpec] = DEFAULT_CONTAINER_MOUNT_SPEC,
+        env: Optional[dict[str, str]] = None,
+    ):
+        super().__init__(name=name, type=ContainerShellToolConfig)
+
+        self.working_directory = working_directory
+        self.image = image
+        self.mounts = mounts
+        self.env = env
+
+    async def make(
+        self, *, room: RoomClient, model: str, config: ContainerShellToolConfig
+    ) -> Toolkit:
+        return Toolkit(
+            name=self.name,
+            tools=[
+                ContainerShellTool(
+                    name=self.name,
+                    working_directory=self.working_directory,
+                    image=self.image,
+                    mounts=self.mounts,
+                    env=self.env,
+                )
+            ],
+        )
+
+
+class ContainerShellTool(Tool):
+    def __init__(
+        self,
+        *,
+        name: str = "container_shell",
+        description: Optional[str] = None,
+        title: 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,
+    ):
+        self.working_directory = working_directory
+        self.image = image
+        self.mounts = mounts
+        self._container_id = None
+        self.env = env
+
+        super().__init__(
+            name=name,
+            description=description
+            or "execute shell commands in a container and return the result",
+            title=title,
+            input_schema={
+                "type": "object",
+                "required": ["commands"],
+                "additionalProperties": False,
+                "properties": {
+                    "commands": {"type": "array", "items": {"type": "string"}},
+                    "max_output_length": {"type": "integer"},
+                    "timeout_ms": {"type": "integer"},
+                },
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        **kwargs,
+    ):
+        commands = kwargs.get("commands") or []
+        max_output_length = kwargs.get("max_output_length")
+        timeout_ms = kwargs.get("timeout_ms")
+
+        if not commands:
+            raise Exception("commands is required")
+
+        if self.image is None:
+            raise Exception("container_shell requires an image")
+
+        results = []
+        encoding = os.device_encoding(1) or "utf-8"
+
+        left = 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(timeout_ms) / 1000.0 if timeout_ms else 20 * 1000.0
+
+        running = False
+
+        if self._container_id:
+            for c in await context.room.containers.list():
+                if c.id == self._container_id:
+                    running = True
+
+        if not running:
+            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
+
+        try:
+            logger.info(
+                "executing shell commands in container %s with timeout %s: %s",
+                container_id,
+                timeout,
+                commands,
+            )
+            import shlex
+
+            for command in commands:
+                command_to_run = command
+                if self.working_directory:
+                    command_to_run = (
+                        f"cd {shlex.quote(self.working_directory)} && {command}"
+                    )
+                exec = await context.room.containers.exec(
+                    container_id=container_id,
+                    command=shlex.join(["bash", "-lc", command_to_run]),
+                    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
+
+                        results.append(
+                            {
+                                "outcome": {
+                                    "type": "exit",
+                                    "exit_code": exit_code,
+                                },
+                                "stdout": stdout.decode(),
+                                "stderr": stderr.decode(),
+                            }
+                        )
+
+                except asyncio.TimeoutError:
+                    logger.info("The command timed out after %ss", timeout)
+                    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}",
+                }
+            )
+
+        return {"results": results}

meshagent/tools/database.py

@@ -128,7 +128,7 @@ class UpdateTool(Tool):
         columns = ""
 
         for k, v in schema.items():
-            columns += f"column {k} => {v.to_json()}"
+            columns += f"column {k} => {v.model_dump(mode='json')}"
 
         anyOf = []
 
@@ -500,7 +500,7 @@ class AdvancedSearchTool(Tool):
         columns = ""
 
         for k, v in schema.items():
-            columns += f"column {k} => {v.to_json()}\n"
+            columns += f"column {k} => {v.model_dump(mode='json')}\n"
 
         input_schema = {
             "type": "object",
@@ -542,7 +542,7 @@ class AdvancedDeleteRowsTool(Tool):
         columns = ""
 
         for k, v in schema.items():
-            columns += f"column {k} => {v.to_json()}"
+            columns += f"column {k} => {v.model_dump(mode='json')}"
 
         input_schema = {
             "type": "object",

meshagent/tools/script.py

@@ -1,9 +1,7 @@
 from meshagent.api import RoomClient
-from meshagent.tools import Toolkit, ToolContext, Tool
+from meshagent.tools.tool import Tool, ToolContext
+from meshagent.tools.toolkit import Toolkit, ToolkitBuilder
 
-from meshagent.agents.adapter import (
-    ToolkitBuilder,
-)
 
 from meshagent.api.specs.service import ContainerMountSpec, RoomStorageMountSpec
 from typing import Literal
@@ -311,3 +309,39 @@ class ScriptTool(Tool):
                 )
 
         return {"results": results}
+
+
+async def get_script_tools(room: RoomClient):
+    services = await room.services.list()
+
+    st = []
+
+    for service in services:
+        if service.metadata.annotations is not None:
+            print("X")
+            type = service.metadata.annotations.get("meshagent.tool.type")
+            print(type)
+            commands_str = service.metadata.annotations.get("meshagent.tool.commands")
+            print(commands_str)
+            tool_name = service.metadata.annotations.get(
+                "meshagent.tool.name", service.metadata.name
+            )
+            description = service.metadata.annotations.get(
+                "meshagent.tool.description", service.metadata.description
+            )
+
+            if type == "script" and tool_name is not None:
+                print("FOUND")
+                if commands_str is not None:
+                    commands = commands_str.split("\n")
+
+                    st.append(
+                        ScriptTool(
+                            name=tool_name,
+                            description=description,
+                            service_id=service.id,
+                            commands=commands,
+                        )
+                    )
+
+    return st

meshagent/tools/tests/tool_decorator_test.py

@@ -0,0 +1,45 @@
+import pytest
+from pydantic import BaseModel
+
+from meshagent.api.messaging import JsonResponse
+from meshagent.tools import Toolkit, ToolContext, tool
+
+
+class Payload(BaseModel):
+    name: str
+    count: int
+
+
+class Result(BaseModel):
+    name: str
+    count: int
+    flag: bool
+
+
+@tool(name="make_payload")
+async def make_payload(context: ToolContext, payload: Payload, flag: bool):
+    return Result(name=payload.name, count=payload.count, flag=flag)
+
+
+@pytest.mark.asyncio
+async def test_decorated_tool_executes_with_toolkit():
+    toolkit = Toolkit(name="test", tools=[make_payload])
+    context = ToolContext(room=object(), caller=object())
+
+    result = await toolkit.execute(
+        context=context,
+        name="make_payload",
+        arguments={"payload": {"name": "alpha", "count": 2}, "flag": True},
+    )
+
+    assert isinstance(result, JsonResponse)
+    assert result.json == {"name": "alpha", "count": 2, "flag": True}
+
+
+def test_decorator_schema_is_strict():
+    schema = make_payload.input_schema
+
+    assert schema["type"] == "object"
+    assert schema["additionalProperties"] is False
+    assert "payload" in schema["properties"]
+    assert "flag" in schema["properties"]

meshagent/tools/tool.py

@@ -3,9 +3,15 @@ from meshagent.api.participant import Participant
 import logging
 from abc import ABC
 
-from typing import Optional, Dict, Any, Callable
+from typing import Optional, Dict, Any, Callable, get_type_hints
 
-from meshagent.api.messaging import Response
+import inspect
+
+from pydantic import BaseModel, create_model
+
+from meshagent.tools.strict_schema import ensure_strict_json_schema
+
+from meshagent.api.messaging import Response, ensure_response
 
 
 from opentelemetry import trace
@@ -117,5 +123,84 @@ class Tool(BaseTool):
         if defs is not None:
             openai_schema["$defs"] = {**defs}
 
+    async def invoke(
+        self, context: ToolContext, arguments: dict, attachment: Optional[bytes] = None
+    ) -> Response:
+        return await self.execute(context=context, **arguments)
+
     async def execute(self, context: ToolContext, **kwargs) -> Response:
         raise (Exception("Not implemented"))
+
+
+def tool(
+    *,
+    name: Optional[str] = None,
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    rules: Optional[list[str]] = None,
+    thumbnail_url: Optional[str] = None,
+):
+    def decorator(fn: Callable[..., Response]):
+        signature = inspect.signature(fn)
+        hints = get_type_hints(fn, include_extras=True)
+
+        supports_context = False
+        fields: dict[str, tuple[Any, Any]] = {}
+
+        for param_name, param in signature.parameters.items():
+            annotation = hints.get(param_name, Any)
+            if annotation is ToolContext:
+                supports_context = True
+                continue
+
+            default = param.default if param.default is not inspect._empty else ...
+            fields[param_name] = (annotation, default)
+
+        InputModel = create_model(f"{fn.__name__}Input", **fields)
+        schema = InputModel.model_json_schema()
+        strict_schema = ensure_strict_json_schema(schema)
+
+        tool_name = name or fn.__name__
+        tool_title = title or tool_name
+        tool_description = (
+            description if description is not None else (fn.__doc__ or "").strip()
+        )
+
+        class FunctionTool(Tool):
+            def __init__(self):
+                super().__init__(
+                    name=tool_name,
+                    title=tool_title,
+                    description=tool_description,
+                    rules=rules,
+                    thumbnail_url=thumbnail_url,
+                    input_schema=strict_schema,
+                    supports_context=supports_context,
+                )
+                self.strict = True
+
+            async def invoke(
+                self,
+                context: ToolContext,
+                arguments: dict,
+                attachment: Optional[bytes] = None,
+            ) -> Response:
+                data = InputModel.model_validate(arguments)
+                parsed_args = {field: getattr(data, field) for field in fields}
+
+                if supports_context:
+                    result = fn(context, **parsed_args)
+                else:
+                    result = fn(**parsed_args)
+
+                if inspect.isawaitable(result):
+                    result = await result
+
+                if isinstance(result, BaseModel):
+                    result = result.model_dump(mode="json")
+
+                return ensure_response(result)
+
+        return FunctionTool()
+
+    return decorator

meshagent/tools/toolkit.py

@@ -8,7 +8,7 @@ import json
 
 from typing import Optional, Literal
 from meshagent.tools.config import ToolkitConfig
-from meshagent.tools.tool import ToolContext, BaseTool
+from meshagent.tools.tool import ToolContext, BaseTool, Tool
 
 from opentelemetry import trace
 
@@ -91,7 +91,12 @@ class Toolkit(ToolkitBuilder):
                 schema["$defs"] = {**tool.defs}
 
             validate(arguments, schema)
-            response = await tool.execute(context=context, **arguments)
+            if isinstance(tool, Tool):
+                response = await tool.invoke(
+                    context=context, arguments=arguments, attachment=attachment
+                )
+            else:
+                raise RoomException("tools must extend the Tool class to be invokable")
             response = ensure_response(response)
 
             span.set_attribute("response_type", response.to_json()["type"])

meshagent/tools/version.py

@@ -1 +1 @@
-__version__ = "0.24.6"
+__version__ = "0.25.1"

meshagent/tools/web_toolkit.py

@@ -1,19 +1,29 @@
-from meshagent.api.messaging import TextResponse
-from meshagent.tools import Toolkit, Tool, ToolContext
-from aiohttp import ClientSession
+from __future__ import annotations
+
+import json
+import mimetypes
+import os
+from urllib.parse import urlparse
+
+from meshagent.api.http import new_client_session
+from meshagent.api.messaging import FileResponse, JsonResponse, Response, TextResponse
+from meshagent.tools.config import ToolkitConfig
+from meshagent.tools.tool import Tool, ToolContext
+from meshagent.tools.toolkit import Toolkit, ToolkitBuilder
+from meshagent.api.room_server_client import RoomClient
 
 
 class WebToolkit(Toolkit):
     def __init__(self):
-        super().__init__(tools=[WebFetchTool()])
+        super().__init__(name="web_fetch", tools=[WebFetchTool()])
 
 
 class WebFetchTool(Tool):
     def __init__(self):
         super().__init__(
-            name="get_web_page_text",
-            title="get web page text",
-            description="gets the text of a web page",
+            name="web_fetch",
+            title="web fetch",
+            description="fetches a url and returns text, json, or file content",
             input_schema={
                 "type": "object",
                 "properties": {
@@ -22,21 +32,104 @@ class WebFetchTool(Tool):
                         "description": "the url of the web page (always start it with a proper scheme like https://)",
                     }
                 },
+                "required": ["url"],
                 "additionalProperties": False,
             },
         )
 
-    async def execute(
-        self,
-        *,
-        context: ToolContext,
-        url: str,
-    ) -> str:
-        async with ClientSession() as session:
+    async def execute(self, context: ToolContext, **kwargs: object) -> Response:
+        url = str(kwargs.get("url", ""))
+        if not url:
+            raise ValueError("url is required")
+        async with new_client_session() as session:
             async with session.get(url) as resp:
-                body = await resp.text()
+                if resp.status >= 400:
+                    raise Exception(f"web fetch failed with status {resp.status}")
+
+                content_type = (resp.content_type or "").lower()
+                data = await resp.read()
+
+                if _is_json_content_type(content_type):
+                    text = _decode_text(data=data, charset=resp.charset)
+                    try:
+                        parsed = json.loads(text)
+                    except json.JSONDecodeError:
+                        return TextResponse(text=text)
+
+                    if isinstance(parsed, dict):
+                        return JsonResponse(json=parsed)
+                    return JsonResponse(json={"data": parsed})
+
+                if _is_text_content_type(content_type):
+                    text = _decode_text(data=data, charset=resp.charset)
+                    if content_type == "text/html":
+                        from html_to_markdown import convert
+
+                        text = convert(text)
+                    return TextResponse(text=text)
+
+                if _is_file_content_type(content_type):
+                    filename = _infer_filename(url=url, content_type=content_type)
+                    return FileResponse(
+                        name=filename,
+                        mime_type=content_type or "application/octet-stream",
+                        data=data,
+                    )
+
+                filename = _infer_filename(url=url, content_type=content_type)
+                return FileResponse(
+                    name=filename,
+                    mime_type=content_type or "application/octet-stream",
+                    data=data,
+                )
+
+
+def _decode_text(*, data: bytes, charset: str | None) -> str:
+    encoding = charset or "utf-8"
+    return data.decode(encoding, errors="replace")
+
 
-                from bs4 import BeautifulSoup
+def _is_json_content_type(content_type: str) -> bool:
+    if content_type in {"application/json", "text/json"}:
+        return True
+    return content_type.endswith("+json")
+
+
+def _is_text_content_type(content_type: str) -> bool:
+    if content_type.startswith("text/"):
+        return True
+    return content_type in {
+        "application/xml",
+        "application/xhtml+xml",
+        "application/javascript",
+        "application/x-javascript",
+    }
+
+
+def _is_file_content_type(content_type: str) -> bool:
+    if content_type.startswith("image/"):
+        return True
+    return content_type == "application/pdf"
+
+
+def _infer_filename(*, url: str, content_type: str) -> str:
+    parsed = urlparse(url)
+    basename = os.path.basename(parsed.path)
+    if basename:
+        return basename
+    extension = mimetypes.guess_extension(content_type or "") or ""
+    return f"downloaded-content{extension}"
+
+
+class WebFetchConfig(ToolkitConfig):
+    name: str = "web_fetch"
+
+
+class WebFetchToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="web_fetch", type=WebFetchConfig)
 
-                soup = BeautifulSoup(body, "html.parser")
-                return TextResponse(text=soup.get_text())
+    async def make(
+        self, *, room: RoomClient, model: str, config: WebFetchConfig
+    ) -> Toolkit:
+        return WebToolkit()

{meshagent_tools-0.24.6.dist-info → meshagent_tools-0.25.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-tools
-Version: 0.24.6
+Version: 0.25.1
 Summary: Tools for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,8 +12,9 @@ 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.6
-Requires-Dist: aiohttp~=3.10
+Requires-Dist: meshagent-api~=0.25.1
+Requires-Dist: html-to-markdown~=2.24.3
+Requires-Dist: aiohttp[speedups]~=3.13.0
 Requires-Dist: opentelemetry-distro~=0.54b1
 Dynamic: license-file
 

meshagent_tools-0.25.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+meshagent/tools/__init__.py,sha256=2qAAi4eUVq4q6gXyAGnjQze2Rs9Q9kIJfdm4oEheRPQ,1843
+meshagent/tools/blob.py,sha256=Liw1zdtDc-Viy6Hcgrb4XZ8ULUPEubzShWAdIci0wWI,1505
+meshagent/tools/config.py,sha256=zH2xGxg28K7Tg-aYor6LXdzf0LRxS9iE0679H1FuWhE,79
+meshagent/tools/container_shell.py,sha256=BMcTi_j0-yUPk9ZkVux1j8CxDFmyrCYFn-XeT3S77Ik,7056
+meshagent/tools/database.py,sha256=HWH7_Fm_8GexDJv_T-D6o0yJVUPmE-j31TU2AfcgaPs,18438
+meshagent/tools/datetime.py,sha256=2pOUOWopYIsc5y4EoFo_1PdBaBcTSkeOOs_EqdqYTk0,17503
+meshagent/tools/discovery.py,sha256=f7DJtwIiBQCxByTepsvGM2NRn-9KGxZTZMoTRCKYQ7E,1251
+meshagent/tools/document_tools.py,sha256=LMULXOSBjsvhKjqzxUxe8586t0Vol0v1Btu5v6ofm7A,11755
+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/script.py,sha256=eyQiufoc2ZkTUBTO58VQURnkkQA2lboED5s0-BvAvgM,11811
+meshagent/tools/storage.py,sha256=NVpi9CZKSZUh8PTxxCdJhJy7Gzmdp55-zo2yHYGod_E,23340
+meshagent/tools/strict_schema.py,sha256=IytdAANa6lsfrsg5FsJuqYrxH9D_fayl-Lc9EwgLJSM,6277
+meshagent/tools/tool.py,sha256=HgvlOlz2wMrmD5aaV49fRpnGyXJwnVcH9j4wKaaPbWo,5935
+meshagent/tools/toolkit.py,sha256=iVcCvhwWqmahDow9FN-VRWGo9MEj669Vw7TAB7Mx9Ww,4066
+meshagent/tools/uuid.py,sha256=mzRwDmXy39U5lHhd9wqV4r-ZdS8jPfDTTs4UfW4KHJQ,1342
+meshagent/tools/version.py,sha256=ACu2Z3Q3TFgYpAno_eu9ssJ1QULjNXvjGvyqDSHrQ_o,23
+meshagent/tools/web_toolkit.py,sha256=Seju8gpdUoPku7Yfar_s-cVOnlweFzKj-bFqrQVup8o,4603
+meshagent/tools/tests/tool_decorator_test.py,sha256=Fd4uvoefU8hpdSWaiYen15tqnlwoY092G6hjYafaMGE,1190
+meshagent_tools-0.25.1.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_tools-0.25.1.dist-info/METADATA,sha256=I_DrA3zW7uRwNXwllW8OSipjUKQimC_BgOP4_8xoDBI,2930
+meshagent_tools-0.25.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meshagent_tools-0.25.1.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_tools-0.25.1.dist-info/RECORD,,

meshagent_tools-0.24.6.dist-info/RECORD

@@ -1,23 +0,0 @@
-meshagent/tools/__init__.py,sha256=1zgD5OvAJP10eERoE72VbDu9hFVfAqCWUXw3SiCYFTE,1285
-meshagent/tools/blob.py,sha256=aDW_z8R4HrmrYzAWoWm13Ypqcxcl4rL1Dc0ESnQETLM,1473
-meshagent/tools/config.py,sha256=zH2xGxg28K7Tg-aYor6LXdzf0LRxS9iE0679H1FuWhE,79
-meshagent/tools/database.py,sha256=Jd_YJLPIBsypSK1SziwaYb8xKnG4oafoCDs6vzAC2Oc,18396
-meshagent/tools/datetime.py,sha256=2pOUOWopYIsc5y4EoFo_1PdBaBcTSkeOOs_EqdqYTk0,17503
-meshagent/tools/discovery.py,sha256=f7DJtwIiBQCxByTepsvGM2NRn-9KGxZTZMoTRCKYQ7E,1251
-meshagent/tools/document_tools.py,sha256=LMULXOSBjsvhKjqzxUxe8586t0Vol0v1Btu5v6ofm7A,11755
-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/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=1LERjg6TTlEZCKHKtH82Ox1j8xI8WMA94hEjeTPs1Io,23
-meshagent/tools/web_toolkit.py,sha256=IoOYjOBmcbQsqWT14xYg02jjWpWmGOkDSxt2U-LQoaA,1258
-meshagent_tools-0.24.6.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_tools-0.24.6.dist-info/METADATA,sha256=AzHewWZ3JwdinUT2J0eNarP9N_IPR-GF2fKN13myULI,2878
-meshagent_tools-0.24.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meshagent_tools-0.24.6.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_tools-0.24.6.dist-info/RECORD,,