meshagent-tools 0.19.1__tar.gz → 0.20.5__tar.gz

{meshagent_tools-0.19.1 → meshagent_tools-0.20.5}/CHANGELOG.md

@@ -1,3 +1,43 @@
+## [0.20.5]
+- Stability
+
+## [0.20.4]
+- Stability
+
+## [0.20.3]
+- Stability
+
+## [0.20.2]
+- Stability
+
+## [0.20.1]
+- Stability
+
+## [0.20.0]
+- Breaking: mailbox create/update requests must now include a `public` flag (SDK defaults to `False` when omitted in method calls)
+- Mailbox response models include a `public` field
+- Breaking: service specs now require either `external` or `container` to be set
+- External service specs allow omitting the base URL
+- Service template variables include optional `annotations` metadata
+- CLI mailbox commands support `--public` and include the `public` value in listings
+- Mailbot whitelist parsing accepts comma-separated values
+- Fixed JSON schema generation for database delete/search tools
+
+## [0.19.5]
+- Stability
+
+## [0.19.4]
+- Stability
+
+## [0.19.3]
+- Stability
+
+## [0.19.2]
+- Add boolean data type support plus `nullable`/`metadata` on schema types and generated JSON Schema.
+- BREAKING: OpenAI proxy client creation now takes an optional `http_client` (request logging is configured via a separate logging client helper).
+- Shell tool now reuses a long-lived container with a writable root filesystem, runs commands via `bash -lc`, and defaults to the `python:3.13` image.
+- Add `log_llm_requests` support to enable OpenAI request/response logging.
+
 ## [0.19.1]
 - Add optional metadata to agent chat contexts and propagate it through message-stream LLM delegation, including recording thread participant lists
 - Add an option for the mailbot CLI to delegate LLM interactions to a remote participant instead of using the local LLM adapter

