meshagent-agents 0.0.34__tar.gz → 0.0.36__tar.gz

{meshagent_agents-0.0.34 → meshagent_agents-0.0.36}/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.0.36]
+- Stability
+
+## [0.0.35]
+- Stability
+
 ## [0.0.34]
 - Stability
 

{meshagent_agents-0.0.34/meshagent_agents.egg-info → meshagent_agents-0.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-agents
-Version: 0.0.34
+Version: 0.0.36
 Summary: Agent Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -9,23 +9,22 @@ Project-URL: Source, https://www.meshagent.com
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pyjwt~=2.10.1
-Requires-Dist: pytest~=8.3.5
-Requires-Dist: pytest-asyncio~=0.26.0
-Requires-Dist: meshagent-api~=0.0.34
-Requires-Dist: meshagent-tools~=0.0.34
-Requires-Dist: meshagent-openai~=0.0.34
-Requires-Dist: pydantic~=2.11.1
-Requires-Dist: pydantic-ai~=0.0.48
+Requires-Dist: pyjwt~=2.10
+Requires-Dist: pytest~=8.3
+Requires-Dist: pytest-asyncio~=0.26
+Requires-Dist: meshagent-api~=0.0.36
+Requires-Dist: meshagent-tools~=0.0.36
+Requires-Dist: meshagent-openai~=0.0.36
+Requires-Dist: pydantic~=2.11
 Requires-Dist: opentelemetry-distro~=0.54b1
 Provides-Extra: all
-Requires-Dist: meshagent-api[all]~=0.0.34; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.0.36; 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.0.34; extra == "sync"
+Requires-Dist: meshagent-api[sync]~=0.0.36; extra == "sync"
 Provides-Extra: mail
 Requires-Dist: aiosmtplib~=4.0.1; extra == "mail"
 Provides-Extra: rag

{meshagent_agents-0.0.34 → meshagent_agents-0.0.36}/meshagent/agents/agent.py

@@ -174,8 +174,7 @@ class SingleRoomAgent(Agent):
                     installed = True
 
                     schema_path = f".schemas/{requirement.name}.json"
-
-                   
+                    
                     if await self._room.storage.exists(path=schema_path):
                         # Schema is already in the room
                         pass

{meshagent_agents-0.0.34 → meshagent_agents-0.0.36}/meshagent/agents/chat.py

@@ -15,6 +15,7 @@ import json
 from typing import Literal, Optional
 import base64
 from openai.types.responses import ResponseStreamEvent
+from asyncio import CancelledError
 
 from opentelemetry import trace
 
@@ -222,13 +223,15 @@ class ChatBot(SingleRoomAgent):
                     )
                 )
 
-    async def _send_and_save_chat(self, messages: Element, path: str, to: RemoteParticipant, id: str, text: str):
+    async def _send_and_save_chat(self, messages: Element, path: str, to: RemoteParticipant, id: str, text: str, thread_attributes: dict):
 
-        with tracer.start_as_current_span("chatbot.say") as span:
+        with tracer.start_as_current_span("chatbot.thread.message") as span:
 
+            span.set_attributes(thread_attributes)
+            span.set_attribute("role", "assistant")
+            span.set_attribute("from_participant_name", self.room.local_participant.get_attribute("name"))
             span.set_attributes({
                 "id" : id,
-                "path" : path,
                 "text" : text
             })
 
@@ -242,11 +245,11 @@ class ChatBot(SingleRoomAgent):
             })
         
      
-    async def greet(self, *, messages: Element, path: str, chat_context: AgentChatContext, participant: RemoteParticipant):
+    async def greet(self, *, messages: Element, path: str, chat_context: AgentChatContext, participant: RemoteParticipant, thread_attributes: dict):
 
         if self._auto_greet_message != None:
             chat_context.append_user_message(self._auto_greet_message)
