meshagent-agents 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

meshagent/agents/__init__.py

@@ -3,3 +3,4 @@ from .development import connect_development_agent
 from .listener import Listener, ListenerContext
 from .hosting import RemoteTaskRunnerServer
 from .adapter import ToolResponseAdapter, LLMAdapter
+from .thread_schema import thread_schema

meshagent/agents/adapter.py

@@ -3,7 +3,7 @@ from .agent import AgentChatContext
 from jsonschema import validate
 from meshagent.tools.toolkit import Response, Toolkit
 from meshagent.api import RoomClient
-from typing import Any, Optional
+from typing import Any, Optional, Callable
 
 class ToolResponseAdapter(ABC):
     def __init__(self):
@@ -14,15 +14,19 @@ class ToolResponseAdapter(ABC):
         pass
 
     @abstractmethod
-    async def append_messages(self, *, context: AgentChatContext, tool_call: Any, room: RoomClient, response: Response):
+    async def create_messages(self, *, context: AgentChatContext, tool_call: Any, room: RoomClient, response: Response) -> list:
         pass
 
 
-class LLMAdapter(ABC):
+class LLMAdapter[T](ABC):
 
     def create_chat_context(self) -> AgentChatContext:
         return AgentChatContext()
     
+    @abstractmethod
+    async def check_for_termination(self, *, context: AgentChatContext, room: RoomClient):
+        return True
+
     @abstractmethod
     async def next(self, 
         *,
@@ -31,6 +35,7 @@ class LLMAdapter(ABC):
         toolkits: Toolkit,
         tool_adapter: Optional[ToolResponseAdapter] = None,
         output_schema: Optional[dict] = None,
+        event_handler: Optional[Callable[[T],None]] = None
     ) -> Any:  
         pass
 

meshagent/agents/agent.py

@@ -8,11 +8,9 @@ from meshagent.api import WebSocketClientProtocol, ToolDescription, ToolkitDescr
 from meshagent.api.protocol import Protocol
 from meshagent.tools.toolkit import Toolkit, Tool, ToolContext
 from meshagent.api.room_server_client import RoomClient, RoomException
-from meshagent.api.schema_document import Document
 from jsonschema import validate
-from typing import Callable, Awaitable
 from .context import AgentCallContext, AgentChatContext
-from .schema import no_arguments_schema
+from meshagent.api.schema_util import no_arguments_schema
 import logging
 import asyncio
 from typing import Optional
@@ -45,6 +43,7 @@ class RoomTool(Tool):
 class Agent:
 
     def __init__(self, *, name: str, title: Optional[str] = None, description: Optional[str] = None, requires: Optional[list[Requirement]] = None, labels: Optional[list[str]] = None):
+       
         self._name = name
         if title == None:
             title = name
@@ -55,6 +54,8 @@ class Agent:
         self._description = description
         if requires == None:
             requires = []
+
+        self.init_requirements(requires)
         self._requires = requires
         
         if labels == None:
@@ -82,6 +83,8 @@ class Agent:
     def labels(self):
         return self._labels
     
+    def init_requirements(self, requires): ...
+    
     async def init_chat_context(self) -> AgentChatContext:
         return AgentChatContext() 
 
@@ -100,6 +103,7 @@ class SingleRoomAgent(Agent):
         super().__init__(name=name, title=title, description=description, requires=requires, labels=labels)
         self._room = None
 
+
     async def start(self, *, room: RoomClient) -> None:
 
         if self._room != None:
@@ -107,6 +111,9 @@ class SingleRoomAgent(Agent):
         
         self._room = room
 
+        await self.install_requirements()
+
+
     async def stop(self) -> None:
         self._room = None
         pass
@@ -121,7 +128,6 @@ class SingleRoomAgent(Agent):
 
         schemas = await self._room.storage.list(path=".schemas")
         
-
         for schema in schemas:
             schemas_by_name[schema.name] = schema
 
@@ -137,6 +143,11 @@ class SingleRoomAgent(Agent):
         for requirement in self.requires:
             
             if isinstance(requirement, RequiredToolkit):
+                
+                if requirement.name == "meshagent.ui":
+                    # TODO: maybe requirements can be marked as non installable?
+                    continue
+                
                 if requirement.name not in toolkits_by_name:
                     
                     installed = True
@@ -369,9 +380,6 @@ class TaskRunner(SingleRoomAgent):
                     )
 
 