{meshagent_tools-0.19.1/meshagent_tools.egg-info → meshagent_tools-0.20.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-tools
-Version: 0.19.1
+Version: 0.20.5
 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.19.1
+Requires-Dist: meshagent-api~=0.20.5
 Requires-Dist: aiohttp~=3.10
 Requires-Dist: opentelemetry-distro~=0.54b1
 Dynamic: license-file

{meshagent_tools-0.19.1 → meshagent_tools-0.20.5}/meshagent/tools/database.py

@@ -86,14 +86,12 @@ class DeleteRowsTool(Tool):
 
         for k, v in schema.items():
             input_schema["required"].append(k)
-            schema = v.to_json_schema()
-            schema["type"] = [schema["type"], "null"]
-            input_schema["properties"][k] = schema
+            input_schema["properties"][k] = v.to_json_schema()
 
         super().__init__(
             name=f"delete_{table}_rows",
             title=f"delete {table} rows",
-            description=f"search {table} table for rows with the specified values (specify null for a column to exclude it from the search) and then delete them",
+            description=f"delete from {table} where rows match the specified values (specify null for a column to exclude it from the search)",
             input_schema=input_schema,
         )
 
@@ -181,7 +179,7 @@ class SearchTool(Tool):
         self.table = table
         self.namespace = namespace
 
-        input_schema = {
+        query = {
             "type": "object",
             "required": [],
             "additionalProperties": False,
@@ -189,11 +187,28 @@ class SearchTool(Tool):
         }
 
         for k, v in schema.items():
-            input_schema["required"].append(k)
-            schema = v.to_json_schema()
-            schema["type"] = [schema["type"], "null"]
-            input_schema["properties"][k] = schema
+            query["required"].append(k)
+            query["properties"][k] = v.to_json_schema()
 
+        input_schema = {
+            "type": "object",
+            "required": ["query", "limit", "offset", "select"],
+            "additionalProperties": False,
+            "properties": {
+                "query": query,
+                "select": {
+                    "type": "array",
+                    "description": f"the columns to return, available columns: {','.join(schema.keys())}",
+                    "items": {
+                        "type": "string",
+                    },
+                },
+                "limit": {"type": "integer"},
+                "offset": {"type": "integer"},
+            },
+        }
+
+        print(input_schema)
         super().__init__(
             name=f"search_{table}",
             title=f"search {table}",
@@ -201,15 +216,79 @@ class SearchTool(Tool):
             input_schema=input_schema,
         )
 
-    async def execute(self, context: ToolContext, **values):
+    async def execute(
+        self,
+        context: ToolContext,
+        query: object,
+        limit: int,
+        offset: int,
+        select: list[str],
+    ):
         search = {}
 
-        for k, v in values.items():
+        for k, v in query.items():
             if v is not None:
                 search[k] = v
 
         return {
             "rows": await context.room.database.search(
+                select=select,
+                table=self.table,
+                where=search if len(search) > 0 else None,
+                namespace=self.namespace,
+                offset=offset,
+                limit=limit,
+            )
+        }
+
+
+class CountTool(Tool):
+    def __init__(
+        self,
+        *,
+        table: str,
+        schema: dict[str, DataType],
+        namespace: Optional[list[str]] = None,
+    ):
+        self.table = table
+        self.namespace = namespace
+
+        query = {
+            "type": "object",
+            "required": [],
+            "additionalProperties": False,
+            "properties": {},
+        }
+
+        input_schema = {
+            "type": "object",
+            "required": ["query"],
+            "additionalProperties": False,
+            "properties": {
+                "query": query,
+            },
+        }
+
+        for k, v in schema.items():
+            query["required"].append(k)
+            query["properties"][k] = v.to_json_schema()
+
+        super().__init__(
+            name=f"count_{table}",
+            title=f"count_{table}",
+            description=f"count matching rows in the {table} table",
+            input_schema=input_schema,
+        )
+
+    async def execute(self, context: ToolContext, query: object):
+        search = {}
+
+        for k, v in query.items():
+            if v is not None:
+                search[k] = v
+
+        return {
+            "rows": await context.room.database.count(
                 table=self.table,
                 where=search if len(search) > 0 else None,
                 namespace=self.namespace,
@@ -330,6 +409,7 @@ class DatabaseToolkit(RemoteToolkit):
                     )
                 )
 
+            tools.append(CountTool(table=table, schema=schema, namespace=namespace))
             tools.append(SearchTool(table=table, schema=schema, namespace=namespace))
             tools.append(
                 AdvancedSearchTool(table=table, schema=schema, namespace=namespace)

meshagent_tools-0.20.5/meshagent/tools/datetime.py

@@ -0,0 +1,535 @@
+from datetime import datetime, timedelta, timezone
+from typing import Any, Literal, Optional
+from zoneinfo import ZoneInfo
+from .config import ToolkitConfig
+from .tool import Tool
+from .toolkit import ToolContext, ToolkitBuilder
+from .hosting import RemoteToolkit, Toolkit
+from meshagent.api.room_server_client import RoomClient
+
+
+# ----------------------------
+# Helpers
+# ----------------------------
+
+
+def _now_utc() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _get_tz(tz: Optional[str]) -> timezone:
+    """
+    Returns a tzinfo. If tz is None -> UTC.
+    If tz is provided, uses zoneinfo when available; falls back to UTC if unknown.
+    """
+    if not tz:
+        return timezone.utc
+    if ZoneInfo is None:
+        # zoneinfo not available; safest fallback
+        return timezone.utc
+    try:
+        return ZoneInfo(tz)  # type: ignore[arg-type]
+    except Exception:
+        return timezone.utc
+
+
+def _ensure_aware(dt: datetime, tz: Optional[str] = None) -> datetime:
+    """
+    If dt is naive, interpret it in tz (or UTC if tz not provided) and make aware.
+    If aware, leave as-is.
+    """
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=_get_tz(tz))
+    return dt
+
+
+def _to_tz(dt: datetime, tz: Optional[str]) -> datetime:
+    dt = _ensure_aware(dt, tz=None)
+    return dt.astimezone(_get_tz(tz))
+
+
+def _iso(dt: datetime) -> str:
+    """
+    Canonical DB-friendly ISO with offset.
+    """
+    dt = _ensure_aware(dt)
+    # Keep offset; many DBs accept it; if you prefer 'Z', format_utc tool handles that.
+    return dt.isoformat()
+
+
+def _parse_iso(s: str, assume_tz: Optional[str] = None) -> datetime:
+    """
+    Parse ISO-8601-ish strings. If it ends with 'Z', treat as UTC.
+    If parsed datetime is naive, attach assume_tz (or UTC).
+    """
+    s2 = s.strip()
+    if s2.endswith("Z"):
+        s2 = s2[:-1] + "+00:00"
+    dt = datetime.fromisoformat(s2)
+    return _ensure_aware(dt, assume_tz)
+
+
+def _start_of_day(dt: datetime) -> datetime:
+    dt = _ensure_aware(dt)
+    return dt.replace(hour=0, minute=0, second=0, microsecond=0)
+
+
+def _end_of_day(dt: datetime) -> datetime:
+    # inclusive end: 23:59:59.999999
+    dt = _ensure_aware(dt)
+    return dt.replace(hour=23, minute=59, second=59, microsecond=999999)
+
+
+def _start_of_month(dt: datetime) -> datetime:
+    dt = _ensure_aware(dt)
+    return dt.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+
+
+def _end_of_month(dt: datetime) -> datetime:
+    dt = _ensure_aware(dt)
+    # go to first of next month then subtract a microsecond
+    if dt.month == 12:
+        nxt = dt.replace(
+            year=dt.year + 1, month=1, day=1, hour=0, minute=0, second=0, microsecond=0
+        )
+    else:
+        nxt = dt.replace(
+            month=dt.month + 1, day=1, hour=0, minute=0, second=0, microsecond=0
+        )
+    return nxt - timedelta(microseconds=1)
+
+
+def _start_of_week(dt: datetime, week_start: int) -> datetime:
+    """
+    week_start: 0=Mon ... 6=Sun
+    """
+    dt = _ensure_aware(dt)
+    # Python weekday(): Mon=0..Sun=6
+    delta_days = (dt.weekday() - week_start) % 7
+    return _start_of_day(dt - timedelta(days=delta_days))
+
+
+def _end_of_week(dt: datetime, week_start: int) -> datetime:
+    return (
+        _start_of_week(dt, week_start) + timedelta(days=7) - timedelta(microseconds=1)
+    )
+
+
+# ----------------------------
+# Tools
+# ----------------------------
+
+
+class NowTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="now",
+            title="now",
+            description="Get current time. Returns both UTC and (optional) timezone-local ISO strings.",
+            input_schema={
+                "type": "object",
+                "required": ["tz"],
+                "additionalProperties": False,
+                "properties": {
+                    "tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name (e.g. 'America/Los_Angeles'). If omitted, only UTC is returned.",
+                    }
+                },
+            },
+        )
+
+    async def execute(self, context: ToolContext, tz: Optional[str] = None):
+        utc = _now_utc()
+        out: dict[str, Any] = {"utc": _iso(utc)}
+        if tz:
+            out["local"] = _iso(_to_tz(utc, tz))
+            out["tz"] = tz
+        return out
+
+
+class TodayTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="today_range",
+            title="today range",
+            description="Get the start/end of 'today' in a given timezone (defaults to UTC). Useful for date filters.",
+            input_schema={
+                "type": "object",
+                "required": ["tz"],
+                "additionalProperties": False,
+                "properties": {
+                    "tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name (default UTC).",
+                    },
+                },
+            },
+        )
+
+    async def execute(self, context: ToolContext, tz: Optional[str] = None):
+        base = _to_tz(_now_utc(), tz)
+        start = _start_of_day(base)
+        end = _end_of_day(base)
+        return {"start": _iso(start), "end": _iso(end), "tz": tz or "UTC"}
+
+
+class WeekRangeTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="week_range",
+            title="week range",
+            description="Get start/end of the week containing a given datetime (or now), in a timezone. Week start configurable.",
+            input_schema={
+                "type": "object",
+                "required": ["dt", "tz", "week_start"],
+                "additionalProperties": False,
+                "properties": {
+                    "dt": {
+                        "type": ["string", "null"],
+                        "description": "ISO datetime. If omitted, uses now.",
+                    },
+                    "tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name (default UTC).",
+                    },
+                    "week_start": {
+                        "type": "integer",
+                        "description": "0=Mon .. 6=Sun (default 0).",
+                        "minimum": 0,
+                        "maximum": 6,
+                    },
+                },
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        dt: Optional[str] = None,
+        tz: Optional[str] = None,
+        week_start: int = 0,
+    ):
+        base = _to_tz(_parse_iso(dt, assume_tz=tz) if dt else _now_utc(), tz)
+        start = _start_of_week(base, week_start)
+        end = _end_of_week(base, week_start)
+        iso_year, iso_week, iso_wday = base.isocalendar()
+        return {
+            "start": _iso(start),
+            "end": _iso(end),
+            "tz": tz or "UTC",
+            "week_start": week_start,
+            "iso": {"year": iso_year, "week": iso_week, "weekday": iso_wday},
+        }
+
+
+class MonthRangeTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="month_range",
+            title="month range",
+            description="Get start/end of the month containing a given datetime (or now), in a timezone.",
+            input_schema={
+                "type": "object",
+                "required": ["dt", "tz"],
+                "additionalProperties": False,
+                "properties": {
+                    "dt": {
+                        "type": ["string", "null"],
+                        "description": "ISO datetime. If omitted, uses now.",
+                    },
+                    "tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name (default UTC).",
+                    },
+                },
+            },
+        )
+
+    async def execute(
+        self, context: ToolContext, dt: Optional[str] = None, tz: Optional[str] = None
+    ):
+        base = _to_tz(_parse_iso(dt, assume_tz=tz) if dt else _now_utc(), tz)
+        start = _start_of_month(base)
+        end = _end_of_month(base)
+        return {
+            "start": _iso(start),
+            "end": _iso(end),
+            "tz": tz or "UTC",
+            "year": base.year,
+            "month": base.month,
+        }
+
+
+class AddDurationTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="add_duration",
+            title="add duration",
+            description="Add a duration to an ISO datetime. Supports days/hours/minutes/seconds.",
+            input_schema={
+                "type": "object",
+                "required": ["dt", "tz", "days", "hours", "minutes", "seconds"],
+                "additionalProperties": False,
+                "properties": {
+                    "dt": {"type": "string", "description": "Base ISO datetime."},
+                    "tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name. If dt is naive, interpret it in this timezone (default UTC). Also controls output tz.",
+                    },
+                    "days": {"type": "integer"},
+                    "hours": {"type": "integer"},
+                    "minutes": {"type": "integer"},
+                    "seconds": {"type": "integer"},
+                },
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        *,
+        dt: str,
+        tz: Optional[str] = None,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: int = 0,
+    ):
+        base = _parse_iso(dt, assume_tz=tz)
+        base = _to_tz(base, tz)
+        out = base + timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds)
+        return {"dt": _iso(out), "tz": tz or "UTC"}
+
+
+class DiffTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="diff",
+            title="diff",
+            description="Compute dt2 - dt1. Returns seconds, and a simple breakdown.",
+            input_schema={
+                "type": "object",
+                "required": ["dt1", "dt2", "assume_tz"],
+                "additionalProperties": False,
+                "properties": {
+                    "dt1": {"type": "string", "description": "ISO datetime 1."},
+                    "dt2": {"type": "string", "description": "ISO datetime 2."},
+                    "assume_tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name. If either input is naive, interpret it in this timezone (default UTC).",
+                    },
+                },
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        *,
+        dt1: str,
+        dt2: str,
+        assume_tz: Optional[str] = None,
+    ):
+        a = _parse_iso(dt1, assume_tz=assume_tz)
+        b = _parse_iso(dt2, assume_tz=assume_tz)
+        delta = b - a
+        total_seconds = int(delta.total_seconds())
+        sign = -1 if total_seconds < 0 else 1
+        secs = abs(total_seconds)
+
+        days, rem = divmod(secs, 86400)
+        hours, rem = divmod(rem, 3600)
+        minutes, seconds = divmod(rem, 60)
+
+        return {
+            "seconds": total_seconds,
+            "breakdown": {
+                "sign": sign,
+                "days": days,
+                "hours": hours,
+                "minutes": minutes,
+                "seconds": seconds,
+            },
+        }
+
+
+class ParseTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="parse_iso",
+            title="parse iso datetime",
+            description="Parse an ISO datetime string and return normalized ISO plus components.",
+            input_schema={
+                "type": "object",
+                "required": ["dt", "assume_tz", "tz"],
+                "additionalProperties": False,
+                "properties": {
+                    "dt": {
+                        "type": "string",
+                        "description": "ISO datetime (accepts trailing 'Z').",
+                    },
+                    "assume_tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name. If dt is naive, interpret it in this timezone (default UTC).",
+                    },
+                    "tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name. Convert output to this timezone (default keep parsed tz).",
+                    },
+                },
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        *,
+        dt: str,
+        assume_tz: Optional[str] = None,
+        tz: Optional[str] = None,
+    ):
+        parsed = _parse_iso(dt, assume_tz=assume_tz)
+        if tz:
+            parsed = _to_tz(parsed, tz)
+        iso_year, iso_week, iso_wday = parsed.isocalendar()
+        return {
+            "iso": _iso(parsed),
+            "components": {
+                "year": parsed.year,
+                "month": parsed.month,
+                "day": parsed.day,
+                "hour": parsed.hour,
+                "minute": parsed.minute,
+                "second": parsed.second,
+                "microsecond": parsed.microsecond,
+            },
+            "weekday": parsed.weekday(),  # Mon=0..Sun=6
+            "iso_week": {"year": iso_year, "week": iso_week, "weekday": iso_wday},
+            "tz": str(parsed.tzinfo),
+        }
+
+
+class FormatTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="format_dt",
+            title="format datetime",
+            description="Format an ISO datetime using strftime. (Use for human-readable strings.)",
+            input_schema={
+                "type": "object",
+                "required": ["dt", "fmt", "assume_tz", "tz"],
+                "additionalProperties": False,
+                "properties": {
+                    "dt": {"type": "string", "description": "ISO datetime."},
+                    "fmt": {
+                        "type": "string",
+                        "description": "strftime format string, e.g. '%Y-%m-%d %H:%M:%S'.",
+                    },
+                    "assume_tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name. If dt is naive, interpret it in this timezone (default UTC).",
+                    },
+                    "tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name. Convert before formatting (default: keep).",
+                    },
+                },
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        *,
+        dt: str,
+        fmt: str,
+        assume_tz: Optional[str] = None,
+        tz: Optional[str] = None,
+    ):
+        parsed = _parse_iso(dt, assume_tz=assume_tz)
+        if tz:
+            parsed = _to_tz(parsed, tz)
+        return {"text": parsed.strftime(fmt)}
+
+
+class UtcZTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="to_utc_z",
+            title="to utc Z",
+            description="Convert an ISO datetime to UTC and return an RFC3339-ish Z string (e.g. 2026-01-11T12:34:56Z).",
+            input_schema={
+                "type": "object",
+                "required": ["dt", "assume_tz", "drop_microseconds"],
+                "additionalProperties": False,
+                "properties": {
+                    "dt": {"type": "string", "description": "ISO datetime."},
+                    "assume_tz": {
+                        "type": ["string", "null"],
+                        "description": "IANA timezone name. If dt is naive, interpret it in this timezone (default UTC).",
+                    },
+                    "drop_microseconds": {
+                        "type": "boolean",
+                        "description": "Default true.",
+                    },
+                },
+            },
+        )
+
+    async def execute(
+        self,
+        context: ToolContext,
+        *,
+        dt: str,
+        assume_tz: Optional[str] = None,
+        drop_microseconds: bool = True,
+    ):
+        parsed = _parse_iso(dt, assume_tz=assume_tz)
+        u = parsed.astimezone(timezone.utc)
+        if drop_microseconds:
+            u = u.replace(microsecond=0)
+        # emit Z
+        s = u.isoformat().replace("+00:00", "Z")
+        return {"dt": s}
+
+
+# ----------------------------
+# Toolkit
+# ----------------------------
+
+
+class DatetimeToolkit(RemoteToolkit):
+    def __init__(self):
+        tools = [
+            NowTool(),
+            TodayTool(),
+            WeekRangeTool(),
+            MonthRangeTool(),
+            AddDurationTool(),
+            DiffTool(),
+            ParseTool(),
+            FormatTool(),
+            UtcZTool(),
+        ]
+        super().__init__(
+            name="datetime",
+            title="datetime",
+            description="Useful datetime utilities: now/ranges/parse/format/add/diff",
+            tools=tools,
+        )
+
+
+class DatetimeToolkitConfig(ToolkitConfig):
+    name: Literal["datetime"] = "datetime"
+
+
+class DatetimeToolkitBuilder(ToolkitBuilder):
+    def __init__(self):
+        super().__init__(name="datetime", type=DatetimeToolkitConfig)
+
+    async def make(
+        self, *, room: RoomClient, model: str, config: DatetimeToolkitConfig
+    ) -> Toolkit:
+        # no room dependency required; purely local computations
+        return DatetimeToolkit()

