meshagent-agents 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl

meshagent/agents/agent.py

@@ -3,6 +3,7 @@ from copy import deepcopy
 
 from typing import Optional
 
+from meshagent.api.messaging import unpack_message, pack_message
 from meshagent.api.room_server_client import RoomException, RequiredToolkit, Requirement, RequiredSchema
 from meshagent.api import WebSocketClientProtocol, ToolDescription, ToolkitDescription, Participant, RemoteParticipant, meshagent_base_url, StorageEntry, JsonResponse
 from meshagent.api.protocol import Protocol
@@ -169,17 +170,24 @@ class SingleRoomAgent(Agent):
             elif isinstance(requirement, RequiredSchema):
 
                 if requirement.name not in schemas_by_name:
-                    
+
                     installed = True
 
-                    logger.info(f"Installing required tool {requirement.name}")
-                    
-                    if requirement.name.startswith("https://"):
-                        url = requirement.name
-                    else:    
-                        url = f"{meshagent_base_url()}/schemas/{requirement.name}"
+                    schema_path = f".schemas/{requirement.name}.json"
 
-                    await self._room.agents.make_call(url=url, name=requirement.name, arguments={})
+                   
+                    if await self._room.storage.exists(path=schema_path):
+                        # Schema is already in the room
+                        pass
+                    else:
+                        logger.info(f"Installing required tool {requirement.name}")
+                        
+                        if requirement.name.startswith("https://"):
+                            url = requirement.name
+                        else:
+                            url = f"{meshagent_base_url()}/schemas/{requirement.name}"
+                    
+                        await self._room.agents.make_call(url=url, name=requirement.name, arguments={})
 
             else:
                 raise RoomException("unsupported requirement")
@@ -376,7 +384,7 @@ class TaskRunner(SingleRoomAgent):
         
         async def worker():
             # Decode and parse the message
-            message = json.loads(data.decode('utf-8'))
+            message, _ = unpack_message(data)
             logger.info("agent got message %s", message)
             args = message["arguments"]
             task_id = message["task_id"] 
@@ -456,7 +464,7 @@ class TaskRunner(SingleRoomAgent):
           
                 response = await self.ask(context=context, arguments=args)
                 