-            await self._send_and_save_chat(id=str(uuid.uuid4()), to=RemoteParticipant(id=participant.id), messages=messages, path=path, text= self._auto_greet_message)
+            await self._send_and_save_chat(id=str(uuid.uuid4()), to=RemoteParticipant(id=participant.id), messages=messages, path=path, text= self._auto_greet_message, thread_attributes=thread_attributes)
            
 
     async def get_thread_participants(self, *, thread: MeshDocument):
@@ -300,16 +303,20 @@ class ChatBot(SingleRoomAgent):
         self.room.developer.log_nowait(type="chatbot.thread.started", data={ "path" : path })
         chat_context = await self.init_chat_context()
         opened = False
-        thread = None
+        
         doc_messages = None
         current_file = None
         llm_messages = Chan[ResponseStreamEvent]()
         thread_context = None
+
+        thread_attributes = None
     
 
         def done_processing_llm_events(task: asyncio.Task):
             try:
                 task.result()
+            except CancelledError as e:
+                pass
             except Exception as e:
                 logger.error("error sending delta", exc_info=e)
 
@@ -322,7 +329,7 @@ class ChatBot(SingleRoomAgent):
             async for evt in llm_messages:
                 
                 for participant in self._room.messaging.get_participants():
-                    logger.info(f"sending event {evt.type} to {participant.get_attribute("name")}")
+                    logger.debug(f"sending event {evt.type} to {participant.get_attribute("name")}")
 
                     # self.room.messaging.send_message_nowait(to=participant, type="llm.event", message=json.loads(evt.to_json()))
 
@@ -348,180 +355,207 @@ class ChatBot(SingleRoomAgent):
                 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
+                        })
 
         llm_task = asyncio.create_task(process_llm_events())
         llm_task.add_done_callback(done_processing_llm_events)
 
+        thread = None
+
         try:
 
+            received = None
+
             while True:
 
                 while True:
-
+                    
+                    logger.info(f"waiting for message on thread {path}")
                     received = await messages.recv()
+                    logger.info(f"received message on thread {path}: {received.type}")
 
-                    with tracer.start_as_current_span("chatbot.thread.receive") as span:
+                    chat_with_participant = None
+                    for participant in self._room.messaging.get_participants():
+                        if participant.id == received.from_participant_id:
+                            chat_with_participant = participant
+                            break
+                        
+                    if chat_with_participant == None:
+                        logger.warning("participant does not have messaging enabled, skipping message")
+                        continue
+
+                    thread_attributes = {
+                        "agent_name" : self.name,
+                        "agent_participant_id" : self.room.local_participant.id,
+                        "agent_participant_name" : self.room.local_participant.get_attribute("name"),
+                        "remote_participant_id" : chat_with_participant.id,
+                        "remote_participant_name" : chat_with_participant.get_attribute("name"),
+                        "path" : path,
+                    }
+                
+                    if current_file != chat_with_participant.get_attribute("current_file"):
+                        logger.info(f"participant is now looking at {chat_with_participant.get_attribute("current_file")}")
+                        current_file = chat_with_participant.get_attribute("current_file")
+                        
+                    if current_file != None:
+                        chat_context.append_assistant_message(message=f"the user is currently viewing the file at the path: {current_file}")
 
-                        span.set_attributes({
-                            "from_participant_id" : received.from_participant_id,
-                            "type" : received.type,
-                            "has_attachment" : received.attachment != None,
-                        })
+                    elif current_file != None:
+                        chat_context.append_assistant_message(message=f"the user is not current viewing any files")
 
-                        chat_with_participant = None
-                        for participant in self._room.messaging.get_participants():
-                            if participant.id == received.from_participant_id:
-                                chat_with_participant = participant
-                                break
-                            
-                        if chat_with_participant == None:
-                            logger.warning("participant does not have messaging enabled, skipping message")
-                            continue
-                    
-                        if current_file != chat_with_participant.get_attribute("current_file"):
-                            logger.info(f"participant is now looking at {chat_with_participant.get_attribute("current_file")}")
-                            current_file = chat_with_participant.get_attribute("current_file")
-                            
-                        if current_file != None:
-                            chat_context.append_assistant_message(message=f"the user is currently viewing the file at the path: {current_file}")
+                    if thread == None:
 
