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

meshagent/api/specs/service.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, PositiveInt, ConfigDict, model_validator
+from pydantic import BaseModel, PositiveInt, ConfigDict, Field, model_validator
 from typing import Optional, Literal
 from meshagent.api.participant_token import ApiScope
 from meshagent.api.oauth import OAuthClientConfig
@@ -9,9 +9,18 @@ from yaml.loader import SafeLoader
 
 
 class TokenValue(BaseModel):
-    identity: str
-    api: Optional[ApiScope] = None
-    role: Optional[str] = None
+    identity: str = Field(..., description="the name to use in the participant token")
+    api: Optional[ApiScope] = Field(
+        None,
+        description=(
+            "the api permissions that should be granted to this token, set to null "
+            "or omit to use default permissions"
+        ),
+    )
+    role: Optional[str] = Field(
+        None,
+        description="a role to use in the participant token, such as user, agent, or tool",
+    )
 
 
 class EnvironmentVariable(BaseModel):
@@ -22,28 +31,51 @@ class EnvironmentVariable(BaseModel):
 
 
 class RoomStorageMountSpec(BaseModel):
+    """mounts room storage at the specified path using a FUSE mount"""
+
     model_config = ConfigDict(extra="forbid")
-    path: str
-    subpath: Optional[str] = None
+    path: str = Field(
+        ...,
+        description="the path within the container for the room's storage to be mounted to",
+    )
+    subpath: Optional[str] = Field(
+        None, description="mount only a portion of the rooms storage"
+    )
     read_only: bool = False
 
 
 class ProjectStorageMountSpec(BaseModel):
+    """mounts shared project storage at the specified path using a FUSE mount"""
+
     model_config = ConfigDict(extra="forbid")
-    path: str
-    subpath: Optional[str] = None
+    path: str = Field(
+        ...,
+        description="the path within the container for the project storage to be mounted to",
+    )
+    subpath: Optional[str] = Field(
+        None, description="mount only a portion of the project's storage"
+    )
     read_only: bool = True
 
 
 class ImageStorageMountSpec(BaseModel):
+    """mounts a the content of a Docker / OCI image at the specified path within the container"""
+
     model_config = ConfigDict(extra="forbid")
-    image: str
-    path: str
-    subpath: Optional[str] = None
+    image: str = Field(..., description="the tag of an image that will be mounted")
+    path: str = Field(
+        ...,
+        description="the path within the container for the image volume to be mounted to",
+    )
+    subpath: Optional[str] = Field(
+        None, description="mount only a portion of the image volume"
+    )
     read_only: bool = True
 
 
 class FileStorageMountSpec(BaseModel):
+    """mounts a static file into the container at the specified path"""
+
     model_config = ConfigDict(extra="forbid")
     path: str
     text: str
@@ -113,13 +145,24 @@ class ServiceMetadata(BaseModel):
 class ContainerSpec(BaseModel):
     model_config = ConfigDict(extra="forbid")
     image: str
+
     command: Optional[str] = None
     environment: Optional[list[EnvironmentVariable]] = None
-    secrets: Optional[list[str]] = None
-    pull_secret: Optional[str] = None
-    storage: Optional[ContainerMountSpec] = None
+    secrets: Optional[list[str]] = Field(
+        None,
+        description="ids of secrets that contains environment variables for this service to use",
+    )
+    pull_secret: Optional[str] = Field(
+        None,
+        description=(
+            "the id of a pull secret, can be used to pull private container images"
+        ),
+    )
+    storage: Optional[ContainerMountSpec] = Field(
+        None, description="storage mounts that should be provided to this container"
+    )
     api_key: Optional[ServiceApiKeySpec] = None
-    on_demand: Optional[bool] = None
+    on_demand: Optional[bool] = Field(None, description="an on demand service")
     writable_root_fs: Optional[bool] = None
 
 
@@ -133,11 +176,26 @@ class ServiceSpec(BaseModel):
     version: Literal["v1"]
     kind: Literal["Service"]
     id: Optional[str] = None
