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

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,107 +413,149 @@ 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")
+
+        context_message = None
+        updates = asyncio.Queue()
 
-        def done_processing_llm_events(task: asyncio.Task):
+        # throttle updates so we don't send too many syncs over the wire at once
+        async def update_thread():
             try:
-                task.result()
-            except Exception as e:
-                logger.error("error sending delta", exc_info=e)
-
-        async def process_llm_events():
-            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:
-                    changes = {}
-                    while True:
-                        try:
-                            element, partial = updates.get_nowait()
-                            changes[element] = partial
+                changes = {}
+                while True:
+                    try:
+                        element, partial = updates.get_nowait()
+                        changes[element] = partial
 
-                        except asyncio.QueueEmpty:
-                            for e, p in changes.items():
-                                e["text"] = p
+                    except asyncio.QueueEmpty:
+                        for e, p in changes.items():
+                            e["text"] = p
 
-                            changes.clear()
+                        changes.clear()
 
-                            e, p = await updates.get()
-                            changes[e] = p
+                        e, p = await updates.get()
+                        changes[e] = p
 
-                            await asyncio.sleep(0.1)
+                        await asyncio.sleep(0.1)
 
-                except asyncio.QueueShutDown:
-                    pass
+            except asyncio.QueueShutDown:
+                # flush any pending changes
+                for e, p in changes.items():
+                    e["text"] = p
 
-            update_thread_task = asyncio.create_task(update_thread())
-            try:
-                async for evt in llm_messages:
-                    for participant in self._room.messaging.get_participants():
-                        logger.debug(
-                            f"sending event {evt.type} to {participant.get_attribute('name')}"
-                        )
+                changes.clear()
+                pass
 
-                        # self.room.messaging.send_message_nowait(to=participant, type="llm.event", message=json.loads(evt.to_json()))
+        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')}"
+                    )
 
-                    if evt.type == "response.content_part.added":
-                        partial = ""
-                        content_element = doc_messages.append_child(
-                            tag_name="message",
-                            attributes={
-                                "text": "",
-                                "created_at": datetime.datetime.now(
-                                    datetime.timezone.utc
-                                )
-                                .isoformat()
-                                .replace("+00:00", "Z"),
-                                "author_name": self.room.local_participant.get_attribute(
-                                    "name"
-                                ),
-                            },
-                        )
+                    # self.room.messaging.send_message_nowait(to=participant, type="llm.event", message=json.loads(evt.to_json()))
+
+                if evt.type == "response.content_part.added":
+                    partial = ""
+
+                    content_element = doc_messages.append_child(
+                        tag_name="message",
+                        attributes={
+                            "text": "",
+                            "created_at": datetime.datetime.now(datetime.timezone.utc)
+                            .isoformat()
+                            .replace("+00:00", "Z"),
+                            "author_name": self.room.local_participant.get_attribute(
+                                "name"
+                            ),
+                        },
+                    )
 
-                        context_message = {"role": "assistant", "content": ""}
-                        chat_context.messages.append(context_message)
+                    context_message = {"role": "assistant", "content": ""}
+                    thread_context.chat.messages.append(context_message)
 
-                    elif evt.type == "response.output_text.delta":
-                        partial += evt.delta
-                        updates.put_nowait((content_element, partial))
-                        context_message["content"] = partial
+                elif evt.type == "response.output_text.delta":
+                    partial += evt.delta
+                    updates.put_nowait((content_element, partial))
+                    context_message["content"] = partial
 
-                    elif evt.type == "response.output_text.done":
-                        content_element = None
+                elif evt.type == "response.output_text.done":
+                    content_element = None
 
-                        with tracer.start_as_current_span(
-                            "chatbot.thread.message"
-                        ) as span:
-                            span.set_attribute(
-                                "from_participant_name",
-                                self.room.local_participant.get_attribute("name"),
-                            )
-                            span.set_attribute("role", "assistant")
-                            span.set_attributes(thread_attributes)
-                            span.set_attributes({"text": evt.text})
-            finally:
-                updates.shutdown()
-                await update_thread_task
+                    with tracer.start_as_current_span("chatbot.thread.message") as span:
+                        span.set_attribute(
+                            "from_participant_name",
+                            self.room.local_participant.get_attribute("name"),
+                        )
+                        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
 
-        llm_task = asyncio.create_task(process_llm_events())
-        llm_task.add_done_callback(done_processing_llm_events)
+    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
+
+        thread_attributes = None
 
         thread = None
 
@@ -512,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():
@@ -569,83 +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
 
-                        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"],
-                                        }
-                                    },
-                                },
-                            )
+                        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"],
+                            },
+                        )
 
-                            attachments = received.message.get("attachments", [])
-                            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']}'"
-                                )
+                        for attachment in attachments:
+                            chat_context.append_assistant_message(
+                                message=f"the user attached a file at the path '{attachment['path']}'"
+                            )
 
-                            chat_context.append_user_message(message=text)
+                        chat_context.append_user_message(message=text)
 
                         if messages.empty():
                             break
@@ -690,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(
@@ -705,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,
@@ -713,10 +753,13 @@ class ChatBot(SingleRoomAgent):
                                         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()),
@@ -741,13 +784,9 @@ class ChatBot(SingleRoomAgent):
         finally:
 
             async def cleanup():
-                llm_messages.close()
-
                 if self.room is not None:
                     logger.info(f"thread was ended {path}")
-                    self.room.developer.log_nowait(
-                        type="chatbot.thread.ended", data={"path": path}
-                    )
+                    logger.info("chatbot thread ended", extra={"path": path})
 
                     if thread is not None:
                         await self.close_thread(path=path)
@@ -786,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}"
                 )
 
@@ -806,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)
                     )

meshagent/agents/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-agents
-Version: 0.5.3
+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.3
-Requires-Dist: meshagent-tools~=0.5.3
-Requires-Dist: meshagent-openai~=0.5.3
+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.3; 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.3; 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.3.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=dMuejpjl__bdZ-Qmt-k4e81g-i10vZup7WE1JCZ_Sy4,1392
 meshagent/agents/agent.py,sha256=w14hM63YXiH15VEF1T2eZCvggvrUkE00a1kQkaMRBM0,20354
-meshagent/agents/chat.py,sha256=137LU0qkVxF53SQDV1gSHq2QeSFh4m17sGmXg_Ym77U,31964
+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=tgzuqHKcEdKBaP57F5oXxq4XlW2n9J4Fj8ZGu7nGOZg,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.3.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_agents-0.5.3.dist-info/METADATA,sha256=_Fi7KmyntVN55jJ73d6eLDgs8a6QoljVVH-SCOVx9zE,3773
-meshagent_agents-0.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-meshagent_agents-0.5.3.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_agents-0.5.3.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,,