meshagent_tools-0.20.5/meshagent/tools/uuid.py

@@ -0,0 +1,43 @@
+import uuid
+from .tool import Tool
+from .toolkit import ToolContext
+from .hosting import RemoteToolkit
+
+
+class UuidV4Tool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="uuid_v4",
+            title="uuid v4",
+            description="Generate UUIDv4 strings (standard 8-4-4-4-12 format).",
+            input_schema={
+                "type": "object",
+                "required": ["count"],
+                "additionalProperties": False,
+                "properties": {
+                    "count": {
+                        "type": "integer",
+                        "description": "How many UUIDs to generate (default 1).",
+                    },
+                },
+            },
+        )
+
+    async def execute(self, context: ToolContext, *, count: int = 1):
+        # uuid.uuid4() returns a UUID object; str(...) yields canonical form:
+        # xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        uuids = [str(uuid.uuid4()) for _ in range(int(count or 1))]
+        if count == 1:
+            return {"uuid": uuids[0]}
+        return {"uuids": uuids, "count": len(uuids)}
+
+
+class UUIDToolkit(RemoteToolkit):
+    def __init__(self):
+        tools = [UuidV4Tool()]
+        super().__init__(
+            name="uuid",
+            title="uuid",
+            description="Generate uuids",
+            tools=tools,
+        )