-                        elif current_file != None:
-                            chat_context.append_assistant_message(message=f"the user is not current viewing any files")
+                        with tracer.start_as_current_span("chatbot.thread.open") as span:
 
-                    
-                        if thread == None:
-                            with tracer.start_as_current_span("chatbot.open_thread") as span:
+                            span.set_attributes(thread_attributes)
 
-                                thread = await self.open_thread(path=path)
+                            thread = await self.open_thread(path=path)
+                            
+                            for prop in thread.root.get_children():
                                 
-                                for prop in thread.root.get_children():
+                                if prop.tag_name == "messages":
+
+                                    doc_messages = prop
                                     
-                                    if prop.tag_name == "messages":
+                                    for element in doc_messages.get_children():
+
+                                        if isinstance(element, Element):
+                                            
+                                            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 == None:
+                                raise Exception("thread was not properly initialized")
 
-                                        doc_messages = prop
-                                        
-                                        for element in doc_messages.get_children():
-
-                                            if isinstance(element, Element):
-                                                
-                                                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 == None:
-                                    raise Exception("thread was not properly initialized")
 
+                    if received.type == "opened":
+                        
+                        if opened == False:
+                            
+                            opened = True
+                            
+                            await self.greet(path=path, chat_context=chat_context, participant=chat_with_participant, messages=doc_messages, thread_attributes=thread_attributes)
 
-                        if received.type == "opened":
+                    if received.type == "chat":
                             
-                            if opened == False:
-                                
-                                opened = True
-                                
-                                await self.greet(path=path, chat_context=chat_context, participant=chat_with_participant, messages=doc_messages)
+                        
+                        if thread == None:
 
-                        if received.type == "chat":
+                            self.room.developer.log_nowait(type="thread is not open", data={})
+                            break
 
-                             with tracer.start_as_current_span("chatbot.handle_chat") as span:
-                                
-                                text = received.message["text"]
-                                span.set_attributes({
-                                    "text" : text
-                                })
-                                
-                                if thread == None:
 
-                                    self.room.developer.log_nowait(type="thread is not open", data={})
-                                    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"] } } })
 
-                                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})
+                            attachments = received.message.get("attachments", [])
+                            text = received.message["text"]
 
-                                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"] } } })
+                            for attachment in attachments:
 