-                await self.install_requirements(participant_id=caller.id)
-
-
                 context = AgentCallContext(chat=chat_context, room=self.room, caller=caller)
     
                 for toolkit_json in toolkits_json:

meshagent/agents/chat.py

@@ -1,6 +1,6 @@
-from .agent import SingleRoomAgent, AgentChatContext
+from .agent import SingleRoomAgent, AgentChatContext, AgentCallContext
 from meshagent.api.chan import Chan
-from meshagent.api import RoomMessage, RoomException, RoomClient, RemoteParticipant
+from meshagent.api import RoomMessage, RoomException, RoomClient, RemoteParticipant, RequiredSchema, Requirement, Element, MeshDocument
 from meshagent.tools import Toolkit
 from .adapter import LLMAdapter, ToolResponseAdapter
 import asyncio
@@ -8,6 +8,10 @@ from typing import Optional
 import logging
 from meshagent.tools import MultiToolkit
 import urllib
+import uuid
+import datetime
+
+from openai.types.responses import ResponseStreamEvent
 
 logging.basicConfig()
 logger = logging.getLogger("chat")
@@ -16,8 +20,38 @@ logger.setLevel(logging.INFO)
 
 # todo: thread should stop when participant stops?
 
+def get_thread_participants(*, room: RoomClient, thread: MeshDocument) -> list[RemoteParticipant]:
+
+    results = list[RemoteParticipant]()
+
+    for prop in thread.root.get_children():
+
+        if prop.tag_name == "members":
+
+            for member in prop.get_children():
+
+                for online in room.messaging.get_participants():
+
+                    if online.get_attribute("name") == member.get_attribute("name"):
+
+                        results.append(online)
+
+    return results
+
+
+class ChatThreadContext:
+    def __init__(self, *, chat: AgentChatContext, thread: MeshDocument, toolkits: list[Toolkit], participants: Optional[list[RemoteParticipant]] = None):
+        self.thread = thread
+        self.toolkits = toolkits
+        if participants == None:
+            participants = []
+
+        self.participants = participants
+        self.chat = chat
+
 class ChatBot(SingleRoomAgent):
-    def __init__(self, *, name, title = None, description = None, requires = None,  llm_adapter: LLMAdapter, tool_adapter: Optional[ToolResponseAdapter] = None, toolkits: Optional[list[Toolkit]] = None, rules : Optional[list[str]] = None, auto_greet_prompt : Optional[str] = None, auto_greet_message : Optional[str] = None,  empty_state_title : Optional[str] = None, labels: Optional[str] = None):
+    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):
+        
         super().__init__(
             name=name,
             title=title,
@@ -42,30 +76,60 @@ class ChatBot(SingleRoomAgent):
 
         self._rules = rules
         self._is_typing = dict[str,asyncio.Task]()
-        self._auto_greet_prompt = auto_greet_prompt
         self._auto_greet_message = auto_greet_message
         
         if empty_state_title == None:
             empty_state_title = "How can I help you?"
         self._empty_state_title = empty_state_title
 
+        self._thread_tasks = dict[str,asyncio.Task]()
 
-    async def greet(self, *, chat_context: AgentChatContext, messages: Chan[RoomMessage], participant: RemoteParticipant):
+    def init_requirements(self, requires: list[Requirement]):
+        if requires == None:
 
-        if self._auto_greet_prompt != None:
-            messages.send_nowait(RoomMessage(from_participant_id=participant.id, type="chat",  message={"text": self._auto_greet_prompt }))
+            requires = [
+                RequiredSchema(
+                    name="thread"
+                )
+            ]
+
+        else:
+            
+            thread_schema = list(n for n in requires if (isinstance(n, RequiredSchema) and n.name == "thread"))
+            if len(thread_schema) == 0:
+                requires.append(
+                    RequiredSchema(
+                        name="thread"
+                    )
+                )
+
+    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 })
+
+        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):
+
         if self._auto_greet_message != None:
             chat_context.append_user_message(self._auto_greet_message)
