meshagent-agents 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

meshagent/agents/context.py

@@ -1,4 +1,3 @@
-
 from typing import Optional
 from copy import deepcopy
 from meshagent.api import RoomClient
@@ -7,22 +6,30 @@ from meshagent.api.participant import Participant
 
 import uuid
 
+
 class AgentChatContext:
-    def __init__(self, *, messages: Optional[list[dict]] = None, system_role: Optional[str] = None, previous_messages: Optional[list[dict]] = None, previous_response_id: Optional[str] = None):
+    def __init__(
+        self,
+        *,
+        messages: Optional[list[dict]] = None,
+        system_role: Optional[str] = None,
+        previous_messages: Optional[list[dict]] = None,
+        previous_response_id: Optional[str] = None,
+    ):
         self.id = str(uuid.uuid4())
-        if messages == None:
+        if messages is None:
             messages = list[dict]()
         self._messages = messages.copy()
-        if system_role == None:
+        if system_role is None:
             system_role = "system"
         self._system_role = system_role
 
-        if previous_messages == None:            
+        if previous_messages is None:
             previous_messages = list[dict]()
 
         self._previous_response_id = previous_response_id
         self._previous_messages = previous_messages
-    
+
     @property
     def messages(self):
         return self._messages
@@ -30,65 +37,86 @@ class AgentChatContext:
     @property
     def system_role(self):
         return self._system_role
-    
+
     @property
     def previous_messages(self):
         return self._previous_messages
-    
+
     @property
     def previous_response_id(self):
         return self._previous_response_id
-    
+
     def track_response(self, id: str):
         self._previous_response_id = id
         self._previous_messages.extend(self.messages)
         self.messages.clear()
 
     def append_rules(self, rules: list[str]):
-        
         system_message = None
-        
+
         for m in self.messages:
             if m["role"] == self.system_role:
                 system_message = m
                 break
 
-        if system_message == None:
-            system_message = {"role": self.system_role, "content" : ""}
+        if system_message is None:
+            system_message = {"role": self.system_role, "content": ""}
             self.messages.insert(0, system_message)
 
         plan = f"Rules:\n-{'\n-'.join(rules)}\n"
         system_message["content"] = system_message["content"] + plan
 
     def append_assistant_message(self, message: str) -> None:
-        self.messages.append({ "role" : "assistant", "content" : message })
- 
+        self.messages.append({"role": "assistant", "content": message})
+
     def append_user_message(self, message: str) -> None:
-        self.messages.append({ "role" : "user", "content" : message })
+        self.messages.append({"role": "user", "content": message})
 
     def append_user_image(self, url: str) -> None:
-        self.messages.append({ "role" : "user", "content" : [ { "type" : "image_url", "image_url": {"url": url, "detail": "auto"} } ] })
-
-
-    def copy(self) -> 'AgentChatContext':
-        return AgentChatContext(messages=deepcopy(self.messages), system_role=self._system_role)
+        self.messages.append(
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image_url", "image_url": {"url": url, "detail": "auto"}}
+                ],
+            }
+        )
+
+    def copy(self) -> "AgentChatContext":
+        return AgentChatContext(
+            messages=deepcopy(self.messages), system_role=self._system_role
+        )
 
     def to_json(self) -> dict:
         return {
-            "messages" : self.messages,
-            "system_role" : self.system_role,
-            "previous_messages" : self.previous_messages,
-            "previous_response_id" : self.previous_response_id
+            "messages": self.messages,
+            "system_role": self.system_role,
+            "previous_messages": self.previous_messages,
+            "previous_response_id": self.previous_response_id,
         }
-    
+
     @staticmethod
     def from_json(json: dict):
-        return AgentChatContext(messages=json["messages"], system_role=json.get("system_role", None), previous_messages=json.get("previous_messages", None), previous_response_id=json.get("previous_response_id", None))
+        return AgentChatContext(
+            messages=json["messages"],
+            system_role=json.get("system_role", None),
+            previous_messages=json.get("previous_messages", None),
+            previous_response_id=json.get("previous_response_id", None),
+        )
+
 
 class AgentCallContext:
-    def __init__(self, *, chat: AgentChatContext, room: RoomClient, toolkits: Optional[list[Toolkit]] = None, caller: Optional[Participant] = None, on_behalf_of: Optional[Participant] = None):
+    def __init__(
+        self,
+        *,
+        chat: AgentChatContext,
+        room: RoomClient,
+        toolkits: Optional[list[Toolkit]] = None,
+        caller: Optional[Participant] = None,
+        on_behalf_of: Optional[Participant] = None,
+    ):
         self._room = room
-        if toolkits == None:
+        if toolkits is None:
             toolkits = list[Toolkit]()
         self._toolkits = toolkits
         self._chat = chat
