meshagent-api 0.45.7__tar.gz → 0.46.0__tar.gz

{meshagent_api-0.45.7/meshagent_api.egg-info → meshagent_api-0.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-api
-Version: 0.45.7
+Version: 0.46.0
 Summary: Python Server API for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com

{meshagent_api-0.45.7 → meshagent_api-0.46.0}/meshagent/api/client.py

@@ -557,7 +557,6 @@ class SecretVersion(BaseModel):
     id: str
     secret_id: str
     version: int
-    encryption_key_id: str
     value_sha256: Optional[str] = None
     created_by_user_id: Optional[str] = None
     created_by_service_account_id: Optional[str] = None

{meshagent_api-0.45.7 → meshagent_api-0.46.0}/meshagent/api/client_test.py

@@ -916,7 +916,7 @@ def _secret_version_payload(**overrides):
         "id": "version-1",
         "secret_id": "secret-1",
         "version": 1,
-        "encryption_key_id": "key-1",
+        "encryption_key_id": "supabase-vault",
         "value_sha256": None,
         "created_by_user_id": "user-1",
         "created_by_service_account_id": None,
@@ -1059,7 +1059,9 @@ async def test_user_secret_methods_use_new_user_scoped_routes():
     assert fetched.value_base64 == base64.b64encode(b"value").decode()
     assert updated.name == "renamed"
     assert versions[0].version == 1
+    assert not hasattr(versions[0], "encryption_key_id")
     assert created_version.value_sha256 == base64.b64encode(b"hash").decode()
+    assert not hasattr(created_version, "encryption_key_id")
     assert version_value == b"version value"
     assert proxy_access.continuation_token == "next-grants-page"
     assert proxy_access.access_grants[0].subject.type == "service_account"
@@ -1367,7 +1369,9 @@ async def test_service_account_secret_methods_use_service_account_scoped_routes(
     assert fetched.value_base64 == base64.b64encode(b"service value").decode()
     assert updated.http_only is True
     assert versions[0].created_by_service_account_id == "sa-1"
+    assert not hasattr(versions[0], "encryption_key_id")
     assert created_version.id == "version-2"
+    assert not hasattr(created_version, "encryption_key_id")
     assert version_value == b"service version value"
     assert pull_secrets[0].owner_service_account_id == "sa-1"
     assert session.calls == [

{meshagent_api-0.45.7 → meshagent_api-0.46.0}/meshagent/api/crdt.py

@@ -73,7 +73,7 @@ class ServerXmlDocument:
             doc["xml"] = XmlFragment()
         self._root: XmlFragment = doc["xml"]  # fragment not element
         self.doc = doc
-        self._undo_mgr = UndoManager(self._root) if undo else None
+        self._undo_mgr = UndoManager(scopes=[self._root]) if undo else None
         self._notify = notify_changes
 
         # Deep observation (all element / text descendants):contentReference[oaicite:0]{index=0}

{meshagent_api-0.45.7 → meshagent_api-0.46.0}/meshagent/api/room_server_client.py

@@ -25,6 +25,7 @@ from pydantic import (
     Field,
     JsonValue,
     ConfigDict,
+    PositiveInt,
     ValidationError,
     field_validator,
 )
@@ -3152,6 +3153,18 @@ class ServiceRuntimeEvent(BaseModel):
     last_timestamp: float
 
 
+class ServicePortRuntimeState(BaseModel):
+    num: Literal["*"] | PositiveInt
+    liveness: Optional[str] = None
+    liveness_status: Literal["not_configured", "not_ready", "ready"] = "not_configured"
+    last_checked_at: Optional[float] = None
+    last_error: Optional[str] = None
+
+
+class ServiceRuntimeStatus(BaseModel):
+    ports: list[ServicePortRuntimeState] = Field(default_factory=list)
+
+
 class ServiceRuntimeState(BaseModel):
     service_id: str
     state: str
@@ -3163,6 +3176,7 @@ class ServiceRuntimeState(BaseModel):
     last_exit_at: Optional[float] = None
     last_start_error: Optional[str] = None
     last_start_error_at: Optional[float] = None
+    status: ServiceRuntimeStatus = Field(default_factory=ServiceRuntimeStatus)
     events: list[ServiceRuntimeEvent] = Field(default_factory=list)
 
 
@@ -3198,15 +3212,6 @@ class ServicesClient:
 
     async def list(
         self,
-    ) -> List[ServiceSpec]:
-        """
-        Fetch a list of services.
-        """
-
-        return (await self.list_with_state()).services
-
-    async def list_with_state(
-        self,
     ) -> ListServicesResult:
         """
         Fetch a list of services plus runtime state details from the service controller.
@@ -5596,54 +5601,56 @@ class SqliteDatabaseDetails(BaseModel):
     tables: int | None = None
     size_bytes: int | None = None
 
+    model_config = ConfigDict(extra="forbid", strict=True)
+
 
 class _SqliteListDatabasesResponse(BaseModel):
     databases: list[str]
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 class _SqliteListTablesResponse(BaseModel):
     tables: list[str]
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 class _SqliteRowsAffectedResponse(BaseModel):
     rows_affected: int
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 class _SqliteCountResponse(BaseModel):
     count: int
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 class _SqliteStatementResponse(_SqliteRowsAffectedResponse):
     kind: Literal["statement"]
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 class _SqliteCancelResponse(BaseModel):
     status: Literal["cancelled", "cancelling", "not_cancellable"]
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 class _SqliteQueryHeaders(BaseModel):
     kind: Literal["query"]
     query_id: str
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 class _SqliteKindHeaders(BaseModel):
     kind: str
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", strict=True)
 
 
 @dataclass(frozen=True, slots=True)
@@ -7757,7 +7764,10 @@ class SqliteClient:
         )
         if not isinstance(response, JsonContent):
             raise self._unexpected_response_error(operation="inspect_database")
-        return SqliteDatabaseDetails.model_validate(response.json)
+        try:
+            return SqliteDatabaseDetails.model_validate(response.json)
+        except ValidationError as exc:
+            raise self._unexpected_response_error(operation="inspect_database") from exc
 
     async def list_tables(
         self, *, database: str, namespace: Optional[list[str]] = None

{meshagent_api-0.45.7 → meshagent_api-0.46.0}/meshagent/api/room_server_client_test.py

@@ -2577,6 +2577,64 @@ async def test_memory_client_list_validates_typed_response() -> None:
     assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
 
 
+def test_memory_ingest_request_temperature_uses_pydantic_float_coercion() -> None:
+    request_model = room_server_client._MemoryIngestTextRequest
+
+    assert (
+        request_model.model_validate(
+            {"name": "graph", "text": "Alice", "llm_temperature": "0.4"}
+        ).llm_temperature
+        == 0.4
+    )
+    assert (
+        request_model.model_validate(
+            {"name": "graph", "text": "Alice", "llm_temperature": 1}
+        ).llm_temperature
+        == 1.0
+    )
+    assert (
+        request_model.model_validate(
+            {"name": "graph", "text": "Alice", "llm_temperature": True}
+        ).llm_temperature
+        == 1.0
+    )
+    assert (
+        request_model.model_validate(
+            {"name": "graph", "text": "Alice", "llm_temperature": None}
+        ).llm_temperature
+        is None
+    )
+
+    with pytest.raises(ValidationError):
+        request_model.model_validate(
+            {"name": "graph", "text": "Alice", "llm_temperature": ""}
+        )
+
+
+def test_memory_integer_limits_use_pydantic_int_coercion() -> None:
+    ingest_request_model = room_server_client._MemoryIngestFromTableRequest
+    recall_request_model = room_server_client._MemoryRecallRequest
+
+    for value in ["5", "5.0", 5.0, True, False, -1, "-1.0", None]:
+        assert ingest_request_model.model_validate(
+            {"name": "graph", "table": "Entity", "limit": value}
+        ).limit == (value if value is None else int(float(value)))
+
+    for value in ["5", "5.0", 5.0, True, False, -1, "-1.0"]:
+        assert recall_request_model.model_validate(
+            {"name": "graph", "query": "Alice", "limit": value}
+        ).limit == int(float(value))
+
+    with pytest.raises(ValidationError):
+        ingest_request_model.model_validate(
+            {"name": "graph", "table": "Entity", "limit": "5.5"}
+        )
+    with pytest.raises(ValidationError):
+        recall_request_model.model_validate(
+            {"name": "graph", "query": "Alice", "limit": None}
+        )
+
+
 @pytest.mark.asyncio
 async def test_memory_client_uses_room_invoke_for_commands() -> None:
     class _FakeMemoryRoom(_FakeRoom):
@@ -3644,6 +3702,20 @@ async def test_sqlite_client_unexpected_response_uses_error_code() -> None:
 
 @pytest.mark.asyncio
 async def test_sqlite_client_validates_typed_responses() -> None:
+    async def assert_unexpected_response(call: Callable[[], object]) -> None:
+        with pytest.raises(
+            RoomException,
+            match=r"unexpected return type from sqlite\.",
+        ) as ex:
+            result = call()
+            if hasattr(result, "__await__"):
+                await result
+            else:
+                async for _ in result:  # type: ignore[union-attr]
+                    pass
+
+        assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
+
     malformed_databases_client = SqliteClient(
         room=_StaticInvokeRoom(JsonContent(json={"databases": ["app", 2]}))
     )  # type: ignore[arg-type]
@@ -3666,6 +3738,26 @@ async def test_sqlite_client_validates_typed_responses() -> None:
 
     assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
 
+    malformed_inspect_database_client = SqliteClient(
+        room=_StaticInvokeRoom(
+            JsonContent(
+                json={
+                    "name": "app",
+                    "namespace": ["team"],
+                    "tables": "1",
+                    "size_bytes": 1024,
+                }
+            )
+        )
+    )  # type: ignore[arg-type]
+
+    with pytest.raises(
+        RoomException, match="unexpected return type from sqlite.inspect_database"
+    ) as ex:
+        await malformed_inspect_database_client.inspect_database(name="app")
+
+    assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
+
     malformed_query_client = SqliteClient(
         room=_StaticInvokeRoom(
             BinaryContent(
@@ -3687,6 +3779,147 @@ async def test_sqlite_client_validates_typed_responses() -> None:
 
     assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
 
+    await assert_unexpected_response(
+        lambda: (
+            SqliteClient(  # type: ignore[arg-type]
+                room=_StaticInvokeRoom(JsonContent(json={"count": "1"}))
+            )
+            .database("app")
+            .count(table="records")
+        )
+    )
+    await assert_unexpected_response(
+        lambda: (
+            SqliteClient(  # type: ignore[arg-type]
+                room=_StaticInvokeRoom(JsonContent(json={"rows_affected": "2"}))
+            )
+            .database("app")
+            .update(table="records", where="id = ?", values={"name": "x"})
+        )
+    )
+    await assert_unexpected_response(
+        lambda: (
+            SqliteClient(  # type: ignore[arg-type]
+                room=_StaticInvokeRoom(JsonContent(json={"rows_affected": "2"}))
+            )
+            .database("app")
+            .delete(table="records", where="id = ?")
+        )
+    )
+    await assert_unexpected_response(
+        lambda: (
+            SqliteClient(  # type: ignore[arg-type]
+                room=_StaticInvokeRoom(
+                    JsonContent(json={"kind": "statement", "rows_affected": "3"})
+                )
+            )
+            .database("app")
+            .execute_sql(query="DELETE FROM records")
+        )
+    )
+    await assert_unexpected_response(
+        lambda: (
+            SqliteClient(  # type: ignore[arg-type]
+                room=_StaticInvokeRoom(JsonContent(json={"rows_affected": "3"}))
+            )
+            .database("app")
+            .execute_sql_statement(query="DELETE FROM records")
+        )
+    )
+    await assert_unexpected_response(
+        lambda: SqliteClient(  # type: ignore[arg-type]
+            room=_StaticInvokeRoom(JsonContent(json={"status": "bad"}))
+        ).cancel_sql_query(query_id="sqlite-query-1")
+    )
+    await assert_unexpected_response(
+        lambda: (
+            SqliteClient(  # type: ignore[arg-type]
+                room=_StaticInvokeRoom(
+                    BinaryContent(
+                        data=room_server_client._schema_to_arrow_ipc(
+                            pa.schema([pa.field("id", pa.int64())])
+                        ),
+                        headers={"kind": "query", "query_id": 123},
+                    )
+                )
+            )
+            .database("app")
+            .execute_sql(query="SELECT id FROM records")
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_sqlite_client_propagates_stream_errors_and_rejects_malformed_chunks() -> (
+    None
+):
+    class _StaticStreamInvokeRoom:
+        def __init__(self, chunks: list[Content]):
+            self.chunks = chunks
+
+        async def invoke(self, **kwargs) -> AsyncIterable[Content]:
+            del kwargs
+
+            async def stream() -> AsyncIterator[Content]:
+                for chunk in self.chunks:
+                    yield chunk
+
+            return stream()
+
+    malformed_write_client = SqliteClient(
+        room=_StaticStreamInvokeRoom(
+            [BinaryContent(data=b"", headers={"kind": "data"})]
+        )
+    )  # type: ignore[arg-type]
+
+    with pytest.raises(
+        RoomException, match="unexpected return type from sqlite.create_table"
+    ) as ex:
+        await malformed_write_client.database("app").create_table_from_data(
+            name="records",
+            data=pa.table({"id": [1]}),
+        )
+
+    assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
+
+    write_error_client = SqliteClient(
+        room=_StaticStreamInvokeRoom(
+            [ErrorContent(text="write failed", code=ErrorCode.INVALID_REQUEST)]
+        )
+    )  # type: ignore[arg-type]
+
+    with pytest.raises(RoomException, match="write failed") as ex:
+        await write_error_client.database("app").insert(
+            table="records",
+            records=pa.table({"id": [1]}),
+        )
+
+    assert ex.value.code == ErrorCode.INVALID_REQUEST
+
+    malformed_read_client = SqliteClient(
+        room=_StaticStreamInvokeRoom(
+            [BinaryContent(data=b"", headers={"kind": "pull"})]
+        )
+    )  # type: ignore[arg-type]
+
+    with pytest.raises(
+        RoomException, match="unexpected return type from sqlite.search"
+    ) as ex:
+        await malformed_read_client.database("app").search(table="records")
+
+    assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
+
+    read_error_client = SqliteClient(
+        room=_StaticStreamInvokeRoom(
+            [ErrorContent(text="read failed", code=ErrorCode.INVALID_REQUEST)]
+        )
+    )  # type: ignore[arg-type]
+
+    with pytest.raises(RoomException, match="read failed") as ex:
+        await read_error_client.database("app").search(table="records")
+
+    assert ex.value.code == ErrorCode.INVALID_REQUEST
+
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
@@ -4112,7 +4345,7 @@ async def test_services_client_unexpected_response_uses_error_code() -> None:
     with pytest.raises(
         RoomException, match="unexpected return type from services.list"
     ) as ex:
-        await client.list_with_state()
+        await client.list()
 
     assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
 
@@ -4174,7 +4407,7 @@ async def test_services_client_uses_room_invoke_and_translates_service_states()
     room = _InvokeRoom()
     client = ServicesClient(room=room)  # type: ignore[arg-type]
 
-    result = await client.list_with_state()
+    result = await client.list()
 
     assert room.calls == [
         {
@@ -4212,7 +4445,7 @@ async def test_services_client_defaults_missing_service_events() -> None:
         )
     )  # type: ignore[arg-type]
 
-    result = await client.list_with_state()
+    result = await client.list()
 
     assert result.service_states["svc-1"].restart_count == 0
     assert result.service_states["svc-1"].last_start_error is None
@@ -4288,7 +4521,7 @@ async def test_services_client_rejects_nested_service_spec_invalid_payloads() ->
         with pytest.raises(
             RoomException, match="unexpected return type from services.list"
         ) as ex:
-            await client.list_with_state()
+            await client.list()
 
         assert ex.value.code == ErrorCode.UNEXPECTED_RESPONSE_TYPE
 

{meshagent_api-0.45.7 → meshagent_api-0.46.0}/meshagent/api/runtime.py

@@ -96,7 +96,7 @@ class DocumentRuntime(AbstractContextManager):
         self._docs[doc.id] = doc
 
         def send_update_to_backend(bytes: str):
-            runtime.on_document_sync(
+            self.on_document_sync(
                 document_id=doc.id, base64=b64.b64encode(bytes).decode()
             )