-    metadata: ServiceMetadata
-    agents: Optional[list[AgentSpec]] = None
-    ports: Optional[list["PortSpec"]] = []
-    container: Optional[ContainerSpec] = None
-    external: Optional[ExternalServiceSpec] = None
+    metadata: ServiceMetadata = Field(..., description="service metadata")
+    agents: Optional[list[AgentSpec]] = Field(
+        None, description="a list of agents that will be exposed by this service"
+    )
+    ports: Optional[list["PortSpec"]] = Field(
+        default_factory=list,
+        description="a list of ports that are exposed by this service",
+    )
+    container: Optional[ContainerSpec] = Field(
+        None,
+        description=(
+            "container based services run agents in sandboxed containers inside the room"
+        ),
+    )
+    external: Optional[ExternalServiceSpec] = Field(
+        None,
+        description=(
+            "external services allow discovery of externally hosted agents, mcp servers, and tools"
+        ),
+    )
 
     @model_validator(mode="after")
     def require_one_of(cls, m):
@@ -152,8 +210,17 @@ class ServiceSpec(BaseModel):
 
 class MeshagentEndpointSpec(BaseModel):
     model_config = ConfigDict(extra="forbid")
-    identity: str
-    api: Optional[ApiScope] = None
+
+    identity: str = Field(
+        ...,
+        description="the name to use for the participant token provided to this endpoint",
+    )
+    api: Optional[ApiScope] = Field(
+        None,
+        description=(
+            "customize the permissions available to this endpoint, omit to use default agent permissions"
+        ),
+    )
 
 
 class AllowedMcpToolFilter(BaseModel):
@@ -175,8 +242,16 @@ class MCPEndpointSpec(BaseModel):
 
 class EndpointSpec(BaseModel):
     model_config = ConfigDict(extra="forbid")
-    path: str
-    meshagent: Optional[MeshagentEndpointSpec] = None
+    path: str = Field(
+        ...,
+        description="the path that should receive a webhook call when the service starts",
+    )
+    meshagent: Optional[MeshagentEndpointSpec] = Field(
+        None,
+        description=(
+            "meshagent endpoints will be automatically notified when the service starts in order to call an agent or tool into the room"
+        ),
+    )
     mcp: Optional[MCPEndpointSpec] = None
 
 
@@ -184,9 +259,33 @@ class PortSpec(BaseModel):
     model_config = ConfigDict(extra="forbid")
     num: Literal["*"] | PositiveInt = "*"
     type: Optional[Literal["http", "tcp"]] = "http"
-    endpoints: list[EndpointSpec] = []
-    liveness: Optional[str] = None
-    host_port: Optional[PositiveInt] = None
+    endpoints: list[EndpointSpec] = Field(
+        default_factory=list, description="a list of endpoints exposed under this port"
+    )
+    liveness: Optional[str] = Field(
+        None,
+        description=(
+            "a path that will accept a HTTP request and should return 200 when the port is live"
+        ),
+    )
+    host_port: Optional[PositiveInt] = Field(
+        None,
+        description=(
+            "expose a host port for this service, allows traffic to be tunneled to the container with port forwarding"
+        ),
+    )
+    published: Optional[bool] = Field(
+        None,
+        description=(
+            "allow traffic to be routed directly to this container from the internet, useful for implementing patterns such as webhooks"
+        ),
+    )
+    public: Optional[bool] = Field(
+        None,
+        description=(
+            "if a port is not public it will require a participant token to be passed as a Bearer token in the Authorization header"
+        ),
+    )
 
 
 class ServiceTemplateVariable(BaseModel):