-            
-            await self.room.messaging.send_message(to=RemoteParticipant(id=participant.id), type="chat", message={ "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)
+           
 
-    async def finalize_toolkits(self, toolkits) -> list[Toolkit]:
+    async def get_thread_participants(self, *, thread: MeshDocument):
+        return get_thread_participants(room=self._room, thread=thread)
+    
+    async def init_thread_context(self, *, thread_context: ChatThreadContext) -> list[Toolkit]:
 
         toaster = None
         
-        for toolkit in toolkits:
+        for toolkit in thread_context.toolkits:
 
             if toolkit.name == "meshagent.ui":
 
@@ -83,180 +147,223 @@ class ChatBot(SingleRoomAgent):
                 
                 return MultiToolkit(required=[ toaster ], base_toolkit=toolkit )
 
-            toolkits = list(map(multi_tool, toolkits))
+            toolkits = list(map(multi_tool, thread_context.toolkits))
         
-        return toolkits
+        thread_context.toolkits = toolkits
 
-    async def _spawn_thread(self, participant_id: str, messages: Chan[RoomMessage]):
+    
+    async def init_chat_context(self) -> AgentChatContext:
+        context =  self._llm_adapter.create_chat_context()
+        context.append_rules(self._rules)
+        return context
 
-        
-        chat_context = await self.init_chat_context()
-        
+    async def open_thread(self, *, path: str):
 
-        chat_context.append_rules(
-            rules=[
-                *self._rules,
-                "think step by step",
-           ]
-        )
 
-        opened = False
-        chat_with_participant = None
+        return await self.room.sync.open(path=path)
+    
+    async def close_thread(self, *, path: str):
 
-        for participant in self._room.messaging.get_participants():
-            if participant.id == participant_id:
-                chat_with_participant = participant
-                break
+        return await self.room.sync.close(path=path)
 
-        if chat_with_participant == None:
-            raise RoomException(f"caller did not have messaging turned on")
-        
-        messaging = self._room.messaging
 
+    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
+        thread = None
+        doc_messages = None
         current_file = None
+        llm_messages = Chan[ResponseStreamEvent]()
         
-        step_schema = {
-            "type" : "object",
-            "required" : ["text","finished"],
-            "additionalProperties" : False, 
-            "description" : "execute a step",
-            "properties" : {
-                "text" : {
-                    "description" : "a reply to the user or status to display during an intermediate step",
-                    "type" : "string"
-                },
-                "finished" : {
-                    "description" : "whether the agent has finished answering the user's last message. you MUST set this to true if there are no more tool calls to be made or you are stuck in a loop.",
-                    "type" : "boolean"
-                }
-            }
-        }
-
-        installed = False
-
-        while True:
-            
-            while True:
+        def done_processing_llm_events(task: asyncio.Task):
+            try:
+                task.result()
+            except Exception as e:
+                logger.error("error sending delta", exc_info=e)
 
-             
+        async def process_llm_events():
 
-                received = await messages.recv()
+            partial = ""
+            content_element = None
+            context_message = None
 
+            async for evt in llm_messages:
                 
-
-                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")
+                #await self.room.messaging.send_message(to=chat_with_participant, type="llm.event", message=evt)
+
+                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)
+                 
+                elif evt.type == "response.output_text.delta":
+                    partial += evt.delta
+                    content_element["text"] = partial
+                    context_message["content"] = partial
                     
-                if current_file != None:
-                    chat_context.append_assistant_message(message=f"the user is currently viewing the file at the path: {current_file}")
-
-                elif current_file != None:
-                    chat_context.append_assistant_message(message=f"the user is not current viewing any files")
+                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:
 
-                if installed == False:
-                    installed = True
-                    try:
-                        await self.install_requirements(participant_id=participant_id)
-                    except Exception as e:
-                        self.room.developer.log_nowait("error", { "text" : f"unable to install requirements: {e}" })
-
-                        error = "I was unable to install the tools I require to operate in the room, I may not function properly."
-                        chat_context.append_user_message(message=error)
-                        await self._room.messaging.send_message(
-                            to=chat_with_participant,
-                            type="chat",
-                            message={
-                                "text": error
-                            }
-                        )
+                    received = await messages.recv()
 
-                if received.type == "opened":
-                    
-                    
-                    if opened == False:
+                    chat_with_participant = None
+                    for participant in self._room.messaging.get_participants():
+                        if participant.id == received.from_participant_id:
+                            chat_with_participant = participant
+                            break
                         
-                        opened = True
+                    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")
                         
-                        await self.greet(chat_context=chat_context, participant=chat_with_participant, messages=messages)
-
-                if received.type == "chat":
+                    if current_file != None:
+                        chat_context.append_assistant_message(message=f"the user is currently viewing the file at the path: {current_file}")
 
+                    elif current_file != None:
+                        chat_context.append_assistant_message(message=f"the user is not current viewing any files")
 
-                    await self._room.messaging.send_message(to=chat_with_participant, type="thinking", message={"thinking":True})
                 
-                    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"] } } })
-                
-                        text = received.message["text"]
-                        attachments = received.message.get("attachments", [])
+                    if thread == None:
+                        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):
+                                        
+                                        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)
+                        
+                        if doc_messages == None:
+                            raise Exception("thread was not properly initialized")
 