@@ -110,7 +138,7 @@ class AgentCallContext:
     @property
     def on_behalf_of(self):
         return self._on_behalf_of
-    
+
     @property
     def room(self):
         return self._room

meshagent/agents/development.py

@@ -1,32 +1,30 @@
 from .agent import SingleRoomAgent
-from meshagent.api import websocket_protocol, RoomClient, MeshSchema, RoomException
+from meshagent.api import websocket_protocol, RoomClient
 import asyncio
 import signal
-import json
 
-from aiohttp import web
 
-
-async def connect_development_agent(*, room_name:str, agent: SingleRoomAgent):
-    
+async def connect_development_agent(*, room_name: str, agent: SingleRoomAgent):
     async with RoomClient(
-        protocol = websocket_protocol(participant_name=agent.name, room_name=room_name, role="agent")) as room:
-        
+        protocol=websocket_protocol(
+            participant_name=agent.name, room_name=room_name, role="agent"
+        )
+    ) as room:
         await agent.start(room=room)
 
         try:
-            
             term = asyncio.Future()
 
             def clean_termination(signal, frame):
                 term.set_result(True)
-            
+
             signal.signal(signal.SIGTERM, clean_termination)
             signal.signal(signal.SIGABRT, clean_termination)
 
-            await asyncio.wait([asyncio.ensure_future(room.protocol.wait_for_close()), term], return_when=asyncio.FIRST_COMPLETED)
+            await asyncio.wait(
+                [asyncio.ensure_future(room.protocol.wait_for_close()), term],
+                return_when=asyncio.FIRST_COMPLETED,
+            )
 
         finally:
-
             await agent.stop()
-

meshagent/agents/hosting.py

@@ -1,14 +1,13 @@
 import logging
 
-from meshagent.api import websocket_protocol, RoomMessage
-from meshagent.api.webhooks import WebhookServer, RoomStartedEvent, RoomEndedEvent, CallEvent
+from meshagent.api import RoomMessage
+from meshagent.api.webhooks import WebhookServer, CallEvent
 from meshagent.api import WebSocketClientProtocol
 from meshagent.api.room_server_client import RoomClient
 from meshagent.agents import SingleRoomAgent
 from aiohttp import web
 import asyncio
 
-import logging
 from typing import Callable, Optional
 
 from .agent import TaskRunner
@@ -16,77 +15,137 @@ from .agent import TaskRunner
 logger = logging.getLogger("hosting")
 
 
+class RemoteTaskRunnerServer[T: TaskRunner](WebhookServer):
+    def __init__(
+        self,
+        *,
+        cls: Optional[T] = None,
+        path: Optional[str] = None,
+        app: Optional[web.Application] = None,
+        host=None,
+        port=None,
+        webhook_secret=None,
+        create_agent: Optional[Callable[[dict], TaskRunner]] = None,
+        validate_webhook_secret: Optional[bool] = None,
+    ):
+        super().__init__(
+            path=path,
+            app=app,
+            host=host,
+            port=port,
+            webhook_secret=webhook_secret,
+            validate_webhook_secret=validate_webhook_secret,
+        )
+
+        if create_agent is None:
 
-class RemoteTaskRunnerServer[T:TaskRunner](WebhookServer):
-    def __init__(self, *, cls: Optional[T] = None, path: Optional[str] = None, app: Optional[web.Application] = None, host = None, port = None, webhook_secret = None, create_agent: Optional[Callable[[dict],TaskRunner]] = None, validate_webhook_secret: Optional[bool] = None):
-        super().__init__(path=path, app=app, host=host, port=port, webhook_secret=webhook_secret, validate_webhook_secret=validate_webhook_secret)
-        
-        if create_agent == None:
             def default_create_agent(arguments: dict) -> TaskRunner:
                 return cls(**arguments)
-            
+
             create_agent = default_create_agent
 
         self._create_agent = create_agent
 
-    async def _spawn(self, *, room_name: str, room_url: str, token: str, arguments: Optional[dict] = None):
+    async def _spawn(
+        self,
+        *,
+        room_name: str,
+        room_url: str,
+        token: str,
+        arguments: Optional[dict] = None,
+    ):
         agent = self._create_agent(arguments=arguments)
-        
+
         async def run():
-            async with RoomClient(protocol=WebSocketClientProtocol(url= room_url, token=token)) as room:
-    
+            async with RoomClient(
+                protocol=WebSocketClientProtocol(url=room_url, token=token)
+            ) as room:
                 dismissed = asyncio.Future()
 
                 def on_message(message: RoomMessage):
                     if message.type == "dismiss":
-                        logger.info(f"dismissed task runner by {message.from_participant_id}")
+                        logger.info(
+                            f"dismissed task runner by {message.from_participant_id}"
+                        )
                         dismissed.set_result(True)
 
                 room.messaging.on("message", on_message)