-                                    attachments = received.message.get("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_user_message(message=text)
+                                
 
-                                        chat_context.append_assistant_message(message=f"the user attached a file at the path '{attachment["path"]}'")
-                                        
+                        # if user is typing, wait for typing to stop
+                        while True:
+                            
+                            if chat_with_participant.id not in self._is_typing:
+                                break
+                        
+                            await asyncio.sleep(.5)
 
-                                    chat_context.append_user_message(message=text)
-                                        
+                        if messages.empty() == True:
+                            break
+                
+                if received != None:
 
-                                # if user is typing, wait for typing to stop
-                                while True:
+                    with tracer.start_as_current_span("chatbot.thread.message") as span:
                                     
-                                    if chat_with_participant.id not in self._is_typing:
-                                        break
-                                
-                                    await asyncio.sleep(.5)
+                        span.set_attributes(thread_attributes)
+                        span.set_attribute("role", "user")
+                        span.set_attribute("from_participant_name", chat_with_participant.get_attribute("name"))
 
-                                if messages.empty() == True:
-                                    break
-                    
+                        attachments = received.message.get("attachments", [])
+                        span.set_attribute("attachments", attachments)
+
+                        text = received.message["text"]
+                        span.set_attributes({
+                            "text" : text
+                        })
+
+                        try:
+                            
+                            if thread_context == None:
+                            
+                                thread_context = ChatThreadContext(
+                                    chat=chat_context,
+                                    thread=thread,
+                                    participants=get_thread_participants(room=self.room, thread=thread)
+                                )
 
-                try:
+                            def handle_event(evt):
+                                llm_messages.send_nowait(evt)
 
+                            with tracer.start_as_current_span("chatbot.llm") as span: 
 
-                    
-                    if thread_context == None:
-                      
-                        thread_context = ChatThreadContext(
-                            chat=chat_context,
-                            thread=thread,
-                            participants=get_thread_participants(room=self.room, thread=thread)
-                        )
-
-                    def handle_event(evt):
-                        llm_messages.send_nowait(evt)
-                        
-                    try:
-                        response = await self._llm_adapter.next(
-                            context=chat_context,
-                            room=self._room,
-                            toolkits=await self.get_thread_toolkits(thread_context=thread_context, participant=participant),
-                            tool_adapter=self._tool_adapter,
-                            event_handler=handle_event
-                        )
-                    except Exception as e:
-                        logger.error("An error was encountered", exc_info=e)
-                        await self._send_and_save_chat(messages=doc_messages, to=chat_with_participant, path=path, id=str(uuid.uuid4()), text="There was an error while communicating with the LLM. Please try again later.")
-    
-                    
-                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})
+                                try:
+
+                                    with tracer.start_as_current_span("get_thread_toolkits") as span:
+                                        
+                                        thread_toolkits = await self.get_thread_toolkits(thread_context=thread_context, participant=participant)
+
+                                    response = await self._llm_adapter.next(
+                                        context=chat_context,
+                                        room=self._room,
+                                        toolkits=thread_toolkits,
+                                        tool_adapter=self._tool_adapter,
+                                        event_handler=handle_event
+                                    )
+                                except Exception as e:
+                                    logger.error("An error was encountered", exc_info=e)
+                                    await self._send_and_save_chat(messages=doc_messages, to=chat_with_participant, path=path, id=str(uuid.uuid4()), text="There was an error while communicating with the LLM. Please try again later.", thread_attributes=thread_attributes)
+
+                        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})
 
-                   
         finally:
-            
-            
+
             llm_messages.close()
 
             if self.room != None:
+                logger.info("thread was ended {path}")
                 self.room.developer.log_nowait(type="chatbot.thread.ended", data={ "path" : path })
     
                 if thread != None:
                     await self.close_thread(path=path)
-    
 
-    def _get_message_channel(self, participant_id: str) -> Chan[RoomMessage]:
-        if participant_id not in self._message_channels:
+    def _get_message_channel(self, key: str) -> Chan[RoomMessage]:
+        if key not in self._message_channels:
             chan = Chan[RoomMessage]()
-            self._message_channels[participant_id] = chan
+            self._message_channels[key] = chan
 
-        chan = self._message_channels[participant_id]
+        chan = self._message_channels[key]
         
         return chan
     
@@ -537,67 +571,60 @@ class ChatBot(SingleRoomAgent):
 
         await super().start(room=room)
 
-        logger.info("Starting chatbot")
+        logger.debug("Starting chatbot")
         
         await self.room.local_participant.set_attribute("empty_state_title", self._empty_state_title)
 
         def on_message(message: RoomMessage):
 
-            logger.info(f"received message {message.type}")
             
-            with tracer.start_as_current_span("chatbot.receive") as span:
-               
-                span.set_attributes({
-                    "type" : message.type,
-                    "from_participant_id" : message.from_participant_id
-                })
+            if message.type == "chat" or message.type == "opened":
 
-                messages = self._get_message_channel(participant_id=message.from_participant_id)
-                if message.type == "chat" or message.type == "opened":
-                    path = message.message["path"]
-
-                    span.set_attributes({
-                        "path" : path
-                    })
+                path = message.message["path"]
+                
+                messages = self._get_message_channel(path)
 
-                    messages.send_nowait(message)
+                logger.info(f"queued incoming message for thread {path}: {message.type}")
+                
+                messages.send_nowait(message)
 
-                    logger.info(f"received message for thread {path}")
+                if path not in self._thread_tasks or self._thread_tasks[path].done():
                     
-                    if path not in self._thread_tasks or self._thread_tasks[path].cancelled:
-                        
-                        def thread_done(task: asyncio.Task):
+                    def thread_done(task: asyncio.Task):
 