-                        for attachment in attachments:
 
-                            chat_context.append_assistant_message(message=f"the user attached a file '{attachment["filename"]}' with the content: '{attachment["content"]}'")
+                    if received.type == "opened":
+                        
+                        if opened == False:
                             
-
-                        chat_context.append_user_message(message=text)
+                            opened = True
                             
+                            await self.greet(path=path, chat_context=chat_context, participant=chat_with_participant, messages=doc_messages)
 
-                    # if user is typing, wait for typing to stop
-                    while True:
+                    if received.type == "chat":
                         
-                        if chat_with_participant.id not in self._is_typing:
+                        if thread == None:
+
+                            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
+                            await self._room.messaging.send_message(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"] } } })
                     
-                        await asyncio.sleep(.5)
+                        
+                            attachments = received.message.get("attachments", [])
 
-                    if messages.empty() == True:
-                        break
-        
+                            for attachment in attachments:
 
-            try:
-                while True:
+                                chat_context.append_assistant_message(message=f"the user attached a file '{attachment["filename"]}' with the content: '{attachment["content"]}'")
+                                
 
+                            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 messages.empty() == True:
+                            break
+            
+
+                try:
+                
                     toolkits = [
                         *self._toolkits,
                         *await self.get_required_tools(participant_id=chat_with_participant.id)
                     ]
 
-                    toolkits = await self.finalize_toolkits(toolkits)
-
-                    response = await self._llm_adapter.next(
-                        context=chat_context,
-                        room=self._room,
+                    thread_context = ChatThreadContext(
+                        chat=chat_context,
+                        thread=thread,
                         toolkits=toolkits,
-                        tool_adapter=self._tool_adapter,
-                        output_schema=step_schema,
                     )
 
-                    text = response["text"]
-                    
-                    
-                    if response["finished"] or len(toolkits) == 0:
-                        await self._room.messaging.send_message(
-                            to=chat_with_participant,
-                            type="chat",
-                            message={
-                                "text": text
-                            }
-                        )
-                        break
-                    else:
-                        await self._room.messaging.send_message(
-                            to=chat_with_participant,
-                            type="status",
-                            message={
-                                "text": text
-                            }
+                    await self.init_thread_context(thread_context=thread_context)
+
+                    def handle_event(evt):
+                        llm_messages.send_nowait(evt)
+                        
+                    try:
+                        response = await self._llm_adapter.next(
+                            context=chat_context,
+                            room=self._room,
+                            toolkits=toolkits,
+                            tool_adapter=self._tool_adapter,
+                            event_handler=handle_event
                         )
-                        chat_context.append_user_message(message="proceed to the next step if you are ready")
-                
-            finally:
+                    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
+                        await self._room.messaging.send_message(to=participant, type="thinking", message={"thinking":False, "path" : path})
+
+                   
+        finally:
 
-                await self._room.messaging.send_message(to=chat_with_participant, type="thinking", message={"thinking":False})
+            self.room.developer.log_nowait(type="chatbot.thread.ended", data={ "path" : path })
+    
+            llm_messages.close()
 
+            if thread != None:
+                await self.close_thread(path=path)
    
 
     def _get_message_channel(self, participant_id: str) -> Chan[RoomMessage]:
@@ -264,37 +371,50 @@ class ChatBot(SingleRoomAgent):
             chan = Chan[RoomMessage]()
             self._message_channels[participant_id] = chan
 
-            def thread_done(task: asyncio.Task):
-
-                self._message_channels.pop(participant_id)
-                try:
-                    task.result()
-                    logger.info("ending chat thread")
-                except Exception as e:
-                    logger.error("chat thread error", exc_info=e)
-
-            task = asyncio.create_task(self._spawn_thread(participant_id=participant_id, messages=chan))
-            task.add_done_callback(thread_done)
-        
         chan = self._message_channels[participant_id]
         
         return chan
     
-    async def start(self, *, room):
+    async def stop(self):
+        await super().stop()
 
-        await super().start(room=room)
+        for thread in self._thread_tasks.values():
+            thread.cancel()
+        
+        self._thread_tasks.clear()
 
+    async def start(self, *, room):
 
+        await super().start(room=room)
+        
         await self.room.local_participant.set_attribute("empty_state_title", self._empty_state_title)
 
         def on_message(message: RoomMessage):
+
             messages = self._get_message_channel(participant_id=message.from_participant_id)
             if message.type == "chat" or message.type == "opened":
                 messages.send_nowait(message)
-    
-            elif message.type == "typing":
 
+                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):
+
+                        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):
                     try:
                         task.result()
@@ -315,7 +435,7 @@ class ChatBot(SingleRoomAgent):
 
         room.messaging.on("message", on_message)
         
-        if self._auto_greet_prompt != None or self._auto_greet_message != None:
+        if self._auto_greet_message != None:
             def on_participant_added(participant:RemoteParticipant):
                 
                 # will spawn the initial thread

meshagent/agents/context.py

@@ -16,6 +16,9 @@ class AgentChatContext:
         if system_role == None:
             system_role = "system"
         self._system_role = system_role
+
+        self._previous_response_id = None
+        self._previous_messages = list[dict]()
     
     @property
     def messages(self):
@@ -24,6 +27,19 @@ class AgentChatContext:
     @property
     def system_role(self):
         return self._system_role
+    
+    @property
+    def previous_messages(self):
+        return self._previous_messages
+    
+    @property
+    def previous_response_id(self):
+        return self._previous_response_id
+    
+    def create_response(self, id: str):
+        self._previous_response_id = id
+        self._previous_messages.extend(self.messages)
+        self.messages.clear()
 
     def append_rules(self, rules: list[str]):
         

meshagent/agents/indexer.py

@@ -283,9 +283,6 @@ class StorageIndexer(SingleRoomAgent):
 
         self._index_task = asyncio.create_task(self._indexer())
         self._index_task.add_done_callback(index_task)
-
-        await self.install_requirements()
-
     
     async def stop(self):
         await super().stop()

meshagent/agents/planning.py

@@ -7,7 +7,7 @@ from meshagent.api.schema import MeshSchema
 from meshagent.agents.writer import Writer, WriterContext
 from meshagent.agents.adapter import LLMAdapter, ToolResponseAdapter
 from meshagent.api.schema import MeshSchema, ElementType, ChildProperty, ValueProperty
-from meshagent.agents.schema import merge
+from meshagent.api.schema_util import merge
 from meshagent.tools.document_tools import build_tools, DocumentAuthoringToolkit
 from meshagent.agents import TaskRunner
 from copy import deepcopy
@@ -120,7 +120,7 @@ def reasoning_schema(*, description: str, elements: Optional[list[ElementType]]
             *elements
         ])
 
