attp-client 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

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/client.py

@@ -1,19 +1,25 @@
 import asyncio
 from functools import cached_property
 from logging import Logger, getLogger
-from typing import Any, Callable, Literal
+from typing import Any, Callable
 from attp_core.rs_api import AttpClientSession, Limits
-from reactivex import Subject
+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:
     
@@ -22,7 +28,8 @@ class ATTPClient:
     session: SessionDriver | None
     routes: list[AttpRouteMapping]
     inference: AttpInferenceAPI
-    
+    catalogs: list[AttpCatalog]
+
     def __init__(
         self,
         agt_token: str,
@@ -37,20 +44,22 @@ class ATTPClient:
         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.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, self.limits)
+        client = await self.client.connect(self.max_retries)
         
         if not client.session:
             raise ConnectionError("Failed to connect to ATTP server after 10 attempts!")
@@ -69,6 +78,17 @@ class ATTPClient:
         
         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:
@@ -81,14 +101,82 @@ class ATTPClient:
         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)
         
-        return AttpCatalog(id=catalog.catalog_id, catalog_name=catalog_name, manager=self.tools)
+        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, 

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/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/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/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.dist-info → attp_client-0.0.10.dist-info}/METADATA

@@ -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.dist-info → attp_client-0.0.10.dist-info}/RECORD

@@ -1,6 +1,6 @@
 attp_client/__init__.py,sha256=25qGMUU_W8juBuW9N6318vWoqALrPQSp3ECHHkNzUcg,2749
-attp_client/catalog.py,sha256=fDvFC-aherMGsFDRmUgYqlp77II78SXJlal_B4_Vkyg,4569
-attp_client/client.py,sha256=aSjDaH1pHkmPsVZBwIrSIMX8QXDtbDfGpVBXR5KgnF4,3989
+attp_client/catalog.py,sha256=TLQvNKx3GtEYcyqWCJuvF6soZXeebKn6wfQNcvV4cX0,4921
+attp_client/client.py,sha256=CMDj0NMBGDtGGQqz340L2-xafZfpNIxA2zPYdPbkDps,7531
 attp_client/consts.py,sha256=6UZyqWddycOp-TKW5yvb0JW2fdfcS-J2xFVVNfuJQbU,18
 attp_client/errors/attp_exception.py,sha256=HePYyYMknS4t6tMrwU-p9L_LPdj1i7chntrlM53ueK4,347
 attp_client/errors/correlated_rpc_exception.py,sha256=GivYlF0rC4zxbEt5sMxc1cO-iGxIuiEjTy7knN_iur4,591
@@ -8,7 +8,7 @@ attp_client/errors/dead_session.py,sha256=BI-EuTqxVP7j23wcD0GfhteyPsKR2xqUsMNm9S
 attp_client/errors/not_found.py,sha256=Y-Y_Mki1hQYihJttvO0ugHFu9-73--1wqwdOomp2IEM,39
 attp_client/errors/serialization_error.py,sha256=Pa8PRzFJrrikA1Ikj0q-0euvXVUMb_qj-NRIp55SfOk,198
 attp_client/errors/unauthenticated_error.py,sha256=F0V1FjO0qVLMl6Y120y3AXKZnwb5iDD17c4GEMbL5aI,46
-attp_client/inference.py,sha256=S_iAvUwROUIE4IJGC8-ZmVXJc1CP1nbbBHmR0U1k4ZQ,4655
+attp_client/inference.py,sha256=P5fxaH8qlIaCVXpag5gZ_XblaVrpyTu5TRA8E6tE9VU,6955
 attp_client/interfaces/catalogs/catalog.py,sha256=3PxlRwR3y2tbQVfXAkhDIv07AJPraMfH0c_pyi7Y6z8,146
 attp_client/interfaces/catalogs/tools/envelope.py,sha256=6aUx06ou9If9OYv4BODKiBybrgBL2YWfSHZ6ukIR1K0,693
 attp_client/interfaces/error.py,sha256=fIrk5XlAhMs6mbYQ5PzgwS0v-LIbtne3OlQue4CjWXs,139
@@ -24,12 +24,13 @@ attp_client/interfaces/route_mappings.py,sha256=j6hEdkCP5xPpHS16EWmlkdTlnHa7z6e8
 attp_client/misc/fixed_basemodel.py,sha256=0MTVmlTrA75Oxv0pVfLdXFTSp5AmBzgiNwvDiLFGF_w,1853
 attp_client/misc/serializable.py,sha256=tU08TsjiLiafAhU1jKd5BxajlHdEDcdKeEiKPqhMSTI,2102
 attp_client/router.py,sha256=UDHU2xsvTjgSIzMtV0jkPvOYK9R7GFjKfIrjjBHws-Q,4575
-attp_client/session.py,sha256=oZx3Lgsr-y4onaL4yrM3Sj2caQck9wc14QcakhS42Js,11410
-attp_client/tools.py,sha256=zyMCDbph77Ojm74bEQhGm3gzam8lolVpLobcOc89dTM,1920
+attp_client/session.py,sha256=80S1KAhiqiw-sAdT18yB1Wx7XRjol7drMAnYts2FYVs,11813
+attp_client/tools.py,sha256=ThrqM3cL6_XaJdEn3f41P5Y6afct7_GaJ1-Va_ftdHU,1921
 attp_client/types/route_mapping.py,sha256=Kb9ZX88lqihRZr8IryfH1Vg_YAobW699Yjl6Raz1rdg,375
 attp_client/utils/context_awaiter.py,sha256=oCptu5g8mY43j5cr-W4fOe85OCCaqQI9r_Pn92NgZSY,1035
+attp_client/utils/envelopizer.py,sha256=wnFEnEEDGx8eW-UYlhpTeOTyLLXnjBYw3-BOHWG-Hhk,310
 attp_client/utils/route_mapper.py,sha256=uJNhKp6ipCSUxoiZS0Liix2lHOgUAnJM0kfgXWAh9RQ,554
 attp_client/utils/serializer.py,sha256=O1tWYbQS9jC9aus-ISKtliKCgGmOEIb9hxykVrmMKGY,636
-attp_client-0.0.8.dist-info/METADATA,sha256=4muzno9jFdb6WrogPMa4b0HFIvD1LbNeWB5OCUUkVP8,7137
-attp_client-0.0.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-attp_client-0.0.8.dist-info/RECORD,,
+attp_client-0.0.10.dist-info/METADATA,sha256=pTVMigVQ-9bYTHxFnu1Rw0RJ7khCCX4SYkEIvlPeOn8,7138
+attp_client-0.0.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+attp_client-0.0.10.dist-info/RECORD,,