attp-client 0.0.7__tar.gz → 0.0.9__tar.gz

{attp_client-0.0.7 → attp_client-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: attp-client
-Version: 0.0.7
+Version: 0.0.9
 Summary: A python-sdk client for interacting with AgentHub's ATTP protocol (Agent Tool Transport Protocol)
 License: MIT
 Author: Ascender Team

{attp_client-0.0.7 → attp_client-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "attp-client"
-version = "0.0.7"
+version = "0.0.9"
 description = "A python-sdk client for interacting with AgentHub's ATTP protocol (Agent Tool Transport Protocol)"
 authors = [
     {name = "Ascender Team"}

{attp_client-0.0.7 → attp_client-0.0.9}/src/attp_client/inference.py

@@ -18,6 +18,40 @@ class AttpInferenceAPI:
         self.router = router
         self.logger = logger
     
+    async def create_chat(
+        self,
+        name: str,
+        agent_id: int | None = None,
+        agent_name: str | None = None,
+        mode: str = "agent_autopilot",
+        platform: str = "unknown",
+        responsible: int | None = None,
+        client_id: str | None = None,
+        created_by_id: int | None = None,
+        timeout: float = 30
+    ):
+        """
+        Create chat for inference.
+        TODO: Implement own chat manager for chats, just like I did with catalogs.
+        """
+        response = await self.router.send(
+            "messages:chat:create",
+            Serializable[dict[str, Any]]({
+                "name": name,
+                "agent_id": agent_id,
+                "agent_name": agent_name,
+                "mode": mode,
+                "platform": platform,
+                "responsible": responsible,
+                "client_id": client_id,
+                "created_by_id": created_by_id
+            }),
+            timeout=timeout,
+            expected_response=dict[str, Any]
+        )
+        
+        return response
+    
     async def invoke_inference(
         self,
         agent_id: int | None = None,
@@ -67,13 +101,11 @@ class AttpInferenceAPI:
             raise ValueError("Cannot find agent by two identification specifiers, use only one!")
         
         response = await self.router.send("messages:inference:invoke", Serializable[dict[str, Any]]({
-            "data": {
-                "agent_id": agent_id,
-                "agent_name": agent_name,
-                "input_configuration": input_configuration,
-                "messages": [message.model_dump(mode="json") for message in (messages or [])],
-                "stream": stream
-            }    
+            "agent_id": agent_id,
+            "agent_name": agent_name,
+            "input_configuration": input_configuration,
+            "messages": [message.model_dump(mode="json") for message in (messages or [])],
+            "stream": stream
         }), timeout=timeout, expected_response=IMessageResponse)
         
         return response
@@ -110,10 +142,8 @@ class AttpInferenceAPI:
         response = await self.router.send(
             "messages:chat:invoke", 
             Serializable[dict[str, Any]]({
-                "data": {
-                    "chat_id": str(chat_id),
-                    "stream": stream
-                }
+                "chat_id": str(chat_id),
+                "stream": stream
             }),
             timeout=timeout,
             expected_response=IMessageResponse
@@ -132,6 +162,6 @@ class AttpInferenceAPI:
         """
         if isinstance(message, Sequence):
             for msg in message:
-                await self.router.emit("messages:append", Serializable[dict[str, Any]]({"data": msg}))
+                await self.router.emit("messages:append", msg)
         else:
-            await self.router.emit("messages:append", Serializable[dict[str, Any]]({"data": message}))
+            await self.router.emit("messages:append", message)

{attp_client-0.0.7 → attp_client-0.0.9}/src/attp_client/tools.py

@@ -20,23 +20,23 @@ class ToolsManager:
         return_direct: bool = False,
         schema_ver: str = "1.0",
         timeout_ms: float = 20000,
-        idempotent: bool = False
+        idempotent: bool = False,
+        configs: Any | None = None
     ) -> UUID:
         response = await self.router.send(
             "tools:register",
             Serializable[dict[str, Any]]({
-                "data": {
-                    "catalog": catalog_name,
-                    "tool": {
-                        "name": name,
-                        "description": description,
-                        "schema_id": schema_id,
-                        "return_direct": return_direct,
-                        "schema_ver": schema_ver,
-                        "schema": schema,
-                        "timeout_ms": timeout_ms,
-                        "idempotent": idempotent
-                    }
+                "catalog": catalog_name,
+                "tool": {
+                    "name": name,
+                    "description": description,
+                    "schema_id": schema_id,
+                    "return_direct": return_direct,
+                    "schema_ver": schema_ver,
+                    "schema": schema,
+                    "timeout_ms": timeout_ms,
+                    "idempotent": idempotent,
+                    "config": configs or {}
                 }
             }),
             timeout=30,
@@ -51,12 +51,10 @@ class ToolsManager:
         tool_id: str | Sequence[str]
     ) -> str | list[str]:
         response = await self.router.send(
-            "tool:unregister",
+            "tools:unregister",
             Serializable[dict[str, Any]]({
-                "data": {
-                    "catalog": catalog_name,
-                    "tool_id": tool_id
-                }
+                "catalog": catalog_name,
+                "tool_id": tool_id
             }),
             timeout=30,
             expected_response=dict[str, Any]