attp-client 0.0.8__tar.gz → 0.0.10__tar.gz

{attp_client-0.0.8 → attp_client-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: attp-client
-Version: 0.0.8
+Version: 0.0.10
 Summary: A python-sdk client for interacting with AgentHub's ATTP protocol (Agent Tool Transport Protocol)
 License: MIT
 Author: Ascender Team
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: ascender-framework (>=2.0rc7,<3.0)
-Requires-Dist: attp-core (==0.1.10)
+Requires-Dist: attp-core (==0.1.13)
 Requires-Dist: msgpack (>=1.1.1,<2.0.0)
 Requires-Dist: pydantic (>=2.11.7,<3.0.0)
 Description-Content-Type: text/markdown

{attp_client-0.0.8 → attp_client-0.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "attp-client"
-version = "0.0.8"
+version = "0.0.10"
 description = "A python-sdk client for interacting with AgentHub's ATTP protocol (Agent Tool Transport Protocol)"
 authors = [
     {name = "Ascender Team"}
@@ -10,7 +10,7 @@ readme = "README.md"
 requires-python = ">=3.11,<3.14"
 dependencies = [
     "pydantic (>=2.11.7,<3.0.0)",
-    "attp-core (==0.1.10)",
+    "attp-core (==0.1.13)",
     "msgpack (>=1.1.1,<2.0.0)",
     "ascender-framework (>=2.0rc7,<3.0)"
 ]

{attp_client-0.0.8 → attp_client-0.0.10}/src/attp_client/catalog.py

@@ -28,6 +28,7 @@ class AttpCatalog:
         self.tool_manager = manager
         self.attached_tools = {}
         self.tool_name_to_id_symlink = {}
+        self.disposable = None
         
         self.responder = self.tool_manager.router.responder
     
@@ -59,14 +60,20 @@ class AttpCatalog:
             from reactivex import empty
             return empty()
 
-        self.responder.pipe(
-            ops.filter(lambda item: item.payload is not None and item.correlation_id == 1),
+        self.disposable = self.responder.pipe(
+            ops.filter(lambda item: item.payload is not None and item.route_id == 2),
             ops.map(lambda item: envelopize(item)),
             ops.catch(catch_handler),
             ops.filter(lambda item: item.catalog == self.catalog_name and item.tool_id in self.attached_tools),
             ops.observe_on(scheduler),
         ).subscribe(lambda item: handle_call(item))
     
+    async def handle_callback(self, envelope: IEnvelope) -> Any:
+        if envelope.tool_id not in self.attached_tools:
+            raise NotFoundError(f"Tool {envelope.tool_id} not marked as registered and wasn't found in the catalog {self.catalog_name}.")
+
+        return await self.handle_call(envelope)
+
     async def attach_tool(
         self,
         callback: Callable[[IEnvelope], Any],

attp_client-0.0.10/src/attp_client/client.py

@@ -0,0 +1,207 @@
+import asyncio
+from functools import cached_property
+from logging import Logger, getLogger
+from typing import Any, Callable
+from attp_core.rs_api import AttpClientSession, Limits
+from reactivex import Subject, operators as ops
+from reactivex.scheduler.eventloop import AsyncIOScheduler
+from attp_core.rs_api import PyAttpMessage
+
+from attp_client.catalog import AttpCatalog
+from attp_client.errors.dead_session import DeadSessionError
+from attp_client.inference import AttpInferenceAPI
+from attp_client.interfaces.catalogs.catalog import ICatalogResponse
+from attp_client.interfaces.error import IErr
+from attp_client.misc.serializable import Serializable
+from attp_client.router import AttpRouter
+from attp_client.session import SessionDriver
+from attp_client.tools import ToolsManager
+from attp_client.types.route_mapping import AttpRouteMapping, RouteType
+from attp_client.utils import envelopizer
+
+from attp_core.rs_api import AttpCommand
+
+class ATTPClient:
+    
+    is_connected: bool
+    client: AttpClientSession
+    session: SessionDriver | None
+    routes: list[AttpRouteMapping]
+    inference: AttpInferenceAPI
+    catalogs: list[AttpCatalog]
+
+    def __init__(
+        self,
+        agt_token: str,
+        organization_id: int,
+        *,
+        connection_url: str | None = None,
+        max_retries: int = 20,
+        limits: Limits | None = None,
+        logger: Logger | None = None
+    ):
+        self.__agt_token = agt_token
+        self.organization_id = organization_id
+        self.connection_url = connection_url or "attp://localhost:6563"
+        
+        self.session = None
+        self.max_retries = max_retries
+        self.limits = limits or Limits(max_payload_size=50000)
+        self.client = AttpClientSession(self.connection_url, limits=self.limits)
+        self.logger = logger
+        
+        self.route_increment_index = 2
+        
+        self.responder = Subject[PyAttpMessage]()
+        self.routes = []
+        self.catalogs = []
+        self.disposable = None
+    
+    async def connect(self):
+        # Open the connection
+        client = await self.client.connect(self.max_retries)
+        
+        if not client.session:
+            raise ConnectionError("Failed to connect to ATTP server after 10 attempts!")
+        
+        self.session = SessionDriver(
+            client.session, 
+            agt_token=self.__agt_token, 
+            organization_id=self.organization_id,
+            # route_mappings=self.routes,
+            logger=self.logger or getLogger("Ascender Framework")
+        )
+        asyncio.create_task(self.session.start_listener())
+        # Send an authentication frame as soon as connection estabilishes with agenthub
+        await self.session.authenticate(self.routes)
+        asyncio.create_task(self.session.listen(self.responder))
+        
+        self.router = AttpRouter(self.responder, self.session)
+        self.inference = AttpInferenceAPI(self.router)
+        
+        self.add_event_handler("tools:call", "message", self._tool_callback)
+        
+        
+        
+        self.disposable = self.responder.pipe(
+            ops.subscribe_on(AsyncIOScheduler(asyncio.get_event_loop())),
+        ).subscribe(
+            on_next=lambda item: self.logger.debug(f"Received message on route {item.route_id} with correlation ID {item.correlation_id}"),
+            on_error=lambda e: self.logger.error(f"Error in responder stream: {e}"),
+        )
+
+    async def close(self):
+        if self.session:
+            await self.session.close()
+            self.session = None
+            self.is_connected = False
+
+    @cached_property
+    def tools(self):
+        return ToolsManager(self.router)
+    
+    async def catalog(self, catalog_name: str):
+        if any(c.catalog_name == catalog_name for c in self.catalogs):
+            return next(c for c in self.catalogs if c.catalog_name == catalog_name)
+        
+        catalog = await self.router.send(
+            "tools:catalogs:specific", 
+            Serializable[dict[str, str]]({"catalog_name": catalog_name}),
+            timeout=10,
+            expected_response=ICatalogResponse
+        )
+        self.catalogs.append(
+            AttpCatalog(id=catalog.catalog_id, catalog_name=catalog_name, manager=self.tools)
+        )
+        
+        await self.catalogs[-1].start_tool_listener()
+
+        return self.catalogs[-1] # Return the newly added catalog
+
+    async def close_catalog(self, catalog: AttpCatalog):
+        await catalog.detach_all_tools()
+        self.catalogs.remove(catalog)
+
+    async def _tool_callback(self, message: PyAttpMessage):
+        if not self.session:
+            raise DeadSessionError(self.organization_id)
+        
+        if not message.correlation_id:
+            await self.session.send_error(IErr(
+                detail={"message": "Correlation ID was missing in the message.", "code": "MissingCorrelationId"},
+            ))
+            return
+        
+        print("TOOL CALLBACK MESSAGE:", message.payload)
+        try:
+            envelope = envelopizer.envelopize(message)
+        except ValueError as e:
+            await self.session.send_error(IErr(
+                detail={"message": str(e), "code": "InvalidPayload"},
+            ))
+            return
+
+        catalog = next((c for c in self.catalogs if c.id == envelope.tool_id), None)
+        if not catalog:
+            await self.session.send_error(IErr(
+                detail={"message": f"Catalog with id {envelope.tool_id} not found.", "code": "NotFoundError"},
+            ))
+            return
+
+        response = await catalog.handle_callback(envelope)
+
+        await self.session.respond(route=message.route_id, correlation_id=message.correlation_id, payload=response)
+
+    async def _handle_incoming(self, message: PyAttpMessage):
+        relevant_route = next((route for route in self.routes if route.route_id == message.route_id), None)
+        
+        if not relevant_route:
+            if self.logger:
+                self.logger.warning(f"Received message for unknown route ID {message.route_id}. Ignoring.")
+            return
+        
+        response = await relevant_route.callback(message)
+        
+        if message.command_type == AttpCommand.CALL:
+            if not self.session:
+                raise DeadSessionError(self.organization_id)
+            
+            if not message.correlation_id:
+                await self.session.send_error(IErr(
+                    detail={"message": "Correlation ID was missing in the message.", "code": "MissingCorrelationId"},
+                ))
+                return
+            
+            await self.session.respond(
+                route=message.route_id,
+                correlation_id=message.correlation_id,
+                payload=response
+            )
+    
+    def add_event_handler(
+        self, 
+        pattern: str, 
+        route_type: RouteType,
+        callback: Callable[..., Any],
+    ):
+        if route_type in ["connect", "disconnect"]:
+            self.routes.append(
+                AttpRouteMapping(
+                    pattern=pattern,
+                    route_id=0,
+                    route_type=route_type,
+                    callback=callback
+                )
+            )
+            return
+        
+        self.routes.append(
+            AttpRouteMapping(
+                pattern=pattern, 
+                route_id=self.route_increment_index, 
+                route_type=route_type, 
+                callback=callback
+            )
+        )
+        
+        self.route_increment_index += 1

{attp_client-0.0.8 → attp_client-0.0.10}/src/attp_client/inference.py

@@ -18,6 +18,79 @@ 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 change_chat_agent(
+        self,
+        chat_id: UUID,
+        agent_id: int | None = None,
+        agent_name: str | None = None,
+        timeout: float = 30
+    ) -> dict[str, Any]:
+        """
+        Change the agent associated with a chat.
+
+        Parameters
+        ----------
+        chat_id : UUID
+            The ID of the chat to change the agent for.
+        agent_id : int | None, optional
+            The ID of the new agent to associate with the chat, by default None.
+        agent_name : str | None, optional
+            The name of the new agent to associate with the chat, by default None.
+        timeout : float, optional
+            The timeout for the request, by default 30.
+
+        Returns
+        -------
+        dict[str, Any]
+            The response from the change agent request.
+        """
+        response = await self.router.send(
+            "messages:chat:change_agent",
+            Serializable[dict[str, Any]]({
+                "chat_id": str(chat_id),
+                "agent_id": agent_id,
+                "agent_name": agent_name
+            }),
+            timeout=timeout,
+            expected_response=dict[str, Any]
+        )
+        
+        return response
+    
     async def invoke_inference(
         self,
         agent_id: int | None = None,

{attp_client-0.0.8 → attp_client-0.0.10}/src/attp_client/session.py

@@ -215,7 +215,7 @@ class SessionDriver:
             )
         )
     
-    async def respond(self, correlation_id: bytes, payload: FixedBaseModel | Any | None = None):
+    async def respond(self, route: int | str, correlation_id: bytes, payload: FixedBaseModel | Serializable | Any | None = None):
         """
         For responding to `AttpCommand.CALL`. Used only for correlated requests.
         It sends response (acknowledgement) message signed as `AttpCommand.ACK` to the request.
@@ -227,8 +227,16 @@ class SessionDriver:
         payload : FixedBaseModel | Serializable | None, optional
             Response payload, the data that will be sent, by default None
         """
+        relevant_route = route
+
+        if not self.server_routes:
+            raise UnauthenticatedError(f"Cannot send an ATTP message with acknowledgement to unauthenticated (route_mapping={route})")
+        
+        if isinstance(route, str):
+            relevant_route = resolve_route_by_id("message", route, self.server_routes).route_id
+
         frame = PyAttpMessage(
-            route_id=0,
+            route_id=int(relevant_route),
             command_type=AttpCommand.ACK,
             correlation_id=correlation_id,
             payload=serializer.deserialize(payload),
@@ -310,6 +318,7 @@ class SessionDriver:
         if not self.session:
             raise DeadSessionError(self.organization_id)
         self.session.add_event_handler(self._on_event)
+        
         await asyncio.gather(
             self.session.start_handler(),
             self.session.start_listener()

{attp_client-0.0.8 → attp_client-0.0.10}/src/attp_client/tools.py

@@ -51,7 +51,7 @@ class ToolsManager:
         tool_id: str | Sequence[str]
     ) -> str | list[str]:
         response = await self.router.send(
-            "tool:unregister",
+            "tools:unregister",
             Serializable[dict[str, Any]]({
                 "catalog": catalog_name,
                 "tool_id": tool_id

attp_client-0.0.10/src/attp_client/utils/envelopizer.py

@@ -0,0 +1,9 @@
+from attp_client.interfaces.catalogs.tools.envelope import IEnvelope
+from attp_core.rs_api import PyAttpMessage
+
+
+def envelopize(message: PyAttpMessage) -> IEnvelope:
+    if not message.payload:
+        raise ValueError("Message payload is empty, cannot envelopize.")
+
+    return IEnvelope.mps(message.payload)

attp_client-0.0.8/src/attp_client/client.py

@@ -1,119 +0,0 @@
-import asyncio
-from functools import cached_property
-from logging import Logger, getLogger
-from typing import Any, Callable, Literal
-from attp_core.rs_api import AttpClientSession, Limits
-from reactivex import Subject
-from attp_core.rs_api import PyAttpMessage
-
-from attp_client.catalog import AttpCatalog
-from attp_client.inference import AttpInferenceAPI
-from attp_client.interfaces.catalogs.catalog import ICatalogResponse
-from attp_client.misc.serializable import Serializable
-from attp_client.router import AttpRouter
-from attp_client.session import SessionDriver
-from attp_client.tools import ToolsManager
-from attp_client.types.route_mapping import AttpRouteMapping, RouteType
-
-class ATTPClient:
-    
-    is_connected: bool
-    client: AttpClientSession
-    session: SessionDriver | None
-    routes: list[AttpRouteMapping]
-    inference: AttpInferenceAPI
-    
-    def __init__(
-        self,
-        agt_token: str,
-        organization_id: int,
-        *,
-        connection_url: str | None = None,
-        max_retries: int = 20,
-        limits: Limits | None = None,
-        logger: Logger | None = None
-    ):
-        self.__agt_token = agt_token
-        self.organization_id = organization_id
-        self.connection_url = connection_url or "attp://localhost:6563"
-        
-        self.client = AttpClientSession(self.connection_url)
-        self.session = None
-        self.max_retries = max_retries
-        self.limits = limits or Limits(max_payload_size=50000)
-        self.logger = logger
-        
-        self.route_increment_index = 2
-        
-        self.responder = Subject[PyAttpMessage]()
-        self.routes = []
-    
-    async def connect(self):
-        # Open the connection
-        client = await self.client.connect(self.max_retries, self.limits)
-        
-        if not client.session:
-            raise ConnectionError("Failed to connect to ATTP server after 10 attempts!")
-        
-        self.session = SessionDriver(
-            client.session, 
-            agt_token=self.__agt_token, 
-            organization_id=self.organization_id,
-            # route_mappings=self.routes,
-            logger=self.logger or getLogger("Ascender Framework")
-        )
-        asyncio.create_task(self.session.start_listener())
-        # Send an authentication frame as soon as connection estabilishes with agenthub
-        await self.session.authenticate(self.routes)
-        asyncio.create_task(self.session.listen(self.responder))
-        
-        self.router = AttpRouter(self.responder, self.session)
-        self.inference = AttpInferenceAPI(self.router)
-
-    async def close(self):
-        if self.session:
-            await self.session.close()
-            self.session = None
-            self.is_connected = False
-
-    @cached_property
-    def tools(self):
-        return ToolsManager(self.router)
-    
-    async def catalog(self, catalog_name: str):
-        catalog = await self.router.send(
-            "tools:catalogs:specific", 
-            Serializable[dict[str, str]]({"catalog_name": catalog_name}),
-            timeout=10,
-            expected_response=ICatalogResponse
-        )
-        
-        return AttpCatalog(id=catalog.catalog_id, catalog_name=catalog_name, manager=self.tools)
-    
-    def add_event_handler(
-        self, 
-        pattern: str, 
-        route_type: RouteType,
-        callback: Callable[..., Any],
-    ):
-        if route_type in ["connect", "disconnect"]:
-            self.routes.append(
-                AttpRouteMapping(
-                    pattern=pattern,
-                    route_id=0,
-                    route_type=route_type,
-                    callback=callback
-                )
-            )
-            return
-        
-        self.routes.append(
-            AttpRouteMapping(
-                pattern=pattern, 
-                route_id=self.route_increment_index, 
-                route_type=route_type, 
-                callback=callback
-            )
-        )
-        
-        self.route_increment_index += 1