meshagent-agents 0.0.3__tar.gz → 0.0.5__tar.gz

{meshagent_agents-0.0.3/meshagent_agents.egg-info → meshagent_agents-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: meshagent-agents
-Version: 0.0.3
+Version: 0.0.5
 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.5
+Requires-Dist: meshagent-tools>=0.0.5
+Requires-Dist: meshagent-openai>=0.0.5
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pydantic-ai>=0.0.23
 Requires-Dist: chonkie>=0.5.1

{meshagent_agents-0.0.3 → meshagent_agents-0.0.5}/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-0.0.3 → meshagent_agents-0.0.5}/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-0.0.3 → meshagent_agents-0.0.5}/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-0.0.5/meshagent/agents/chat.py

@@ -0,0 +1,448 @@
+from .agent import SingleRoomAgent, AgentChatContext, AgentCallContext
+from meshagent.api.chan import Chan
+from meshagent.api import RoomMessage, RoomException, RoomClient, RemoteParticipant, RequiredSchema, Requirement, Element, MeshDocument
+from meshagent.tools import Toolkit
+from .adapter import LLMAdapter, ToolResponseAdapter
+import asyncio
+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")
+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 : 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,
+            description=description,
+            requires=requires,
+            labels=labels
+        )
+
+        if toolkits == None:
+            toolkits = []
+
+        self._llm_adapter = llm_adapter
+        self._tool_adapter = tool_adapter
+
+        self._message_channels = dict[str, Chan[RoomMessage]]()
+
+        self._room : RoomClient | None = None
+        self._toolkits = toolkits
+
+        if rules == None:
+            rules = []
+
+        self._rules = rules
+        self._is_typing = dict[str,asyncio.Task]()
+        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]()
+
+    def init_requirements(self, requires: list[Requirement]):
+        if requires == None:
+
+            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._send_and_save_chat(id=str(uuid.uuid4()), to=RemoteParticipant(id=participant.id), messages=messages, path=path, text= self._auto_greet_message)
+           
+
+    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 thread_context.toolkits:
+
+            if toolkit.name == "meshagent.ui":
+
+                for tool in toolkit.tools:
+
+                    if tool.name == "show_toast":
+
+                        toaster = tool
+
+        if toaster != None:
+
+            def multi_tool(toolkit: Toolkit):
+                if toaster in toolkit.tools:
+                    return toolkit
+                
+                return MultiToolkit(required=[ toaster ], base_toolkit=toolkit )
+
+            toolkits = list(map(multi_tool, thread_context.toolkits))
+        
+            thread_context.toolkits = toolkits
+
+    
+    async def init_chat_context(self) -> AgentChatContext:
+        context =  self._llm_adapter.create_chat_context()
+        context.append_rules(self._rules)
+        return context
+
+    async def open_thread(self, *, path: str):
+
+
+        return await self.room.sync.open(path=path)
+    
+    async def close_thread(self, *, path: str):
+
+        return await self.room.sync.close(path=path)
+
+
+    async def _spawn_thread(self, path: str, messages: Chan[RoomMessage]):
+
+        self.room.developer.log_nowait(type="chatbot.thread.started", data={ "path" : path })
+        chat_context = await self.init_chat_context()
+        opened = False
+        thread = None
+        doc_messages = None
+        current_file = None
+        llm_messages = Chan[ResponseStreamEvent]()
+        
+        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():
+
+            partial = ""
+            content_element = None
+            context_message = None
+
+            async for evt in llm_messages:
+                
+                #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
+                    
+                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}")
+
+                    elif current_file != None:
+                        chat_context.append_assistant_message(message=f"the user is not current viewing any files")
+
+                
+                    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")
+
+
+                    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)
+
+                    if received.type == "chat":
+                        
+                        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"] } } })
+                    
+                        
+                            attachments = received.message.get("attachments", [])
+
+                            for attachment in attachments:
+
+                                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)
+                    ]
+
+                    thread_context = ChatThreadContext(
+                        chat=chat_context,
+                        thread=thread,
+                        toolkits=toolkits,
+                    )
+
+                    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
+                        )
+                    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:
+
+            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]:
+        if participant_id not in self._message_channels:
+            chan = Chan[RoomMessage]()
+            self._message_channels[participant_id] = chan
+
+        chan = self._message_channels[participant_id]
+        
+        return chan
+    
+    async def stop(self):
+        await super().stop()
+
+        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)
+
+                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()
+                    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()
+
+                timeout = asyncio.create_task(remove_timeout(id=message.from_participant_id))
+                timeout.add_done_callback(callback)
+
+                self._is_typing[message.from_participant_id] = timeout
+
+        room.messaging.on("message", on_message)
+        
+        if self._auto_greet_message != None:
+            def on_participant_added(participant:RemoteParticipant):
+                
+                # will spawn the initial thread
+                self._get_message_channel(participant_id=participant.id)
+               
+
+            room.messaging.on("participant_added", on_participant_added)
+
+        await room.messaging.enable()
+