-from .schema import prompt_schema
+from meshagent.api.schema_util import prompt_schema
 import logging
 logging.basicConfig()
 logger = logging.getLogger("planning_agent")

meshagent/agents/prompt.py

@@ -1,9 +1,10 @@
 
 from .adapter import LLMAdapter, Toolkit, ToolResponseAdapter
-from .schema import prompt_schema
+from meshagent.api.schema_util import prompt_schema
 from .agent import AgentCallContext
 from typing import Optional
 from meshagent.agents import TaskRunner
+from meshagent.api import RequiredToolkit
 
 # An agent that takes a simple prompt and gets the result
 class PromptAgent(TaskRunner):
@@ -16,7 +17,10 @@ class PromptAgent(TaskRunner):
         tools: list[Toolkit] = [],
         rules: list[str] = [],
         title: Optional[str] = None,
-        description: Optional[str] = None
+        description: Optional[str] = None,
+        requires: Optional[list[RequiredToolkit]] = None,
+        supports_tools: Optional[bool] = None,
+        labels: Optional[list[str]] = None
     ):
         super().__init__(
             name=name,
@@ -26,7 +30,9 @@ class PromptAgent(TaskRunner):
                 description=description
             ),
             output_schema=output_schema,
-
+            requires=requires,
+            supports_tools=supports_tools,
+            labels=labels
         )
         self.rules = rules
         self.tools = tools

meshagent/agents/pydantic.py

@@ -6,12 +6,13 @@ from .agent import AgentCallContext
 from .writer import Writer, WriterContext
 import logging
 from typing import Optional