-        
+
                 await agent.start(room=room)
 
-                done, pending = await asyncio.wait([
-                    dismissed,
-                    asyncio.ensure_future(room.protocol.wait_for_close())
-                ], return_when=asyncio.FIRST_COMPLETED)
-                
+                done, pending = await asyncio.wait(
+                    [dismissed, asyncio.ensure_future(room.protocol.wait_for_close())],
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
 
                 await agent.stop()
 
         def on_done(task: asyncio.Task):
             try:
-                result = task.result()
+                task.result()
             except Exception as e:
                 logger.error("agent encountered an error", exc_info=e)
-                
+
         task = asyncio.create_task(run())
         task.add_done_callback(on_done)
-    
-    async def on_call(self, event: CallEvent):
-        await self._spawn(room_name=event.room_name, room_url=event.room_url, token=event.token, arguments=event.arguments)
 
+    async def on_call(self, event: CallEvent):
+        await self._spawn(
+            room_name=event.room_name,
+            room_url=event.room_url,
+            token=event.token,
+            arguments=event.arguments,
+        )
+
+
+class RemoteAgentServer[T: SingleRoomAgent](WebhookServer):
+    def __init__(
+        self,
+        *,
+        cls: Optional[T] = None,
+        path: Optional[str] = None,
+        app: Optional[web.Application] = None,
+        host=None,
+        port=None,
+        webhook_secret=None,
+        create_agent: Optional[Callable[[dict], SingleRoomAgent]] = None,
+        validate_webhook_secret: Optional[bool] = None,
+    ):
+        super().__init__(
+            path=path,
+            app=app,
+            host=host,
+            port=port,
+            webhook_secret=webhook_secret,
+            validate_webhook_secret=validate_webhook_secret,
+        )
+
+        if create_agent is None:
 
-class RemoteAgentServer[T:SingleRoomAgent](WebhookServer):
-    def __init__(self, *, cls: Optional[T] = None, path: Optional[str] = None, app: Optional[web.Application] = None,  host = None, port = None, webhook_secret = None, create_agent: Optional[Callable[[dict], SingleRoomAgent]] = None, validate_webhook_secret: Optional[bool] = None):
-        super().__init__(path=path, app=app, host=host, port=port, webhook_secret=webhook_secret, validate_webhook_secret=validate_webhook_secret)
-        
-        if create_agent == None:
             def default_create_agent(arguments: dict) -> SingleRoomAgent:
                 return cls(**arguments)
-            
+
             create_agent = default_create_agent
 
         self._create_agent = create_agent
-    
-    async def _spawn(self, *, room_name: str, room_url: str, token: str, arguments: Optional[dict] = None):
 
-        logger.info(f"spawning agent on room: {room_name} url: {room_url} arguments: {arguments}")
+    async def _spawn(
+        self,
+        *,
+        room_name: str,
+        room_url: str,
+        token: str,
+        arguments: Optional[dict] = None,
+    ):
+        logger.info(
+            f"spawning agent on room: {room_name} url: {room_url} arguments: {arguments}"
+        )
         agent = self._create_agent(arguments=arguments)
 
         async def run():
-            async with RoomClient(protocol=WebSocketClientProtocol(url=room_url, token=token)) as room:
-    
+            async with RoomClient(
+                protocol=WebSocketClientProtocol(url=room_url, token=token)
+            ) as room:
                 dismissed = asyncio.Future()
 
                 def on_message(message: RoomMessage):
@@ -95,25 +154,29 @@ class RemoteAgentServer[T:SingleRoomAgent](WebhookServer):
                         dismissed.set_result(True)
 
                 room.messaging.on("message", on_message)
-            
+
                 await agent.start(room=room)
 
-                done, pending = await asyncio.wait([
-                    dismissed,
-                    asyncio.ensure_future(room.protocol.wait_for_close())
-                ], return_when=asyncio.FIRST_COMPLETED)
-                
+                done, pending = await asyncio.wait(
+                    [dismissed, asyncio.ensure_future(room.protocol.wait_for_close())],
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+
                 await agent.stop()
 
         def on_done(task: asyncio.Task):
             try:
-                result = task.result()
+                task.result()
             except Exception as e:
                 logger.error("agent encountered an error", exc_info=e)
 
         task = asyncio.create_task(run())
         task.add_done_callback(on_done)
-        
-    async def on_call(self, event: CallEvent):
-        await self._spawn(room_name=event.room_name, room_url=event.room_url, token=event.token, arguments=event.arguments)
 
+    async def on_call(self, event: CallEvent):
+        await self._spawn(
+            room_name=event.room_name,
+            room_url=event.room_url,
+            token=event.token,
+            arguments=event.arguments,
+        )