-                await protocol.send(type="agent.ask_response", data=json.dumps({ 
+                await protocol.send(type="agent.ask_response", data=pack_message({ 
                     "task_id" : task_id,
                     "answer" : response,
                     "caller_context" : {
@@ -468,7 +476,7 @@ class TaskRunner(SingleRoomAgent):
                 logger.error("Task runner failed to complete task", exc_info=e)
                 if chat_context != None:
                         
-                    await protocol.send(type="agent.ask_response", data=json.dumps({
+                    await protocol.send(type="agent.ask_response", data=pack_message({
                         "task_id" : task_id,
                         "error" : str(e),
                         "caller_context" : {
@@ -476,7 +484,7 @@ class TaskRunner(SingleRoomAgent):
                         }
                     }))
                 else:
-                    await protocol.send(type="agent.ask_response", data=json.dumps({
+                    await protocol.send(type="agent.ask_response", data=pack_message({
                         "task_id" : task_id,
                         "error" : str(e),
                     }))
@@ -522,4 +530,4 @@ async def make_run_task_tool(context: ToolContext, toolkit: RequiredToolkit):
         tools=tools
     )
 
-register_toolkit_factory("agents", make_run_task_tool)
+register_toolkit_factory("agents", make_run_task_tool)

meshagent/agents/chat.py

@@ -3,6 +3,7 @@ from meshagent.api.chan import Chan
 from meshagent.api import RoomMessage, RoomException, RoomClient, RemoteParticipant, RequiredSchema, Requirement, Element, MeshDocument
 from meshagent.tools import Toolkit, ToolContext
 from .adapter import LLMAdapter, ToolResponseAdapter
+from meshagent.openai.tools.responses_adapter import ImageGenerationTool
 import asyncio
 from typing import Optional
 import logging
@@ -11,12 +12,128 @@ import urllib
 import uuid
 import datetime
 import json
+from typing import Literal, Optional
+import base64
 from openai.types.responses import ResponseStreamEvent
 
+from opentelemetry import trace
+
+tracer = trace.get_tracer("meshagent.chatbot")
+
 logger = logging.getLogger("chat")
 
 
-# todo: thread should stop when participant stops?
+
+class ChatBotThreadOpenAIImageGenerationTool(ImageGenerationTool):
+    def __init__(self,
+        *,
+        background: Literal["transparent","opaque","auto"] = None,
+        input_image_mask_url: Optional[str] = None,
+        model: Optional[str] = None,
+        moderation: Optional[str] = None,
+        output_compression: Optional[int] = None,
+        output_format: Optional[Literal["png","webp","jpeg"]] = None,
+        partial_images: Optional[int] = None,
+        quality: Optional[Literal["auto", "low", "medium", "high"]] = None,
+        size: Optional[Literal["1024x1024","1024x1536","1536x1024","auto"]] = None,
+        thread_context: 'ChatThreadContext'
+    ):
+        super().__init__(
+            background=background,
+            input_image_mask_url=input_image_mask_url,
+            model=model,
+            moderation=moderation,
+            output_compression=output_compression,
+            output_format=output_format,
+            partial_images=partial_images,
+            quality=quality,
+            size=size
+        )
+
+        self.thread_context = thread_context
+
+    async def on_image_generation_partial(self, context, *, item_id, output_index, sequence_number, type, partial_image_b64, partial_image_index, size, quality, background, output_format, **extra):
+        
+        output_format = self.output_format
+        if output_format == None:
+            output_format = "png"
+
+        image_name = f"{str(uuid.uuid4())}.{output_format}"
+
+        handle = await context.room.storage.open(path=image_name)
+        await context.room.storage.write(handle=handle, data=base64.b64decode(partial_image_b64))
+        await context.room.storage.close(handle=handle)
+
+
+        messages = None
+
+        for prop in self.thread_context.thread.root.get_children():
+                                
+            if prop.tag_name == "messages":
+
+                messages = prop
+
+        for child in messages.get_children():
+
+            if child.get_attribute("id") == item_id:
+
+                for file in child.get_children():
+                    file.set_attribute("path", image_name)
+
+                return
+
+        message_element = messages.append_child(
+            tag_name="message",                                            
+            attributes={
+                "id" : item_id,
+                "text" : "",
+                "created_at" : datetime.datetime.now(datetime.timezone.utc).isoformat().replace("+00:00","Z"),
+                "author_name" : context.room.local_participant.get_attribute("name"),
+            }
+        )
+        message_element.append_child(tag_name="file", attributes={ "path" : image_name })
+    
+    async def on_image_generated(self, context: ToolContext, *, item_id: str, data: bytes, status: str, size: str, quality: str, background: str, output_format: str, **extra):
+        
+        output_format = self.output_format
+        if output_format == None:
+            output_format = "png"
+
+        image_name = f"{str(uuid.uuid4())}.{output_format}"
+
+        handle = await context.room.storage.open(path=image_name)
+        await context.room.storage.write(handle=handle, data=data)
+        await context.room.storage.close(handle=handle)
+
+
+        messages = None
+
+        for prop in self.thread_context.thread.root.get_children():
+                                
+            if prop.tag_name == "messages":
+
+                messages = prop
+
+        for child in messages.get_children():
+
+            if child.get_attribute("id") == item_id:
+
+                for file in child.get_children():
+                    file.set_attribute("path", image_name)
+
+                return
+        
+        message_element = messages.append_child(
+            tag_name="message",                                            
+            attributes={
+                "id" : item_id,
+                "text" : "",
+                "created_at" : datetime.datetime.now(datetime.timezone.utc).isoformat().replace("+00:00","Z"),
+                "author_name" : context.room.local_participant.get_attribute("name"),
+            }
+        )
+        message_element.append_child(tag_name="file", attributes={ "path" : image_name })
+
 
 def get_thread_participants(*, room: RoomClient, thread: MeshDocument) -> list[RemoteParticipant]:
 
@@ -46,6 +163,7 @@ class ChatThreadContext:
         self.participants = participants
         self.chat = chat
 
+# todo: thread should stop when participant stops?
 class ChatBot(SingleRoomAgent):
     def __init__(self, *, name, title = None, description = None, requires : Optional[list[Requirement]] = None, llm_adapter: LLMAdapter, tool_adapter: Optional[ToolResponseAdapter] = None, toolkits: Optional[list[Toolkit]] = None, rules : Optional[list[str]] = None, auto_greet_message : Optional[str] = None,  empty_state_title : Optional[str] = None, labels: Optional[str] = None):
         
@@ -102,14 +220,22 @@ class ChatBot(SingleRoomAgent):
 
     async def _send_and_save_chat(self, messages: Element, path: str, to: RemoteParticipant, id: str, text: str):
 
-        await self.room.messaging.send_message(to=to, type="chat", message={  "path" : path, "text" : text })
+        with tracer.start_as_current_span("chatbot.say") as span:
 
-        messages.append_child(tag_name="message", attributes={
-            "id" : id,
-            "text" : text,
-            "created_at" : datetime.datetime.now(datetime.timezone.utc).isoformat().replace("+00:00","Z"),
-            "author_name" : self.room.local_participant.get_attribute("name"),
-        })
+            span.set_attributes({
+                "id" : id,
+                "path" : path,
+                "text" : text
+            })
+
+            await self.room.messaging.send_message(to=to, type="chat", message={  "path" : path, "text" : text })
+
+            messages.append_child(tag_name="message", attributes={
+                "id" : id,
+                "text" : text,
+                "created_at" : datetime.datetime.now(datetime.timezone.utc).isoformat().replace("+00:00","Z"),
+                "author_name" : self.room.local_participant.get_attribute("name"),
+            })
         
      
     async def greet(self, *, messages: Element, path: str, chat_context: AgentChatContext, participant: RemoteParticipant):
@@ -219,113 +345,128 @@ class ChatBot(SingleRoomAgent):
                     
                 elif evt.type == "response.output_text.done":
                     content_element = None
+                    
 
         llm_task = asyncio.create_task(process_llm_events())
         llm_task.add_done_callback(done_processing_llm_events)
 
         try:
+
             while True:
-                
+
                 while True:
 
                     received = await messages.recv()
 
-                    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}")
+                    with tracer.start_as_current_span("chatbot.thread.receive") as span:
 
-                    elif current_file != None:
-                        chat_context.append_assistant_message(message=f"the user is not current viewing any files")
+                        span.set_attributes({
+                            "from_participant_id" : received.from_participant_id,
+                            "type" : received.type,
+                            "has_attachment" : received.attachment != None,
+                        })
 
-                
-                    if thread == None:
-                        thread = await self.open_thread(path=path)
-                        
-                        for prop in thread.root.get_children():
+                        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 prop.tag_name == "messages":
+                        if current_file != None:
+                            chat_context.append_assistant_message(message=f"the user is currently viewing the file at the path: {current_file}")
 
-                                doc_messages = prop
+                        elif current_file != None:
+                            chat_context.append_assistant_message(message=f"the user is not current viewing any files")
+
+                    
+                        if thread == None:
+                            with tracer.start_as_current_span("chatbot.open_thread") as span:
+
+                                thread = await self.open_thread(path=path)
                                 
-                                for element in doc_messages.get_children():
+                                for prop in thread.root.get_children():
+                                    
+                                    if prop.tag_name == "messages":
 
-                                    if isinstance(element, Element):
+                                        doc_messages = prop
                                         
-                                        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")
+                                        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
+                        if received.type == "opened":
                             
-                            await self.greet(path=path, chat_context=chat_context, participant=chat_with_participant, messages=doc_messages)
+                            if opened == False:
+                                
+                                opened = True
+                                
+                                await self.greet(path=path, chat_context=chat_context, participant=chat_with_participant, messages=doc_messages)
 
-                    if received.type == "chat":
-                        
-                        if thread == None:
+                        if received.type == "chat":
 
-                            self.room.developer.log_nowait(type="thread is not open", data={})
+                             with tracer.start_as_current_span("chatbot.handle_chat") as span:
+                                
+                                text = received.message["text"]
+                                span.set_attributes({
+                                    "text" : text
+                                })
+                                
+                                if thread == None:
 
-                            break
+                                    self.room.developer.log_nowait(type="thread is not open", data={})
+                                    break
 
 
-                        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})
 
-                        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"] } } })
 
-                        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", [])
 
-                            attachments = received.message.get("attachments", [])
+                                    for attachment in attachments:
 
-                            for attachment in attachments:
+                                        chat_context.append_assistant_message(message=f"the user attached a file at the path '{attachment["path"]}'")
+                                        
 
-                                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 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)
 
-                        # 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)
-
-                        if messages.empty() == True:
-                            break
-            
+                                if messages.empty() == True:
+                                    break
+                    
 
                 try:
 
@@ -401,49 +542,60 @@ class ChatBot(SingleRoomAgent):
         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
+                })
 
-            messages = self._get_message_channel(participant_id=message.from_participant_id)
-            if message.type == "chat" or message.type == "opened":
-                messages.send_nowait(message)
+                messages = self._get_message_channel(participant_id=message.from_participant_id)
+                if message.type == "chat" or message.type == "opened":
+                    path = message.message["path"]
 
-                path = message.message["path"]
-                logger.info(f"received message for thread {path}")
-                
-                if path not in self._thread_tasks or self._thread_tasks[path].cancelled:
-                     
-                    def thread_done(task: asyncio.Task):
+                    span.set_attributes({
+                        "path" : path
+                    })
 
-                        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)
-                    
+                    messages.send_nowait(message)
+
+                    logger.info(f"received message for thread {path}")
                     
-                    task = asyncio.create_task(self._spawn_thread(messages=messages, path=path))
-                    task.add_done_callback(thread_done)
+                    if path not in self._thread_tasks or self._thread_tasks[path].cancelled:
+                        
+                        def thread_done(task: asyncio.Task):
 
-                    self._thread_tasks[path] = 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)
 
-            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)
+                        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)
         

meshagent/agents/hosting.py

@@ -1,7 +1,8 @@
 import logging
 
 from meshagent.api import websocket_protocol, RoomMessage
-from meshagent.api.webhooks import WebhookServer, RoomStartedEvent, RoomEndedEvent, WebSocketClientProtocol, CallEvent
+from meshagent.api.webhooks import WebhookServer, RoomStartedEvent, RoomEndedEvent, CallEvent
+from meshagent.api import WebSocketClientProtocol
 from meshagent.api.room_server_client import RoomClient
 from meshagent.agents import SingleRoomAgent
 from aiohttp import web

meshagent/agents/version.py

@@ -1 +1 @@
-__version__ = "0.0.30"
+__version__ = "0.0.31"

{meshagent_agents-0.0.30.dist-info → meshagent_agents-0.0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-agents
-Version: 0.0.30
+Version: 0.0.31
 Summary: Agent Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,19 +12,20 @@ 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.30
-Requires-Dist: meshagent-tools~=0.0.30
-Requires-Dist: meshagent-openai~=0.0.30
+Requires-Dist: meshagent-api~=0.0.31
+Requires-Dist: meshagent-tools~=0.0.31
+Requires-Dist: meshagent-openai~=0.0.31
 Requires-Dist: pydantic~=2.11.1
 Requires-Dist: pydantic-ai~=0.0.48
+Requires-Dist: opentelemetry-distro~=0.54b1
 Provides-Extra: all
-Requires-Dist: meshagent-api[all]~=0.0.30; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.0.31; 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.30; extra == "sync"
+Requires-Dist: meshagent-api[sync]~=0.0.31; extra == "sync"
 Provides-Extra: mail
 Requires-Dist: aiosmtplib~=4.0.1; extra == "mail"
 Provides-Extra: rag

{meshagent_agents-0.0.30.dist-info → meshagent_agents-0.0.31.dist-info}/RECORD

@@ -1,10 +1,10 @@
 meshagent/agents/__init__.py,sha256=S83622vDM9hWErcgfwZg8lJT2ncu00OEgnxoIbY3VcM,376
 meshagent/agents/adapter.py,sha256=_83Q2XiA8e6Xh37xYnJ9z75AbDWskR-mmKH-LLq6mpA,1318
-meshagent/agents/agent.py,sha256=4U9R2hcOaXhIF1kaWCDf3P2haHuO-oA6nU6wqUTSVe8,19060
-meshagent/agents/chat.py,sha256=ixe91fNt2J-QEWJpuOGCyR0gXNTJLF0_CqRTSrNHDz8,18166
+meshagent/agents/agent.py,sha256=CDxhHWIDj418zEwqsGJ68p3MJc0Ces2GdaJ9BvpSx6I,19423
+meshagent/agents/chat.py,sha256=LjiyQmNEcp5iMeBT26bVfngeXZF3IRJ7muVGrqGFD2w,24491
 meshagent/agents/context.py,sha256=6eFK7wizjzZmZyhbqwazlT_E_e_Cpb17Qa3tBk2BJzw,3804
 meshagent/agents/development.py,sha256=04VYL1Q_BWUTQeVuiVOpyjcs8bzUIX1eQ4VyTtjc5s0,926
-meshagent/agents/hosting.py,sha256=QFSppE-nbL31yuGvzSpES7FyNHpuHCTDDYSnroottn8,4936
+meshagent/agents/hosting.py,sha256=O_extmPJ9J6hKSD8dGED35F75PAbRJa0VEPC-67sLqc,4961
 meshagent/agents/indexer.py,sha256=Lz7hJvC7hbvnmiFQLEzmakw_1OPh93pp96iSwIv1fQc,19410
 meshagent/agents/listener.py,sha256=39u20ZwTNUVR0CRUOi4CTgBreg2ZPbrHQOohwjsfijg,5359
 meshagent/agents/mail.py,sha256=bDQdJphKJr0Sl1_XiVhdd1J7E2DBqbjvxvnIVxGt5UU,10951
@@ -14,7 +14,7 @@ meshagent/agents/pydantic.py,sha256=My9sv1A56unA0qVoPSH-mYtxcgl0AKyxFgyOM70pjLM,
 meshagent/agents/single_shot_writer.py,sha256=QsGvTIw1qtp8nGLfzuJwdZj6ucY4cW9rdecqNwv83FA,3355
 meshagent/agents/thread_schema.py,sha256=-KGAMNxQsVuXpvc0avV-OYHe2LMXpjTu5PyQ-1nBnyE,2667
 meshagent/agents/utils.py,sha256=upMbvG4KODZijeTO3IdW4GgzFPz4jXTzNhZBDmtroic,1431
-meshagent/agents/version.py,sha256=Ji8g_yOyFfpoV8jQQPNpvlINEqW1-F23R31bqwShK9o,22
+meshagent/agents/version.py,sha256=JkmidIUbQFwwAhFKnz2l-8dxIwGERIblSCC4CXcpX08,22
 meshagent/agents/worker.py,sha256=G2Q3UpUCQQ8GtPK5_LW4q8uDOyuJXJM_zdRPsx4puck,3260
 meshagent/agents/writer.py,sha256=2Nk52JcjdRz3EnGBO4EHnv49QzByWiije1LKMNuCAIo,2687
 meshagent/agents/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,8 +23,8 @@ meshagent/agents/schemas/gallery.py,sha256=fzAdlDrn_dJz4FDPkSTH9ir7QmRpV8wFjj6RT
 meshagent/agents/schemas/presentation.py,sha256=DreBXAU7Lx92NBPTlEOZq1gdaRs0OkZrJgPT5N7fYH4,1265
 meshagent/agents/schemas/schema.py,sha256=O52T5nUGRNQ8AsamZ_W_IQ8WRDqSBo3vWFDSQcC7Lcg,4473
 meshagent/agents/schemas/super_editor_document.py,sha256=lFpbZn_s_6hchimddzpnGneJ7LaB6dTN_AnLZsx2r9c,1469
-meshagent_agents-0.0.30.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_agents-0.0.30.dist-info/METADATA,sha256=QI5sGJySCI1OgKph-XeOVCeWy4MCGnAHyFhY4BiUSuQ,1307
-meshagent_agents-0.0.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-meshagent_agents-0.0.30.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_agents-0.0.30.dist-info/RECORD,,
+meshagent_agents-0.0.31.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_agents-0.0.31.dist-info/METADATA,sha256=ldKAbJie7sfVTBaEEyGypPN7irHEKJCTXGlcx74wiHE,1351
+meshagent_agents-0.0.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+meshagent_agents-0.0.31.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_agents-0.0.31.dist-info/RECORD,,