+from meshagent.api import RoomClient
 
 from .agent import TaskRunner, RequiredToolkit, Requirement, RequiredSchema
 
 from .adapter import  ToolResponseAdapter
-
-from meshagent.tools.pydantic import get_pydantic_ai_tools_from_context
+from meshagent.tools.toolkit import Tool, Response, ToolContext
+from meshagent.tools.pydantic import get_pydantic_ai_tool_definition
 
 from typing import Sequence
 import pydantic_ai
@@ -19,6 +20,35 @@ import pydantic_ai
 logger = logging.getLogger("pydantic_agent")
 logger.setLevel(logging.INFO)
 
+
+def get_pydantic_ai_tool(*, room: RoomClient, tool: Tool, response_adapter: ToolResponseAdapter) -> pydantic_ai.tools.Tool:
+     async def prepare(ctx: pydantic_ai.RunContext, tool_def: pydantic_ai.tools.ToolDefinition):
+         return get_pydantic_ai_tool_definition(tool=tool)
+     
+     async def execute(**kwargs):
+         response = await tool.execute(context=ToolContext(room=room, caller=room.local_participant), **kwargs)
+         return await response_adapter.to_plain_text(room=room, response=response)
+
+     return pydantic_ai.Tool(
+        name=tool.name,
+        takes_ctx=False,
+        description=tool.description,
+        prepare=prepare,
+        function=execute
+    )
+
+def get_pydantic_ai_tools_from_context(*, context: AgentCallContext, response_adapter: ToolResponseAdapter) -> list[pydantic_ai.tools.Tool]:
+
+    tools = list[pydantic_ai.tools.Tool]()
+
+    for toolkit in context.toolkits:
+        
+        for tool in toolkit.tools:
+
+            tools.append(get_pydantic_ai_tool(room=context.room, tool=tool, response_adapter=response_adapter))
+
+    return tools
+
 class PydanticAgent[TInput:BaseModel, TOutput:BaseModel](TaskRunner):
     def __init__(self,
         *,

meshagent/agents/single_shot_writer.py

@@ -3,7 +3,7 @@ from meshagent.api.schema import ValueProperty, ChildProperty
 from meshagent.tools import Toolkit
 from meshagent.agents.writer import Writer, WriterContext
 from meshagent.agents.adapter import LLMAdapter, ToolResponseAdapter
-from .schema import prompt_schema, merge
+from meshagent.api.schema_util import prompt_schema, merge
 from typing import Optional
 from meshagent.api import Requirement
 

meshagent/agents/thread_schema.py

@@ -0,0 +1,59 @@
+from meshagent.api.schema import MeshSchema, ElementType,  ChildProperty, ValueProperty
+
+thread_schema = MeshSchema(
+    root_tag_name="thread",
+    elements=[
+        ElementType(
+            tag_name="thread", 
+            description="a thread of messages",
+            properties=[
+                ChildProperty(name="properties", description="the messages in the thread", ordered=True, child_tag_names=[
+                    "members", "messages"
+                ]),
+            ]
+        ),
+        ElementType(
+            tag_name="members", 
+            description="the members of this thread",
+            properties=[
+                ChildProperty(name="items", child_tag_names=["member"], description="the messages in this thread")
+            ]
+        ),
+        ElementType(
+            tag_name="messages", 
+            description="the messages of this thread",
+            properties=[
+                ChildProperty(name="items", child_tag_names=["message"], description="the messages in this thread")
+            ]
+        ),
+        ElementType(
+            tag_name="member", 
+            description="a member of this thread",
+            properties=[
+                ValueProperty(name="name", description="the name of the member", type="string"),
+                ValueProperty(name="type", description="the type of member", type="string", enum=[
+                    "user", "agent"
+                ]),
+            ]
+        ),
+        ElementType(
+            tag_name="file", 
+            description="a file attachment",
+            properties=[
+                ValueProperty(name="path", description="the path of the file in the room", type="string"),
+            ]
+        ),
+        ElementType(
+            tag_name="message", 
+            description="a message sent in the conversation",
+            properties=[
+                ValueProperty(name="id", description="the id of the message", type="string"),
+                ValueProperty(name="text", description="the text of the message", type="string"),
+                ValueProperty(name="created_at", description="the date that the message was sent in ISO format", type="string"),
+                ValueProperty(name="author_name", description="the name of the author of the post", type="string"),
+                ValueProperty(name="author_ref", description="a reference to author identity in another system", type="string"),
+                ChildProperty(name="attachments", child_tag_names=["file"], description="a list of message attachments")
+            ]
+        ),          
+    ]
+)

meshagent/agents/version.py

@@ -1 +1 @@
-__version__ = "0.0.3"
+__version__ = "0.0.4"

{meshagent_agents-0.0.3.dist-info → meshagent_agents-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: meshagent-agents
-Version: 0.0.3
+Version: 0.0.4
 Summary: Agent Building Blocks for Meshagent
 Home-page: 
 License: Apache License 2.0
@@ -13,9 +13,9 @@ License-File: LICENSE
 Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: pytest>=8.3.4
 Requires-Dist: pytest-asyncio>=0.24.0
-Requires-Dist: meshagent-api>=0.0.3
-Requires-Dist: meshagent-tools>=0.0.3
-Requires-Dist: meshagent-openai>=0.0.3
+Requires-Dist: meshagent-api>=0.0.4
+Requires-Dist: meshagent-tools>=0.0.4
+Requires-Dist: meshagent-openai>=0.0.4
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pydantic-ai>=0.0.23
 Requires-Dist: chonkie>=0.5.1

meshagent_agents-0.0.4.dist-info/RECORD

@@ -0,0 +1,22 @@
+meshagent/agents/__init__.py,sha256=uLDRp7W4wG0M2JHmyWBA4oYwYUsqGPD3VVHmcAddGAs,343
+meshagent/agents/adapter.py,sha256=i2ck7a6B8ByXRZgtOH7chc7VT2cpk3uBAdEd93Ts7jI,1278
+meshagent/agents/agent.py,sha256=t9AwoKjF_bgPrJdN9dr73J-CkQy_oAQWyHKB1Q4RPOU,15734
+meshagent/agents/chat.py,sha256=1NsmQECm2WqHhKcegDz40p9FX4dY9W3hjjgztScVc1s,17409
+meshagent/agents/context.py,sha256=1j38JGb0Nc0CZ0UMC_VkKjMraHZdsqBStTGNrP2nanM,3191
+meshagent/agents/development.py,sha256=04VYL1Q_BWUTQeVuiVOpyjcs8bzUIX1eQ4VyTtjc5s0,926
+meshagent/agents/hosting.py,sha256=e2wMGbWFt0WO3CJaTQehwbucftgUNVTgRsrBWiYDgcU,4973
+meshagent/agents/indexer.py,sha256=t7FbUxTSHSS-2pLrYSiCuv7P28y00XA8iJtEsuQjTZA,19399
+meshagent/agents/listener.py,sha256=kKFaWPmvmk1aCAlI55AAU3-QnOWCSZbf621xZz10rbs,5388
+meshagent/agents/planning.py,sha256=DTanAzanhjZ4bU6kWDFTBkw3oVcdtSj3XTKYwntoN0A,23136
+meshagent/agents/prompt.py,sha256=sidiyLLC6Lr9KO3cUTKttd2oROlcizle_4iKoaNrfhA,1864
+meshagent/agents/pydantic.py,sha256=BXALTyj8O9vV-eY5ejiJoYIY4zVl9AKetsqGUxixbiY,6091
+meshagent/agents/single_shot_writer.py,sha256=CJ7KgekR6JUSbYZ8OdYmhBPPjEWDYNtbIjR4g1wkWAA,3405
+meshagent/agents/thread_schema.py,sha256=mmm1p7A6Eux98xsNXwGSNq_DjkMn3hsyaWsplc6akCM,2575
+meshagent/agents/version.py,sha256=2GWffEF1rjyrveUGdfR8y3cl3JUnX0gJjr8Ryy_u4JQ,21
+meshagent/agents/worker.py,sha256=vZ6tnOyjno8N551c5HsXR8Mw3ZPmYRa4o1MZ3i7hEG4,4374
+meshagent/agents/writer.py,sha256=Ff8RVxdpFNKmo6zxaGkuFMz8MIKumdM0FIXX_6lbZ6Q,2738
+meshagent_agents-0.0.4.dist-info/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_agents-0.0.4.dist-info/METADATA,sha256=64GXsnluH0GU9-tYdqzYFBWZuXlU-XzqyLarqvB_cnQ,896
+meshagent_agents-0.0.4.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+meshagent_agents-0.0.4.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_agents-0.0.4.dist-info/RECORD,,

meshagent/agents/schema.py

@@ -1,50 +0,0 @@
-from copy import deepcopy
-
-def validation_schema(description: str):
-    return {
-        "type" : "object",
-        "description" : description,
-        "required" : [ "is_valid", "message" ],
-        "additionalProperties" : False,
-        "properties" : {
-            "is_valid" : {
-                "type" : "boolean",
-            },
-            "message" : {
-                "type" : "string",
-            },
-        }
-    }
-
-def prompt_schema(description: str):
-    return {
-        "type" : "object",
-        "description" : description,
-        "required" : [ "prompt" ],
-        "additionalProperties" : False,
-        "properties" : {
-            "prompt" : {
-                "description"  : "a prompt that will be used by the agent to create a response",
-                "type" : "string",
-            }
-        }
-    }
-
-def no_arguments_schema(description: str):
-    return {
-        "description" : description,
-        "type" : "object",
-        "required" : [],
-        "additionalProperties" : False,
-        "properties" : {
-        }
-    }
-
-def merge(*, schema: dict, additional_properties: dict) -> dict:
-    schema = deepcopy(schema)
-
-    for k,v in additional_properties.items():
-        schema["required"].append(k)
-        schema["properties"][k] = v
-
-    return schema

meshagent_agents-0.0.3.dist-info/RECORD

@@ -1,22 +0,0 @@
-meshagent/agents/__init__.py,sha256=morriYsu4jkd6oboNO-s531uRTns_br6f4CV_AC7omg,303
-meshagent/agents/adapter.py,sha256=fBNmLtHHgZbgWIqGDUPu5PrUV8qM-_E4kWWvHFWmZqg,1066
-meshagent/agents/agent.py,sha256=VrjUH_scLe4CuZwsrnGMKVvi4NeUcAahd4K9CGEpwwk,15537
-meshagent/agents/chat.py,sha256=EsPOhw4CV4REJTmV1CPFG-Oxj7O-0vU1eTyPxcYPUq8,12257
-meshagent/agents/context.py,sha256=yph6EW5byiKh8znumr6WgN5Us1x6SDPBS3PQo40_krg,2744
-meshagent/agents/development.py,sha256=04VYL1Q_BWUTQeVuiVOpyjcs8bzUIX1eQ4VyTtjc5s0,926
-meshagent/agents/hosting.py,sha256=e2wMGbWFt0WO3CJaTQehwbucftgUNVTgRsrBWiYDgcU,4973
-meshagent/agents/indexer.py,sha256=7JYCnP-A_nqV5l7zhDgyoXhplNldL0_x4ERGhZ0Cx1k,19443
-meshagent/agents/listener.py,sha256=kKFaWPmvmk1aCAlI55AAU3-QnOWCSZbf621xZz10rbs,5388
-meshagent/agents/planning.py,sha256=CAnfX_ushG4OAvMCUnMs4XNYBoyc7PV_lgvTIMjhjrw,23116
-meshagent/agents/prompt.py,sha256=PfdH_7_Re1jEPfDmkwtG74-SwyVA7uRXFk_4_s0us6k,1556
-meshagent/agents/pydantic.py,sha256=MUAcc5HWEvnOPPR2DkFVvGykG00_W8BuPwFPrbzher8,4904
-meshagent/agents/schema.py,sha256=Efzd-srpHazNq-jZ7bMNZX_TZJOBbfYfDHXbpLu_hhY,1292
-meshagent/agents/single_shot_writer.py,sha256=-wMqQTYVYrh_P5Gc9PROOiTeJefdgNGWAYeRFZ2sQVk,3387
-meshagent/agents/version.py,sha256=k5tJXhBQJ4l9fKHJ76K5w98zBHoYvNk9r-UNH6eQ2-k,21
-meshagent/agents/worker.py,sha256=vZ6tnOyjno8N551c5HsXR8Mw3ZPmYRa4o1MZ3i7hEG4,4374
-meshagent/agents/writer.py,sha256=Ff8RVxdpFNKmo6zxaGkuFMz8MIKumdM0FIXX_6lbZ6Q,2738
-meshagent_agents-0.0.3.dist-info/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_agents-0.0.3.dist-info/METADATA,sha256=MiPmYESj4KOhJD5p-vUfKQuFG1iq_wCgcMtyzfl5A_s,896
-meshagent_agents-0.0.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-meshagent_agents-0.0.3.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_agents-0.0.3.dist-info/RECORD,,