meshagent-agents 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

meshagent/agents/adapter.py

@@ -44,7 +44,7 @@ class LLMAdapter(Generic[T]):
         *,
         context: AgentChatContext,
         room: RoomClient,
-        toolkits: Toolkit,
+        toolkits: list[Toolkit],
         tool_adapter: Optional[ToolResponseAdapter] = None,
         output_schema: Optional[dict] = None,
         event_handler: Optional[Callable[[T], None]] = None,

meshagent/agents/agent.py

@@ -335,7 +335,7 @@ class TaskRunner(SingleRoomAgent):
         requires=None,
         supports_tools: Optional[bool] = None,
         input_schema: dict,
-        output_schema: dict,
+        output_schema: Optional[dict] = None,
         labels: Optional[list[str]] = None,
         toolkits: Optional[list[Toolkit]] = None,
     ):

meshagent/agents/chat.py

@@ -1,4 +1,4 @@
-from .agent import SingleRoomAgent, AgentChatContext
+from meshagent.agents.agent import SingleRoomAgent, AgentChatContext
 from meshagent.api.chan import Chan
 from meshagent.api import (
     RoomMessage,
@@ -10,7 +10,7 @@ from meshagent.api import (
     MeshDocument,
 )
 from meshagent.tools import Toolkit, ToolContext
-from .adapter import LLMAdapter, ToolResponseAdapter
+from meshagent.agents.adapter import LLMAdapter, ToolResponseAdapter
 from meshagent.openai.tools.responses_adapter import ImageGenerationTool, LocalShellTool
 import asyncio
 from typing import Optional
@@ -22,6 +22,7 @@ from typing import Literal
 import base64
 from openai.types.responses import ResponseStreamEvent
 from asyncio import CancelledError
+from meshagent.api import RoomException
 
 from opentelemetry import trace
 import shlex
@@ -307,13 +308,22 @@ class ChatBot(SingleRoomAgent):
 
     async def _send_and_save_chat(
         self,
-        messages: Element,
+        thread: MeshDocument,
         path: str,
         to: RemoteParticipant,
         id: str,
         text: str,
         thread_attributes: dict,
     ):
+        messages = None
+
+        for prop in thread.root.get_children():
+            if prop.tag_name == "messages":
+                messages = prop
+
+        if messages is None:
+            raise RoomException("messages element was not found in thread document")
+
         with tracer.start_as_current_span("chatbot.thread.message") as span:
             span.set_attributes(thread_attributes)
             span.set_attribute("role", "assistant")
@@ -339,10 +349,10 @@ class ChatBot(SingleRoomAgent):
                 },
             )
 