-                            self._message_channels.pop(message.from_participant_id)
-                            try:
-                                task.result()
-                            except Exception as e:
-                                logger.error(f"The chat thread ended with an error {e}", exc_info=e)
-                        
-                        
-                        task = asyncio.create_task(self._spawn_thread(messages=messages, path=path))
-                        task.add_done_callback(thread_done)
-
-                        self._thread_tasks[path] = task
-
-                elif message.type == "typing":
-                    def callback(task: asyncio.Task):
+                        self._message_channels.pop(path)
                         try:
                             task.result()
-                        except:
+                        except CancelledError as e:
                             pass
+                        except Exception as e:
+                            logger.error(f"The chat thread ended with an error {e}", exc_info=e)
+                    
                     
-                    async def remove_timeout(id: str):
-                        await asyncio.sleep(1)
-                        self._is_typing.pop(id)
+                    logger.info(f"spawning chat thread for {path}")
+                    task = asyncio.create_task(self._spawn_thread(messages=messages, path=path))
+                    task.add_done_callback(thread_done)
+
+                    self._thread_tasks[path] = task
+
+            elif message.type == "typing":
+                def callback(task: asyncio.Task):
+                    try:
+                        task.result()
+                    except:
+                        pass
+                
+                async def remove_timeout(id: str):
+                    await asyncio.sleep(1)
+                    self._is_typing.pop(id)
 
-                    if message.from_participant_id in self._is_typing:
-                        self._is_typing[message.from_participant_id].cancel()
+                if message.from_participant_id in self._is_typing:
+                    self._is_typing[message.from_participant_id].cancel()
 
-                    timeout = asyncio.create_task(remove_timeout(id=message.from_participant_id))
-                    timeout.add_done_callback(callback)
+                timeout = asyncio.create_task(remove_timeout(id=message.from_participant_id))
+                timeout.add_done_callback(callback)
 
-                    self._is_typing[message.from_participant_id] = timeout
+                self._is_typing[message.from_participant_id] = timeout
 
         room.messaging.on("message", on_message)
         
@@ -611,6 +638,6 @@ class ChatBot(SingleRoomAgent):
             room.messaging.on("participant_added", on_participant_added)
 
 
-        logger.info("Enabling chatbot messaging")
+        logger.debug("Enabling chatbot messaging")
         await room.messaging.enable()
 

{meshagent_agents-0.0.34 → meshagent_agents-0.0.36}/meshagent/agents/hosting.py

@@ -39,7 +39,7 @@ class RemoteTaskRunnerServer[T:TaskRunner](WebhookServer):
 
                 def on_message(message: RoomMessage):
                     if message.type == "dismiss":