meshagent_tools-0.20.5/meshagent/tools/version.py

@@ -0,0 +1 @@
+__version__ = "0.20.5"

{meshagent_tools-0.19.1 → meshagent_tools-0.20.5/meshagent_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-tools
-Version: 0.19.1
+Version: 0.20.5
 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.19.1
+Requires-Dist: meshagent-api~=0.20.5
 Requires-Dist: aiohttp~=3.10
 Requires-Dist: opentelemetry-distro~=0.54b1
 Dynamic: license-file

{meshagent_tools-0.19.1 → meshagent_tools-0.20.5}/meshagent_tools.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ meshagent/tools/__init__.py
 meshagent/tools/blob.py
 meshagent/tools/config.py
 meshagent/tools/database.py
+meshagent/tools/datetime.py
 meshagent/tools/discovery.py
 meshagent/tools/document_tools.py
 meshagent/tools/hosting.py
@@ -16,6 +17,7 @@ meshagent/tools/storage.py
 meshagent/tools/strict_schema.py
 meshagent/tools/tool.py
 meshagent/tools/toolkit.py
+meshagent/tools/uuid.py
 meshagent/tools/version.py
 meshagent/tools/web_toolkit.py
 meshagent_tools.egg-info/PKG-INFO

{meshagent_tools-0.19.1 → meshagent_tools-0.20.5}/meshagent_tools.egg-info/requires.txt

@@ -1,6 +1,6 @@
 pyjwt~=2.10
 pytest~=8.4
 pytest-asyncio~=0.26
-meshagent-api~=0.19.1
+meshagent-api~=0.20.5
 aiohttp~=3.10
 opentelemetry-distro~=0.54b1

{meshagent_tools-0.19.1 → meshagent_tools-0.20.5}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
   "pyjwt~=2.10",
   "pytest~=8.4",
   "pytest-asyncio~=0.26",
-  "meshagent-api~=0.19.1",
+  "meshagent-api~=0.20.5",
   "aiohttp~=3.10",
   "opentelemetry-distro~=0.54b1"
 ]

meshagent_tools-0.19.1/meshagent/tools/version.py

@@ -1 +0,0 @@
-__version__ = "0.19.1"