-    async def greet(
+    async def _greet(
         self,
         *,
-        messages: Element,
+        thread: MeshDocument,
         path: str,
         chat_context: AgentChatContext,
         participant: RemoteParticipant,
@@ -353,7 +363,7 @@ class ChatBot(SingleRoomAgent):
             await self._send_and_save_chat(
                 id=str(uuid.uuid4()),
                 to=RemoteParticipant(id=participant.id),
-                messages=messages,
+                thread=thread,
                 path=path,
                 text=self._auto_greet_message,
                 thread_attributes=thread_attributes,
@@ -403,34 +413,92 @@ class ChatBot(SingleRoomAgent):
     async def close_thread(self, *, path: str):
         return await self.room.sync.close(path=path)
 
-    async def _spawn_thread(self, path: str, messages: Chan[RoomMessage]):
-        self.room.developer.log_nowait(
-            type="chatbot.thread.started", data={"path": path}
-        )
-        chat_context = await self.init_chat_context()
-        opened = False
+    async def load_thread_context(self, *, thread_context: ChatThreadContext):
+        """
+        load the thread from the thread document by inserting the current messages in the thread into the chat context
+        """
+        thread = thread_context.thread
+        chat_context = thread_context.chat
+        for prop in thread.root.get_children():
+            if prop.tag_name == "messages":
+                doc_messages = prop
+
+                for element in doc_messages.get_children():
+                    if isinstance(element, Element) and element.tag_name == "message":
+                        msg = element["text"]
+                        if element[
+                            "author_name"
+                        ] == self.room.local_participant.get_attribute("name"):
+                            chat_context.append_assistant_message(msg)
+                        else:
+                            chat_context.append_user_message(msg)
+
+                        for child in element.get_children():
+                            if child.tag_name == "file":
+                                chat_context.append_assistant_message(
+                                    f"the user attached a file with the path '{child.get_attribute('path')}'"
+                                )
+
+        if doc_messages is None:
+            raise Exception("thread was not properly initialized")
 
+    async def prepare_llm_context(self, *, context: ChatThreadContext):
+        """
+        called prior to sending the request to the LLM in case the agent needs to modify the context prior to sending
+        """
+        pass
+
+    async def _process_llm_events(
+        self,
+        *,
+        thread_context: ChatThreadContext,
+        llm_messages: asyncio.Queue,
+        thread_attributes: dict,
+    ):
+        thread = thread_context.thread
         doc_messages = None
-        current_file = None
-        llm_messages = Chan[ResponseStreamEvent]()
-        thread_context = None
+        for prop in thread.root.get_children():
+            if prop.tag_name == "messages":
+                doc_messages = prop
 
-        thread_attributes = None
+        if doc_messages is None:
+            raise RoomException("messages element is missing from thread document")
 
-        def done_processing_llm_events(task: asyncio.Task):
+        context_message = None
+        updates = asyncio.Queue()
+
+        # throttle updates so we don't send too many syncs over the wire at once
+        async def update_thread():
             try:
-                task.result()
-            except CancelledError:
-                pass
-            except Exception as e:
-                logger.error("error sending delta", exc_info=e)
+                changes = {}
+                while True:
+                    try:
+                        element, partial = updates.get_nowait()
+                        changes[element] = partial
+
+                    except asyncio.QueueEmpty:
+                        for e, p in changes.items():
+                            e["text"] = p
+
+                        changes.clear()
+
+                        e, p = await updates.get()
+                        changes[e] = p
 
-        async def process_llm_events():
-            partial = ""
-            content_element = None
-            context_message = None
+                        await asyncio.sleep(0.1)
 
-            async for evt in llm_messages:
+            except asyncio.QueueShutDown:
+                # flush any pending changes
+                for e, p in changes.items():
+                    e["text"] = p
+
+                changes.clear()
+                pass
+
+        update_thread_task = asyncio.create_task(update_thread())
+        try:
+            while True:
+                evt = await llm_messages.get()
                 for participant in self._room.messaging.get_participants():
                     logger.debug(
                         f"sending event {evt.type} to {participant.get_attribute('name')}"
@@ -440,6 +508,7 @@ class ChatBot(SingleRoomAgent):
 
                 if evt.type == "response.content_part.added":
                     partial = ""
+
                     content_element = doc_messages.append_child(
                         tag_name="message",
                         attributes={
@@ -454,11 +523,11 @@ class ChatBot(SingleRoomAgent):
                     )
 
                     context_message = {"role": "assistant", "content": ""}
-                    chat_context.messages.append(context_message)
+                    thread_context.chat.messages.append(context_message)
 
                 elif evt.type == "response.output_text.delta":
                     partial += evt.delta
-                    content_element["text"] = partial
+                    updates.put_nowait((content_element, partial))
                     context_message["content"] = partial
 
                 elif evt.type == "response.output_text.done":
@@ -472,9 +541,21 @@ class ChatBot(SingleRoomAgent):
                         span.set_attribute("role", "assistant")
                         span.set_attributes(thread_attributes)
                         span.set_attributes({"text": evt.text})
+        except asyncio.QueueShutDown:
+            pass
+        finally:
+            updates.shutdown()
+            await update_thread_task
+
+    async def _spawn_thread(self, path: str, messages: Chan[RoomMessage]):
+        logger.debug("chatbot is starting a thread", extra={"path": path})
+        chat_context = await self.init_chat_context()
+        opened = False
+
+        current_file = None
+        thread_context = None
 
-        llm_task = asyncio.create_task(process_llm_events())
-        llm_task.add_done_callback(done_processing_llm_events)
+        thread_attributes = None
 
         thread = None
 
@@ -483,9 +564,9 @@ class ChatBot(SingleRoomAgent):
 
             while True:
                 while True:
-                    logger.info(f"waiting for message on thread {path}")
+                    logger.debug(f"waiting for message on thread {path}")
                     received = await messages.recv()
-                    logger.info(f"received message on thread {path}: {received.type}")
+                    logger.debug(f"received message on thread {path}: {received.type}")
 
                     chat_with_participant = None
                     for participant in self._room.messaging.get_participants():
@@ -540,100 +621,57 @@ class ChatBot(SingleRoomAgent):
 
                             thread = await self.open_thread(path=path)
 
-                            for prop in thread.root.get_children():
-                                if prop.tag_name == "messages":
-                                    doc_messages = prop
-
-                                    for element in doc_messages.get_children():
-                                        if (
-                                            isinstance(element, Element)
-                                            and element.tag_name == "message"
-                                        ):
-                                            msg = element["text"]
-                                            if (
-                                                element["author_name"]
-                                                == self.room.local_participant.get_attribute(
-                                                    "name"
-                                                )
-                                            ):
-                                                chat_context.append_assistant_message(
-                                                    msg
-                                                )
-                                            else:
-                                                chat_context.append_user_message(msg)
-
-                                            for child in element.get_children():
-                                                if child.tag_name == "file":
-                                                    chat_context.append_assistant_message(
-                                                        f"the user attached a file with the path '{child.get_attribute('path')}'"
-                                                    )
-
-                            if doc_messages is None:
-                                raise Exception("thread was not properly initialized")
+                            thread_context = ChatThreadContext(
+                                path=path,
+                                chat=chat_context,
+                                thread=thread,
+                                participants=get_thread_participants(
+                                    room=self.room, thread=thread
+                                ),
+                            )
+
+                            await self.load_thread_context(
+                                thread_context=thread_context
+                            )
 
                     if received.type == "opened":
                         if not opened:
                             opened = True
 
-                            await self.greet(
+                            await self._greet(
                                 path=path,
                                 chat_context=chat_context,
                                 participant=chat_with_participant,
-                                messages=doc_messages,
+                                thread=thread,
                                 thread_attributes=thread_attributes,
                             )
 
                     if received.type == "chat":
                         if thread is None:
-                            self.room.developer.log_nowait(
-                                type="thread is not open", data={}
-                            )
+                            logger.info("thread is not open", extra={"path": path})
                             break
 
-                        for participant in get_thread_participants(
-                            room=self._room, thread=thread
-                        ):
-                            # TODO: async gather
-                            self._room.messaging.send_message_nowait(
-                                to=participant,
-                                type="thinking",
-                                message={"thinking": True, "path": path},
-                            )
-
-                        if chat_with_participant.id == received.from_participant_id:
-                            self.room.developer.log_nowait(
-                                type="llm.message",
-                                data={
-                                    "context": chat_context.id,
-                                    "participant_id": self.room.local_participant.id,
-                                    "participant_name": self.room.local_participant.get_attribute(
-                                        "name"
-                                    ),
-                                    "message": {
-                                        "content": {
-                                            "role": "user",
-                                            "text": received.message["text"],
-                                        }
-                                    },
-                                },
-                            )
-
-                            attachments = received.message.get("attachments", [])
-                            text = received.message["text"]
-
-                            for attachment in attachments:
-                                chat_context.append_assistant_message(
-                                    message=f"the user attached a file at the path '{attachment['path']}'"
-                                )
+                        logger.debug(
+                            "chatbot received a chat",
+                            extra={
+                                "context": chat_context.id,
+                                "participant_id": self.room.local_participant.id,
+                                "participant_name": self.room.local_participant.get_attribute(
+                                    "name"
+                                ),
+                                "text": received.message["text"],
+                            },
+                        )
 
-                            chat_context.append_user_message(message=text)
+                        attachments = received.message.get("attachments", [])
+                        text = received.message["text"]
 
-                        # if user is typing, wait for typing to stop
-                        while True:
-                            if chat_with_participant.id not in self._is_typing:
-                                break
+                        for attachment in attachments:
+                            chat_context.append_assistant_message(
+                                message=f"the user attached a file at the path '{attachment['path']}'"
+                            )
 
-                            await asyncio.sleep(0.5)
+                        chat_context.append_user_message(message=text)
 
                         if messages.empty():
                             break
@@ -654,6 +692,16 @@ class ChatBot(SingleRoomAgent):
                         span.set_attributes({"text": text})
 
                         try:
+                            for participant in get_thread_participants(
+                                room=self._room, thread=thread
+                            ):
+                                # TODO: async gather
+                                self._room.messaging.send_message_nowait(
+                                    to=participant,
+                                    type="thinking",
+                                    message={"thinking": True, "path": path},
+                                )
+
                             if thread_context is None:
                                 thread_context = ChatThreadContext(
                                     path=path,
@@ -668,9 +716,6 @@ class ChatBot(SingleRoomAgent):
                                     room=self.room, thread=thread
                                 )
 
-                            def handle_event(evt):
-                                llm_messages.send_nowait(evt)
-
                             with tracer.start_as_current_span("chatbot.llm") as span:
                                 try:
                                     with tracer.start_as_current_span(
@@ -683,6 +728,23 @@ class ChatBot(SingleRoomAgent):
                                             )
                                         )
 
+                                    await self.prepare_llm_context(
+                                        context=thread_context
+                                    )
+
+                                    llm_messages = asyncio.Queue[ResponseStreamEvent]()
+
+                                    def handle_event(evt):
+                                        llm_messages.put_nowait(evt)
+
+                                    llm_task = asyncio.create_task(
+                                        self._process_llm_events(
+                                            thread_context=thread_context,
+                                            llm_messages=llm_messages,
+                                            thread_attributes=thread_attributes,
+                                        )
+                                    )
+
                                     await self._llm_adapter.next(
                                         context=chat_context,
                                         room=self._room,
@@ -690,10 +752,14 @@ class ChatBot(SingleRoomAgent):
                                         tool_adapter=self._tool_adapter,
                                         event_handler=handle_event,
                                     )
+
+                                    llm_messages.shutdown()
+                                    await llm_task
+
                                 except Exception as e:
                                     logger.error("An error was encountered", exc_info=e)
                                     await self._send_and_save_chat(
-                                        messages=doc_messages,
+                                        thread=thread,
                                         to=chat_with_participant,
                                         path=path,
                                         id=str(uuid.uuid4()),
@@ -702,27 +768,30 @@ class ChatBot(SingleRoomAgent):
                                     )
 
                         finally:
-                            for participant in get_thread_participants(
-                                room=self._room, thread=thread
-                            ):
-                                # TODO: async gather
-                                self._room.messaging.send_message_nowait(
-                                    to=participant,
-                                    type="thinking",
-                                    message={"thinking": False, "path": path},
-                                )
+
+                            async def cleanup():
+                                for participant in get_thread_participants(
+                                    room=self._room, thread=thread
+                                ):
+                                    self._room.messaging.send_message_nowait(
+                                        to=participant,
+                                        type="thinking",
+                                        message={"thinking": False, "path": path},
+                                    )
+
+                            asyncio.shield(cleanup())
 
         finally:
-            llm_messages.close()
 
-            if self.room is not None:
-                logger.info("thread was ended {path}")
-                self.room.developer.log_nowait(
-                    type="chatbot.thread.ended", data={"path": path}
-                )
+            async def cleanup():
+                if self.room is not None:
+                    logger.info(f"thread was ended {path}")
+                    logger.info("chatbot thread ended", extra={"path": path})
 
-                if thread is not None:
-                    await self.close_thread(path=path)
+                    if thread is not None:
+                        await self.close_thread(path=path)
+
+            asyncio.shield(cleanup())
 
     def _get_message_channel(self, key: str) -> Chan[RoomMessage]:
         if key not in self._message_channels:
@@ -756,7 +825,7 @@ class ChatBot(SingleRoomAgent):
 
                 messages = self._get_message_channel(path)
 
-                logger.info(
+                logger.debug(
                     f"queued incoming message for thread {path}: {message.type}"
                 )
 
@@ -765,6 +834,7 @@ class ChatBot(SingleRoomAgent):
                 if path not in self._thread_tasks or self._thread_tasks[path].done():
 
                     def thread_done(task: asyncio.Task):
+                        self._thread_tasks.pop(path)
                         self._message_channels.pop(path)
                         try:
                             task.result()
@@ -775,7 +845,7 @@ class ChatBot(SingleRoomAgent):
                                 f"The chat thread ended with an error {e}", exc_info=e
                             )
 
-                    logger.info(f"spawning chat thread for {path}")
+                    logger.debug(f"spawning chat thread for {path}")
                     task = asyncio.create_task(
                         self._spawn_thread(messages=messages, path=path)
                     )
@@ -783,6 +853,11 @@ class ChatBot(SingleRoomAgent):
 
                     self._thread_tasks[path] = task
 
+            elif message.type == "cancel":
+                path = message.message["path"]
+                if path in self._thread_tasks:
+                    self._thread_tasks[path].cancel()
+
             elif message.type == "typing":
 
                 def callback(task: asyncio.Task):

meshagent/agents/version.py

@@ -1 +1 @@
-__version__ = "0.5.2"
+__version__ = "0.5.4"

{meshagent_agents-0.5.2.dist-info → meshagent_agents-0.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-agents
-Version: 0.5.2
+Version: 0.5.4
 Summary: Agent Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,19 +12,19 @@ License-File: LICENSE
 Requires-Dist: pyjwt~=2.10
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
-Requires-Dist: meshagent-api~=0.5.2
-Requires-Dist: meshagent-tools~=0.5.2
-Requires-Dist: meshagent-openai~=0.5.2
+Requires-Dist: meshagent-api~=0.5.4
+Requires-Dist: meshagent-tools~=0.5.4
+Requires-Dist: meshagent-openai~=0.5.4
 Requires-Dist: pydantic~=2.11
 Requires-Dist: opentelemetry-distro~=0.54b1
 Provides-Extra: all
-Requires-Dist: meshagent-api[all]~=0.5.2; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.5.4; extra == "all"
 Requires-Dist: chonkie~=0.5.1; extra == "all"
 Requires-Dist: chonkie[semantic]~=0.5.1; extra == "all"
 Requires-Dist: chonkie[openai]~=0.5.1; extra == "all"
 Requires-Dist: aiosmtplib~=4.0.1; extra == "all"
 Provides-Extra: sync
-Requires-Dist: meshagent-api[sync]~=0.5.2; extra == "sync"
+Requires-Dist: meshagent-api[sync]~=0.5.4; extra == "sync"
 Provides-Extra: mail
 Requires-Dist: aiosmtplib~=4.0.1; extra == "mail"
 Provides-Extra: rag

{meshagent_agents-0.5.2.dist-info → meshagent_agents-0.5.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
 meshagent/agents/__init__.py,sha256=d2cplyLH8xqDWqP_GoPQ8ApHzuv8Iiq4rz-vYBlGMTw,706
-meshagent/agents/adapter.py,sha256=CZgVzUTTY8dyPBYA7O_Kaawb40maxAbUUhBFk1YjbsI,1386
-meshagent/agents/agent.py,sha256=OaWjjccOsU_n-Pr6WdA90LePGQflHQlL-X5lJ72s3pc,20337
-meshagent/agents/chat.py,sha256=HocrfVSV6kJaNUG5umKhi22AKwyq0ySCfVM--7ytjtE,30595
+meshagent/agents/adapter.py,sha256=dMuejpjl__bdZ-Qmt-k4e81g-i10vZup7WE1JCZ_Sy4,1392
+meshagent/agents/agent.py,sha256=w14hM63YXiH15VEF1T2eZCvggvrUkE00a1kQkaMRBM0,20354
+meshagent/agents/chat.py,sha256=xnXQTRiiCL-rzZw8Gv1LJy09frQpHAoAHoK2-gzP6MM,32737
 meshagent/agents/context.py,sha256=6txCXA22aHQaikvIKED6YjPyasM_bPqGqCE4HGj04_E,4035
 meshagent/agents/development.py,sha256=AEBkkycNZDRLYIdmX2LkrVZv715ALswiwSR9CiV3HE4,894
 meshagent/agents/hosting.py,sha256=tCcswAweEhlMxGaBR_m2YvUkwZiaHbTBT64urRHfK7I,5446
@@ -14,7 +14,7 @@ meshagent/agents/pydantic.py,sha256=RrdOESZg-n_FyxbfkOBwRPVxV39IOjxK2unsyAGn9as,
 meshagent/agents/single_shot_writer.py,sha256=miWVMo4NX8Hib0yHwDmiwuk8GraJwg1JzljsgFyTl4Y,3237
 meshagent/agents/thread_schema.py,sha256=OGQ-H5c2fJgNOYHC3Pas8iqTi2RUSxP2bytf0SK-SYc,4208
 meshagent/agents/utils.py,sha256=6D9GXpYu9xx5XlfD3DiGFdyOwq46e5-sTYOF_FYep1o,1446
-meshagent/agents/version.py,sha256=isJrmDBLRag7Zc2UK9ZovWGOv7ji1Oh-zJtJMNJFkXw,22
+meshagent/agents/version.py,sha256=DITpct-LrdIsTgwx2NgH5Ghx5y8Xgz1YMimy1ZV5RTY,22
 meshagent/agents/worker.py,sha256=SkrPhxIQ-Chyjg-eZGOlehkbrVYmsas8zmZnrTsAl3o,3910
 meshagent/agents/writer.py,sha256=dXglYgHwBrBJIaapMqBDyD3kmwSyi94tOdHH44itODc,2682
 meshagent/agents/schemas/__init__.py,sha256=_xAhrkxvFdfer3NolrynragGxcLElGR51LSribT3deU,299
@@ -23,8 +23,8 @@ meshagent/agents/schemas/gallery.py,sha256=65IsrH2wiFIR-DNo8est-nCOC72i1Aa5EmVNU
 meshagent/agents/schemas/presentation.py,sha256=aaMzkFQryurbHd1fbzTQPdN7v8QIhsjXuvbE8ZiuXNY,1589
 meshagent/agents/schemas/schema.py,sha256=8OXGCLVouoPg6eHBU9mgf1pTGTMvVZqiKNq15wkQJe0,5310
 meshagent/agents/schemas/super_editor_document.py,sha256=iRv4Q-DE_5kUdsAD5Rm4GwHek8L_7ZEpxIZ1x2dWjdg,1813
-meshagent_agents-0.5.2.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_agents-0.5.2.dist-info/METADATA,sha256=ERL9HgViuRRP24QRR4ejhBpSOPyW5QA-I86KZqm0zlE,3773
-meshagent_agents-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-meshagent_agents-0.5.2.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_agents-0.5.2.dist-info/RECORD,,
+meshagent_agents-0.5.4.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_agents-0.5.4.dist-info/METADATA,sha256=slVBBDAZPV--6XZANlTd_H-qRKuDmlE6alIVIViLq9g,3773
+meshagent_agents-0.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+meshagent_agents-0.5.4.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_agents-0.5.4.dist-info/RECORD,,