meshagent/api/sql.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from meshagent.api.room_server_client import (
+    BinaryDataType,
+    BoolDataType,
+    DataTypeUnion,
+    DateDataType,
+    FloatDataType,
+    IntDataType,
+    TextDataType,
+    TimestampDataType,
+    VectorDataType,
+)
+
+TABLE_SCHEMA_GRAMMAR = """
+TABLE_SCHEMA  := COLUMN_DEF ("," COLUMN_DEF)*
+COLUMN_DEF    := IDENTIFIER TYPE_SPEC NULLABILITY?
+TYPE_SPEC     := SIMPLE_TYPE | VECTOR_TYPE
+SIMPLE_TYPE   := "int" | "bool" | "date" | "timestamp" | "float" | "text" | "binary"
+VECTOR_TYPE   := "vector" "(" INT ("," TYPE_SPEC)? ")"
+NULLABILITY   := "null" | "not" "null"
+IDENTIFIER    := /[A-Za-z_][A-Za-z0-9_]*/
+INT           := /[0-9]+/
+""".strip()
+
+ALLOWED_DATA_TYPES = (
+    "int",
+    "bool",
+    "date",
+    "timestamp",
+    "float",
+    "text",
+    "binary",
+    "vector",
+)
+
+
+@dataclass(frozen=True)
+class _Token:
+    kind: str
+    value: str
+    position: int
+
+
+class SchemaParseError(ValueError):
+    pass
+
+
+def parse_table_schema(source: str) -> dict[str, DataTypeUnion]:
+    tokens = _tokenize(source)
+    parser = _SchemaParser(tokens)
+    schema = parser.parse_schema()
+    parser.ensure_end()
+    return schema
+
+
+class _SchemaParser:
+    def __init__(self, tokens: Iterable[_Token]):
+        self._tokens = list(tokens)
+        self._index = 0
+
+    def parse_schema(self) -> dict[str, DataTypeUnion]:
+        schema: dict[str, DataTypeUnion] = {}
+        while True:
+            name, data_type = self._parse_column_def()
+            if name in schema:
+                raise SchemaParseError(f"Duplicate column name: {name}")
+            schema[name] = data_type
+            if not self._accept("COMMA"):
+                break
+        return schema
+
+    def parse_type(self) -> DataTypeUnion:
+        token = self._peek()
+        if token is None or token.kind != "IDENT":
+            raise self._error("Expected data type")
+        type_name = token.value.casefold()
+        if type_name == "vector":
+            self._advance()
+            return self._parse_vector_type()
+        if type_name not in ALLOWED_DATA_TYPES:
+            raise self._error(
+                f"Unsupported data type '{token.value}'. Allowed: {', '.join(ALLOWED_DATA_TYPES)}"
+            )
+        self._advance()
+        return _simple_type(type_name)
+
+    def parse_schema_type(self) -> DataTypeUnion:
+        return self.parse_type()
+
+    def parse_schema_type_with_nullability(self) -> DataTypeUnion:
+        data_type = self.parse_schema_type()
+        if self._accept("IDENT", "null"):
+            data_type.nullable = True
+        elif self._accept("IDENT", "not"):
+            self._expect("IDENT", "null")
+            data_type.nullable = False
+        return data_type
+
+    def ensure_end(self) -> None:
+        if self._peek() is not None:
+            token = self._peek()
+            raise SchemaParseError(
+                f"Unexpected token '{token.value}' at position {token.position}"
+            )
+
+    def _parse_column_def(self) -> tuple[str, DataTypeUnion]:
+        name_token = self._expect("IDENT")
+        data_type = self.parse_schema_type_with_nullability()
+        return name_token.value, data_type
+
+    def _parse_vector_type(self) -> DataTypeUnion:
+        self._expect("LPAREN")
+        size_token = self._expect("INT")
+        size = int(size_token.value)
+        if size <= 0:
+            raise self._error("Vector size must be a positive integer")
+        element_type = FloatDataType()
+        if self._accept("COMMA"):
+            element_type = self.parse_schema_type()
+        self._expect("RPAREN")
+        return VectorDataType(size=size, element_type=element_type)
+
+    def _expect(self, kind: str, value: str | None = None) -> _Token:
+        token = self._peek()
+        if token is None:
+            raise self._error("Unexpected end of input")
+        if token.kind != kind or (
+            value is not None and token.value.casefold() != value.casefold()
+        ):
+            expected = f"{kind}{' ' + value if value else ''}"
+            raise self._error(f"Expected {expected}")
+        self._index += 1
+        return token
+
+    def _accept(self, kind: str, value: str | None = None) -> bool:
+        token = self._peek()
+        if token is None:
+            return False
+        if token.kind != kind:
+            return False
+        if value is not None and token.value.casefold() != value.casefold():
+            return False
+        self._index += 1
+        return True
+
+    def _peek(self) -> _Token | None:
+        if self._index >= len(self._tokens):
+            return None
+        return self._tokens[self._index]
+
+    def _advance(self) -> _Token:
+        token = self._peek()
+        if token is None:
+            raise self._error("Unexpected end of input")
+        self._index += 1
+        return token
+
+    def _error(self, message: str) -> SchemaParseError:
+        token = self._peek()
+        if token is None:
+            return SchemaParseError(f"{message} at end of input")
+        return SchemaParseError(f"{message} at position {token.position}")
+
+
+def _tokenize(source: str) -> list[_Token]:
+    tokens: list[_Token] = []
+    idx = 0
+    length = len(source)
+    while idx < length:
+        char = source[idx]
+        if char.isspace():
+            idx += 1
+            continue
+        if char == ",":
+            tokens.append(_Token("COMMA", char, idx))
+            idx += 1
+            continue
+        if char == "(":
+            tokens.append(_Token("LPAREN", char, idx))
+            idx += 1
+            continue
+        if char == ")":
+            tokens.append(_Token("RPAREN", char, idx))
+            idx += 1
+            continue
+        if char.isdigit():
+            start = idx
+            while idx < length and source[idx].isdigit():
+                idx += 1
+            tokens.append(_Token("INT", source[start:idx], start))
+            continue
+        if char.isalpha() or char == "_":
+            start = idx
+            while idx < length and (source[idx].isalnum() or source[idx] == "_"):
+                idx += 1
+            tokens.append(_Token("IDENT", source[start:idx], start))
+            continue
+        raise SchemaParseError(f"Unexpected character '{char}' at position {idx}")
+    return tokens
+
+
+def _simple_type(type_name: str) -> DataTypeUnion:
+    if type_name == "int":
+        return IntDataType()
+    if type_name == "bool":
+        return BoolDataType()
+    if type_name == "date":
+        return DateDataType()
+    if type_name == "timestamp":
+        return TimestampDataType()
+    if type_name == "float":
+        return FloatDataType()
+    if type_name == "text":
+        return TextDataType()
+    if type_name == "binary":
+        return BinaryDataType()
+    raise SchemaParseError(
+        f"Unsupported data type '{type_name}'. Allowed: {', '.join(ALLOWED_DATA_TYPES)}"
+    )