-                        logger.info(f"dismissed 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)
@@ -81,7 +81,7 @@ class RemoteAgentServer[T:SingleRoomAgent](WebhookServer):
     
     async def _spawn(self, *, room_name: str, room_url: str, token: str, arguments: Optional[dict] = None):
 
-        logger.info(f"room: {room_name} url: {room_url} token: {token} arguments: {arguments}")
+        logger.info(f"spawning agent on room: {room_name} url: {room_url} arguments: {arguments}")
         agent = self._create_agent(arguments=arguments)
 
         async def run():
@@ -91,7 +91,7 @@ class RemoteAgentServer[T:SingleRoomAgent](WebhookServer):
 
                 def on_message(message: RoomMessage):
                     if message.type == "dismiss":
-                        logger.info(f"dismissed by {message.from_participant_id}")
+                        logger.info(f"dismissed agent by {message.from_participant_id}")
                         dismissed.set_result(True)
 
                 room.messaging.on("message", on_message)

meshagent_agents-0.0.36/meshagent/agents/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.36"

{meshagent_agents-0.0.34 → meshagent_agents-0.0.36/meshagent_agents.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-agents
-Version: 0.0.34
+Version: 0.0.36
 Summary: Agent Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -9,23 +9,22 @@ Project-URL: Source, https://www.meshagent.com
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pyjwt~=2.10.1
-Requires-Dist: pytest~=8.3.5
-Requires-Dist: pytest-asyncio~=0.26.0
-Requires-Dist: meshagent-api~=0.0.34
-Requires-Dist: meshagent-tools~=0.0.34
-Requires-Dist: meshagent-openai~=0.0.34
-Requires-Dist: pydantic~=2.11.1
-Requires-Dist: pydantic-ai~=0.0.48
+Requires-Dist: pyjwt~=2.10
+Requires-Dist: pytest~=8.3
+Requires-Dist: pytest-asyncio~=0.26
+Requires-Dist: meshagent-api~=0.0.36
+Requires-Dist: meshagent-tools~=0.0.36
+Requires-Dist: meshagent-openai~=0.0.36
+Requires-Dist: pydantic~=2.11
 Requires-Dist: opentelemetry-distro~=0.54b1
 Provides-Extra: all
-Requires-Dist: meshagent-api[all]~=0.0.34; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.0.36; 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.0.34; extra == "sync"
+Requires-Dist: meshagent-api[sync]~=0.0.36; extra == "sync"
 Provides-Extra: mail
 Requires-Dist: aiosmtplib~=4.0.1; extra == "mail"
 Provides-Extra: rag

{meshagent_agents-0.0.34 → meshagent_agents-0.0.36}/meshagent_agents.egg-info/requires.txt

@@ -1,15 +1,14 @@
-pyjwt~=2.10.1
-pytest~=8.3.5
-pytest-asyncio~=0.26.0
-meshagent-api~=0.0.34
-meshagent-tools~=0.0.34
-meshagent-openai~=0.0.34
-pydantic~=2.11.1
-pydantic-ai~=0.0.48
+pyjwt~=2.10
+pytest~=8.3
+pytest-asyncio~=0.26
+meshagent-api~=0.0.36
+meshagent-tools~=0.0.36
+meshagent-openai~=0.0.36
+pydantic~=2.11
 opentelemetry-distro~=0.54b1
 
 [all]
-meshagent-api[all]~=0.0.34
+meshagent-api[all]~=0.0.36
 chonkie~=0.5.1
 chonkie[semantic]~=0.5.1
 chonkie[openai]~=0.5.1
@@ -24,4 +23,4 @@ chonkie[semantic]~=0.5.1
 chonkie[openai]~=0.5.1
 
 [sync]
-meshagent-api[sync]~=0.0.34
+meshagent-api[sync]~=0.0.36

{meshagent_agents-0.0.34 → meshagent_agents-0.0.36}/pyproject.toml

@@ -14,20 +14,19 @@ license = "Apache-2.0"
 classifiers = []
 keywords = []
 dependencies = [
-  "pyjwt~=2.10.1",
-  "pytest~=8.3.5",
-  "pytest-asyncio~=0.26.0",
-  "meshagent-api~=0.0.34",
-  "meshagent-tools~=0.0.34",
-  "meshagent-openai~=0.0.34",
-  "pydantic~=2.11.1",
-  "pydantic-ai~=0.0.48",
+  "pyjwt~=2.10",
+  "pytest~=8.3",
+  "pytest-asyncio~=0.26",
+  "meshagent-api~=0.0.36",
+  "meshagent-tools~=0.0.36",
+  "meshagent-openai~=0.0.36",
+  "pydantic~=2.11",
   "opentelemetry-distro~=0.54b1"
 ]
 
 [project.optional-dependencies]
 all = [
-    "meshagent-api[all]~=0.0.34",
+    "meshagent-api[all]~=0.0.36",
     "chonkie~=0.5.1",
     "chonkie[semantic]~=0.5.1",
     "chonkie[openai]~=0.5.1",
@@ -35,7 +34,7 @@ all = [
 ]
 
 sync = [
-    "meshagent-api[sync]~=0.0.34",
+    "meshagent-api[sync]~=0.0.36",
 ]
 
 mail = [

meshagent_agents-0.0.34/meshagent/agents/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.34"