{meshagent_agents-0.0.3 → meshagent_agents-0.0.5}/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-0.0.3 → meshagent_agents-0.0.5}/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-0.0.3 → meshagent_agents-0.0.5}/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-0.0.3 → meshagent_agents-0.0.5}/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-0.0.3 → meshagent_agents-0.0.5}/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-0.0.3 → meshagent_agents-0.0.5}/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-0.0.5/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-0.0.5/meshagent/agents/version.py

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

{meshagent_agents-0.0.3 → meshagent_agents-0.0.5/meshagent_agents.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: meshagent-agents
-Version: 0.0.3
+Version: 0.0.5
 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.5
+Requires-Dist: meshagent-tools>=0.0.5
+Requires-Dist: meshagent-openai>=0.0.5
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pydantic-ai>=0.0.23
 Requires-Dist: chonkie>=0.5.1

{meshagent_agents-0.0.3 → meshagent_agents-0.0.5}/meshagent_agents.egg-info/SOURCES.txt

@@ -15,8 +15,8 @@ meshagent/agents/listener.py
 meshagent/agents/planning.py
 meshagent/agents/prompt.py
 meshagent/agents/pydantic.py
-meshagent/agents/schema.py
 meshagent/agents/single_shot_writer.py
+meshagent/agents/thread_schema.py
 meshagent/agents/version.py
 meshagent/agents/worker.py
 meshagent/agents/writer.py

{meshagent_agents-0.0.3 → meshagent_agents-0.0.5}/meshagent_agents.egg-info/requires.txt

@@ -1,9 +1,9 @@
 pyjwt>=2.0.0
 pytest>=8.3.4
 pytest-asyncio>=0.24.0
-meshagent-api>=0.0.3
-meshagent-tools>=0.0.3
-meshagent-openai>=0.0.3
+meshagent-api>=0.0.5
+meshagent-tools>=0.0.5
+meshagent-openai>=0.0.5
 pydantic>=2.10.4
 pydantic-ai>=0.0.23
 chonkie>=0.5.1

{meshagent_agents-0.0.3 → meshagent_agents-0.0.5}/setup.py

@@ -28,9 +28,9 @@ setuptools.setup(
         "pyjwt>=2.0.0",
         "pytest>=8.3.4",
         "pytest-asyncio>=0.24.0",        
-        "meshagent-api>=0.0.3",
-        "meshagent-tools>=0.0.3",
-        "meshagent-openai>=0.0.3",
+        "meshagent-api>=0.0.5",
+        "meshagent-tools>=0.0.5",
+        "meshagent-openai>=0.0.5",
         "pydantic>=2.10.4",
         "pydantic-ai>=0.0.23",
         "chonkie>=0.5.1",

meshagent_agents-0.0.3/meshagent/agents/chat.py

@@ -1,328 +0,0 @@
-from .agent import SingleRoomAgent, AgentChatContext
-from meshagent.api.chan import Chan
-from meshagent.api import RoomMessage, RoomException, RoomClient, RemoteParticipant
-from meshagent.tools import Toolkit
-from .adapter import LLMAdapter, ToolResponseAdapter
-import asyncio
-from typing import Optional
-import logging
-from meshagent.tools import MultiToolkit
-import urllib
-
-logging.basicConfig()
-logger = logging.getLogger("chat")
-logger.setLevel(logging.INFO)
-
-
-# todo: thread should stop when participant stops?
-
-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):
-        super().__init__(
-            name=name,
-            title=title,
-            description=description,
-            requires=requires,
-            labels=labels
-        )
-
-        if toolkits == None:
-            toolkits = []
-
-        self._llm_adapter = llm_adapter
-        self._tool_adapter = tool_adapter
-
-        self._message_channels = dict[str, Chan[RoomMessage]]()
-
-        self._room : RoomClient | None = None
-        self._toolkits = toolkits
-
-        if rules == None:
-            rules = []
-
-        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
-
-
-    async def greet(self, *, chat_context: AgentChatContext, messages: Chan[RoomMessage], participant: RemoteParticipant):
-
-        if self._auto_greet_prompt != None:
-            messages.send_nowait(RoomMessage(from_participant_id=participant.id, type="chat",  message={"text": self._auto_greet_prompt }))
-        
-        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  })
-
-
-    async def finalize_toolkits(self, toolkits) -> list[Toolkit]:
-
-        toaster = None
-        
-        for toolkit in toolkits:
-
-            if toolkit.name == "meshagent.ui":
-
-                for tool in toolkit.tools:
-
-                    if tool.name == "show_toast":
-
-                        toaster = tool
-
-        if toaster != None:
-
-            def multi_tool(toolkit: Toolkit):
-                if toaster in toolkit.tools:
-                    return toolkit
-                
-                return MultiToolkit(required=[ toaster ], base_toolkit=toolkit )
-
-            toolkits = list(map(multi_tool, toolkits))
-        
-        return toolkits
-
-    async def _spawn_thread(self, participant_id: str, messages: Chan[RoomMessage]):
-
-        
-        chat_context = await self.init_chat_context()
-        
-
-        chat_context.append_rules(
-            rules=[
-                *self._rules,
-                "think step by step",
-           ]
-        )
-
-        opened = False
-        chat_with_participant = None
-
-        for participant in self._room.messaging.get_participants():
-            if participant.id == participant_id:
-                chat_with_participant = participant
-                break
-
-        if chat_with_participant == None:
-            raise RoomException(f"caller did not have messaging turned on")
-        
-        messaging = self._room.messaging
-
-        current_file = None
-        
-        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:
-
-             
-
-                received = await messages.recv()
-
-                
-
-                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}")
-
-                elif current_file != None:
-                    chat_context.append_assistant_message(message=f"the user is not current viewing any files")
-
-
-
-                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
-                            }
-                        )
-
-                if received.type == "opened":
-                    
-                    
-                    if opened == False:
-                        
-                        opened = True
-                        
-                        await self.greet(chat_context=chat_context, participant=chat_with_participant, messages=messages)
-
-                if received.type == "chat":
-
-
-                    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", [])
-
-                        for attachment in attachments:
-
-                            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:
-                while True:
-
-                    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,
-                        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
-                            }
-                        )
-                        chat_context.append_user_message(message="proceed to the next step if you are ready")
-                
-            finally:
-
-                await self._room.messaging.send_message(to=chat_with_participant, type="thinking", message={"thinking":False})
-
-   
-
-    def _get_message_channel(self, participant_id: str) -> Chan[RoomMessage]:
-        if participant_id not in self._message_channels:
-            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):
-
-        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":
-
-                
-                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()
-
-                timeout = asyncio.create_task(remove_timeout(id=message.from_participant_id))
-                timeout.add_done_callback(callback)
-
-                self._is_typing[message.from_participant_id] = timeout
-
-        room.messaging.on("message", on_message)
-        
-        if self._auto_greet_prompt != None or self._auto_greet_message != None:
-            def on_participant_added(participant:RemoteParticipant):
-                
-                # will spawn the initial thread
-                self._get_message_channel(participant_id=participant.id)
-               
-
-            room.messaging.on("participant_added", on_participant_added)
-
-        await room.messaging.enable()
-

meshagent_agents-0.0.3/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/meshagent/agents/version.py

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