meshagent/api/sql_test.py

@@ -0,0 +1,38 @@
+import pytest
+
+from meshagent.api.room_server_client import (
+    FloatDataType,
+    IntDataType,
+    TextDataType,
+    VectorDataType,
+)
+from meshagent.api.sql import SchemaParseError, parse_table_schema
+
+
+def test_parse_schema_case_insensitive():
+    schema = parse_table_schema("names VeCtOr(20) nUlL, test TeXT NoT NuLL, age INT")
+
+    assert isinstance(schema["names"], VectorDataType)
+    assert schema["names"].size == 20
+    assert schema["names"].nullable is True
+    assert isinstance(schema["names"].element_type, FloatDataType)
+
+    assert isinstance(schema["test"], TextDataType)
+    assert schema["test"].nullable is False
+
+    assert isinstance(schema["age"], IntDataType)
+    assert schema["age"].nullable is None
+
+
+def test_parse_schema_vector_element_type_case_insensitive():
+    schema = parse_table_schema("embedding vector(3, FLOAT)")
+    column = schema["embedding"]
+
+    assert isinstance(column, VectorDataType)
+    assert column.size == 3
+    assert isinstance(column.element_type, FloatDataType)
+
+
+def test_parse_schema_duplicate_columns():
+    with pytest.raises(SchemaParseError, match="Duplicate column name"):
+        parse_table_schema("id int, id text")

meshagent/api/urls.py

@@ -8,7 +8,7 @@ def meshagent_base_url(base_url: Optional[str] = None):
 
 def websocket_room_url(*, room_name: str, base_url: Optional[str] = None) -> str:
     if base_url is None:
-        api_url = os.getenv("MESHAGENT_API_URL")
+        api_url = os.getenv("MESHAGENT_ROOM_URL", os.getenv("MESHAGENT_API_URL"))
         if api_url is None:
             base_url = "wss://api.meshagent.com"
         else:

meshagent/api/version.py

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

meshagent/api/websocket_protocol.py

@@ -4,6 +4,7 @@ import asyncio
 import logging
 import urllib
 from meshagent.api.version import __version__
+from meshagent.api.http import new_client_session
 from typing import Optional
 
 from meshagent.api.protocol import Protocol, ClientProtocol
@@ -12,19 +13,31 @@ logger = logging.getLogger("protocol.websocket")
 
 
 class WebSocketClientProtocol(ClientProtocol):
-    def __init__(self, *, url: str, token: str, heartbeat: float = 30):
+    def __init__(
+        self,
+        *,
+        url: str,
+        token: str,
+        heartbeat: float = 30,
+        session: ClientSession | None = None,
+    ):
         super().__init__(token=token)
         self._url = url
         self._heartbeat = heartbeat
+        self._session = session
+        self._session_external = session is not None
 
     @property
     def url(self):
         return self._url
 
     async def __aenter__(self):
-        self._session = ClientSession()
+        if self._session is None:
+            self._session = new_client_session()
+            self._session_external = False
 
-        await self._session.__aenter__()
+        if not self._session_external:
+            await self._session.__aenter__()
 
         url_parts = urllib.parse.urlparse(self._url)
         query_dict = urllib.parse.parse_qs(url_parts.query)
@@ -70,7 +83,8 @@ class WebSocketClientProtocol(ClientProtocol):
         if not self._ws.closed:
             await self._ws.close()
         await self._ws_recv_task
-        await self._session.__aexit__(exc_type, exc, tb)
+        if not self._session_external:
+            await self._session.__aexit__(exc_type, exc, tb)
         await self._ws_ctx.__aexit__(exc_type, exc, tb)
         await super().__aexit__(exc_type, exc, tb)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-api
-Version: 0.24.6
+Version: 0.25.1
 Summary: Python Server API for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -10,12 +10,13 @@ Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyjwt~=2.10
-Requires-Dist: aiohttp~=3.10
+Requires-Dist: aiohttp[speedups]~=3.13.0
 Requires-Dist: jsonschema~=4.23
 Requires-Dist: pycrdt~=0.12.26
 Requires-Dist: opentelemetry-distro~=0.54b1
 Requires-Dist: pydantic~=2.11.7
 Requires-Dist: jinja2~=3.1.6
+Requires-Dist: certifi~=2026.1.4
 Provides-Extra: all
 Provides-Extra: sync
 Provides-Extra: stpyv8

{meshagent_api-0.24.6.dist-info → meshagent_api-0.25.1.dist-info}/RECORD

@@ -1,21 +1,22 @@
 meshagent/api/__init__.py,sha256=kzhnEnzNjm4yUztR4aY78h1mxZxkvXGeWIvxOA2rDxY,2037
 meshagent/api/chan.py,sha256=PBIfVHj_znsmlZ0zxvmglCrX_4m7zzPLhxWRycfyEgc,4763
-meshagent/api/client.py,sha256=Lkjh3KQYWEEd80FQuhwHTbqZlW8INDW7iIC9cwz1WoI,75387
+meshagent/api/client.py,sha256=4aHj3BI6y1UE0jAHPh4m6-X_F4iOe39IwrC2Y-esqFQ,76362
 meshagent/api/crdt.py,sha256=1d_bjIR8iYfktHBW04dfaaiXWA6ZYCfgfxCmDHXivGk,18580
 meshagent/api/entrypoint.js,sha256=82XGHgopru9fyzi3V5JFy6YoaV0OmlsczXE9OdHjYgw,85567
-meshagent/api/helpers.py,sha256=bwMHDA9PmNZmVTKiMsGef3sQVq3LiyRoi8plJhBxwME,3270
+meshagent/api/helpers.py,sha256=5tU0k1DcWZMcZy2dlA3qJ5Ifs5Au4TEsBontKHa43y4,3365
+meshagent/api/http.py,sha256=gooHy2PIpP4Upnbxn_TZ5D3si6dixsG5piPbFzdGXEI,413
 meshagent/api/keys.py,sha256=VkRo0tH3uEMgCDnUg7640oDQkruGoE1AItb9g-Jjg9c,2950
 meshagent/api/messaging.py,sha256=0vCmdxwtki9rHKrON427r2TTbXdyW9iEluQ3fAyjMYU,8844
 meshagent/api/oauth.py,sha256=ezwtsdM76FWFGIZeUhJ5z02tOTh-ve7djHPe-PuzGVU,460
 meshagent/api/participant.py,sha256=usyXHK42Swobb76SRNHZrfB3w4h0P8tGmzGRrOJCw-k,341
-meshagent/api/participant_token.py,sha256=QZFmWV-5ycSFvqv_uXeNzgPJfuoPpAqa5-XXcXp-_f4,13716
+meshagent/api/participant_token.py,sha256=i5trPgWtCxG380GIMz7xGvYbDiyLsO8jeuztBMmxeEs,13893
 meshagent/api/participant_token_test.py,sha256=EeMuw47iR1N2mBxVZRAhhiWYtN9BvIT80fAoZAN-VqQ,6998
-meshagent/api/port_forward.py,sha256=X2NBvAv6_6Ggs0vWsW6RBI0n_TviSePVM15cW_zQzlE,5050
+meshagent/api/port_forward.py,sha256=WijWKs14kMabW97GjjBXTdB0dg7_mdlCWeNk7KW91e4,5097
 meshagent/api/protocol.py,sha256=1N82ZQmSTg_XIf5yrjAo3QVEmW9yT29JctWTwzoVDzA,10571
 meshagent/api/protocol_test.py,sha256=3ETAAAEzuqhFW26xYPxE7Pj1_Us6dHlifgp1W2QiwFs,1428
 meshagent/api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 meshagent/api/reasoning_schema.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-meshagent/api/room_server_client.py,sha256=51dwjpLyxdLRmFNIuh8ud2Qeker8ibvpWMWqq2hdnt8,103727
+meshagent/api/room_server_client.py,sha256=vRpFealzUkRnQsMd8OPc-Rd738hUXJM9ukooHMrjsHM,105259
 meshagent/api/runtime.py,sha256=H0pcZHefjDBFMZgZMeAW7dKUtYrrrKI7Fb8_vvI7o4s,11355
 meshagent/api/runtime_test.py,sha256=hQSp2fz2CT94cGg3-yeyFMK5F7jrIXRDoEtn15A5h4k,10807
 meshagent/api/schema.py,sha256=Y0A1QRk6_hG3zP81Qv7rFO01y2mbNqyvD1sKDyhEJfM,11673
@@ -26,14 +27,16 @@ meshagent/api/schema_test.py,sha256=lYi7AGm5LD8aVMKzGFdN_o219kifb3_laETXAvC7KJI,
 meshagent/api/schema_util.py,sha256=-vtbWKfolYK0946HAGfD5xYmQ0qHJftcPcMBLPtzs1I,1371
 meshagent/api/service_template_test.py,sha256=N348oZzlOiLR4GZNTiiLyEXXWq8Btapg6C3oymtVo8g,6145
 meshagent/api/services.py,sha256=LPJqGuwN0zZgZWIiJqkf6Kh0lyKn9s1z-SEuX2oPw10,11365
+meshagent/api/sql.py,sha256=b3q2xO0yn88S31vha-WZBVEYHUxPcrKR9OcY6dcKXcI,6886
+meshagent/api/sql_test.py,sha256=sDX4vVNRez0EE09J0yPYMuKYJi8dG4eUSE21bBox0sg,1186
 meshagent/api/token_test.py,sha256=KGa-lDMAsB3QST_6ORCPGSOHPnhm6WSTA4uj4ZYgrPY,3719
-meshagent/api/urls.py,sha256=Vxs4Fg4fLfZASmsqAeZtY3u-7vFDx9rH7m7HtQKPg64,712
-meshagent/api/version.py,sha256=1LERjg6TTlEZCKHKtH82Ox1j8xI8WMA94hEjeTPs1Io,23
+meshagent/api/urls.py,sha256=g7w-1nzbcRzJVbxp2M8TiT8pz7NLVfSamrEkr0NDiKc,745
+meshagent/api/version.py,sha256=ACu2Z3Q3TFgYpAno_eu9ssJ1QULjNXvjGvyqDSHrQ_o,23
 meshagent/api/webhooks.py,sha256=6ZKUgc-uXzg6V2DBy-yAvOsb1dXxUVEPTqj36A9w_6Y,8352
-meshagent/api/websocket_protocol.py,sha256=I4NYrSnkohpHi7wYbKAwQsgT2HTH_xWmu5_JDRlpeEQ,3760
-meshagent/api/specs/service.py,sha256=iobqfBMcg5w4ndyqUzyez9RtPTBYB5oGVZf4wLLVeqE,11615
-meshagent_api-0.24.6.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_api-0.24.6.dist-info/METADATA,sha256=LJMo9u_WN9MXBQBsquC956TcHh25MfsKd-PVGpKRvOg,4540
-meshagent_api-0.24.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meshagent_api-0.24.6.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_api-0.24.6.dist-info/RECORD,,
+meshagent/api/websocket_protocol.py,sha256=f9IV6goyRvpbOTIsziOd5_aXujikHuSiTSXk2Q0dXTA,4160
+meshagent/api/specs/service.py,sha256=XIBS9MFmG-k8aeY7JV-_IBFtu0TQUADn2418waGyqHc,15398
+meshagent_api-0.25.1.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_api-0.25.1.dist-info/METADATA,sha256=qwHM_KI6GF4R8DC1fgycj4wsj560z45HMy2_g_O0VJA,4585
+meshagent_api-0.25.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meshagent_api-0.25.1.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_api-0.25.1.dist-info/RECORD,,