meshagent-agents 0.0.22__tar.gz → 0.0.24__tar.gz

{meshagent_agents-0.0.22 → meshagent_agents-0.0.24}/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.0.24]
+- Stability
+
+## [0.0.23]
+- Stability
+
 ## [0.0.22]
 - Stability
 

{meshagent_agents-0.0.22/meshagent_agents.egg-info → meshagent_agents-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-agents
-Version: 0.0.22
+Version: 0.0.24
 Summary: Agent Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,18 +12,21 @@ License-File: LICENSE
 Requires-Dist: pyjwt~=2.10.1
 Requires-Dist: pytest~=8.3.5
 Requires-Dist: pytest-asyncio~=0.26.0
-Requires-Dist: meshagent-api~=0.0.22
-Requires-Dist: meshagent-tools~=0.0.22
-Requires-Dist: meshagent-openai~=0.0.22
+Requires-Dist: meshagent-api~=0.0.24
+Requires-Dist: meshagent-tools~=0.0.24
+Requires-Dist: meshagent-openai~=0.0.24
 Requires-Dist: pydantic~=2.11.1
 Requires-Dist: pydantic-ai~=0.0.48
 Provides-Extra: all
-Requires-Dist: meshagent-api[all]~=0.0.22; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.0.24; extra == "all"
 Requires-Dist: chonkie~=0.5.1; extra == "all"
 Requires-Dist: chonkie[semantic]~=0.5.1; extra == "all"
 Requires-Dist: chonkie[openai]~=0.5.1; extra == "all"
+Requires-Dist: aiosmtplib~=4.0.1; extra == "all"
 Provides-Extra: sync
-Requires-Dist: meshagent-api[sync]~=0.0.22; extra == "sync"
+Requires-Dist: meshagent-api[sync]~=0.0.24; extra == "sync"
+Provides-Extra: mail
+Requires-Dist: aiosmtplib~=4.0.1; extra == "mail"
 Provides-Extra: rag
 Requires-Dist: chonkie~=0.5.1; extra == "rag"
 Requires-Dist: chonkie[semantic]~=0.5.1; extra == "rag"

{meshagent_agents-0.0.22 → meshagent_agents-0.0.24}/meshagent/agents/listener.py

@@ -37,7 +37,7 @@ class Listener(TaskRunner):
                 "properties" : {
                     "path" : {
                         "type" : "string",
-                        "description" : "the path of the document to proofread"
+                        "description" : "the path of the document to listen to"
                     }
                 }
             },

meshagent_agents-0.0.24/meshagent/agents/mail.py

@@ -0,0 +1,337 @@
+from meshagent.agents.worker import Worker
+from meshagent.tools import Tool, Toolkit
+from meshagent.api.room_server_client import TextDataType
+from email import message_from_bytes
+from email.message import EmailMessage
+from email.policy import default
+import email.utils
+from meshagent.api import ParticipantToken
+
+from meshagent.api import RoomClient
+
+from datetime import datetime, timezone
+
+import secrets
+
+from typing import Literal, Optional
+import json
+
+import uuid
+import logging
+
+import os
+import aiosmtplib
+
+logger = logging.getLogger("mail")
+
+type MessageRole = Literal["user", "agent"]
+
+
+
+def create_reply_email_message(*, message: dict, from_address: str, body: str) -> EmailMessage:
+
+    subject : str = message.get("subject")
+
+    if not subject.startswith("RE:"):
+        subject = "RE: " + subject
+
+    _, addr = email.utils.parseaddr(from_address) 
+    domain = addr.split("@")[-1].lower()
+    id = f"<{uuid.uuid4()}@{domain}>"
+
+    msg = EmailMessage()
+    msg["Message-ID"] = id
+    msg["Subject"] = subject
+    msg["From"] = from_address
+    msg["To"] = message.get("reply_to")
+    msg["In-Reply-To"] = message.get("id")
+    msg.set_content(body)
+
+    return msg
+
+def message_to_json(*, message: EmailMessage, role: MessageRole):
+
+    body_part = message.get_body(('plain', 'html'))  # returns the “best” part :contentReference[oaicite:0]{index=0}
+    if body_part:
+        body = body_part.get_content()
+    else:                                            # simple, non-MIME message
+        body = message.get_content()
+
+    id = message.get("Message-ID")
+    if id == None:
+        mfrom = message.get("From")
+        _, addr = email.utils.parseaddr(mfrom) 
+        domain = addr.split("@")[-1].lower()
+        id = f"{uuid.uuid4()}@{domain}"
+
+    return {
+        "id" : id,
+        "in_reply_to" : message.get("In-Reply-To"),
+        "reply_to" : message.get("Reply-To", message.get("From")),
+        "references" : message.get("References"),
+        "from" : message.get("From"),
+        "to" : message.get_all("To"),
+        "subject" : message.get("Subject"),
+        "body" : body,
+        "attachments" : [],
+        "role" : role
+    }
+
+async def load_message(*, room: RoomClient, message_id: str) -> dict | None:
+
+    messages = await room.database.search(
+        table="emails",
+        where={
+            "id" : message_id
+        })
+    
+    if len(messages) == 0:
+        return None
+    
+    return json.loads(messages[0]["json"])
+
+async def save_email_message(*, room: RoomClient, content: bytes, role: MessageRole) -> dict:
+
+    message = message_from_bytes(content, policy=default)
+
+    now = datetime.now(timezone.utc)
+    
+    folder_path = now.strftime('%Y/%m/%d') +"/" + now.strftime('%H/%M/%S') + '/' + secrets.token_hex(3)
+
+    queued_message = message_to_json(message=message, role=role)
+    message_id = queued_message["id"]
+    
+
+    queued_message["role"] = role
+    
+    queued_message["path"] = f".emails/{message_id}/message.json"
+    
+    for part in message.iter_attachments():                # ↔ only the “real” attachments :contentReference[oaicite:0]{index=0}
+        fname = part.get_filename() or "attachment.bin"    # RFC 2183 filename, if any :contentReference[oaicite:1]{index=1}
+        ctype = part.get_content_type()                    # e.g. image/png, application/pdf
+        # get_content() auto-decodes transfer-encodings; returns
+        # *str* for text/*, *bytes* for everything else :contentReference[oaicite:2]{index=2}
+        data  = part.get_content()
+
+        # make sure we write binary data
+        bin_data = data.encode(part.get_content_charset('utf-8')) if isinstance(data, str) else data
+        
+        path = f".emails/{folder_path}/attachments/{fname}"
+        handle = await room.storage.open(path=path)
+        try:
+            logger.info(f"writing content to {path}")
+            await room.storage.write(handle=handle, data=bin_data)
+        finally:
+            await room.storage.close(handle=handle)
+
+        queued_message["attachments"].append(path)
+    
+    logger.info(f"received mail, {queued_message}")
+
+    # write email
+    path = f".emails/{folder_path}/message.eml"
+    handle = await room.storage.open(path=path)
+    try:
+        logger.info(f"writing source message.eml to {path}")
+        await room.storage.write(handle=handle, data=content)
+    finally:
+        await room.storage.close(handle=handle)
+
+    path = f".emails/{folder_path}/message.json"
+    handle = await room.storage.open(path=path)
+    try:
+        logger.info(f"writing source message.json to {path}")
+        await room.storage.write(handle=handle, data=json.dumps(queued_message, indent=4).encode("utf-8"))
+    finally:
+        await room.storage.close(handle=handle)
+
+    # create email table if it doesn't exist
+    tables = await room.database.list_tables()
+
+    if "emails" not in tables:
+
+        await room.database.create_table_with_schema(
+            name="emails",
+            schema={
+                "id" : TextDataType(),
+                "json" : TextDataType()
+            },
+            mode="create_if_not_exists"
+        )
+
+        await room.database.create_scalar_index(table="emails", column="id")
+
+    
+    await room.database.insert(table="emails", records=[ { "id" : message_id, "json" : json.dumps(queued_message) } ])
+
+    return queued_message
+
+
+async def load_thread(*, room: RoomClient, message: dict, thread: list[dict]):
+
+    in_reply_to = message.get("in_reply_to", None)
+    if in_reply_to != None:
+
+        source = await load_message(room=room, message_id=in_reply_to)
+
+        if source != None:
+
+            thread.insert(0, source)
+
+            await load_thread(room=room, message=source, thread=thread)
+
+        else:
+
+            logger.warning(f"message not found {in_reply_to}")
+
+
+class SmtpConfiguration:
+    def __init__(self, username: Optional[str] = None, password: Optional[str] = None, port: Optional[int] = None, hostname: Optional[str] = None):
+        if username == None:
+            username = os.getenv("SMTP_USERNAME")
+
+        if password == None:
+            password = os.getenv("SMTP_PASSWORD")
+
+        if port == None:
+            port = int(os.getenv("SMTP_PORT", "587"))
+
+        if hostname == None:
+            hostname = os.getenv("SMTP_HOSTNAME")
+            
+        self.username = username
+        self.password = password
+        self.port = port
+        self.hostname = hostname
+
+class MailWorker(Worker):
+
+    def __init__(self, *, 
+        queue: str = "email", 
+        name,
+        title=None,
+        description=None,
+        requires=None,
+        llm_adapter,
+        tool_adapter = None,
+        toolkits = None,
+        rules = None,
+        domain: str = os.getenv("MESHAGENT_MAIL_DOMAIN", "mail.meshagent.com"),
+        smtp: Optional[SmtpConfiguration] = None):
+
+        if smtp == None:
+            smtp = SmtpConfiguration()
+
+        self._domain = domain
+        self._smtp = smtp
+        super().__init__(queue=queue, name=name, title=title, description=description, requires=requires, llm_adapter=llm_adapter, tool_adapter=tool_adapter, toolkits=toolkits, rules=rules)
+
+    async def start(self, *, room):
+        
+        await super().start(room=room)
+
+        token = ParticipantToken.from_jwt(room.protocol.token, validate=False)
+        self._email_address = room_address(project_id=token.project_id, room_name=room.room_name, domain=self._domain)
+
+    async def append_message_context(self, *, room, message, chat_context):
+        
+        thread = [
+            message
+        ]
+
+        await load_thread(room=room, message=message, thread=thread)
+
+        for msg in thread:
+            
+            if msg["role"] == "agent":
+                
+                chat_context.append_assistant_message(json.dumps(msg))
+
+            else:
+
+                chat_context.append_user_message(json.dumps(msg))
+    
+
+        # TODO: load previous messages
+        return await super().append_message_context(room=room, message=message, chat_context=chat_context)
+    
+    async def process_message(self, *, chat_context, room, message, toolkits):
+        
+        logger.info(f"processing message {message}")
+        body = await super().process_message(chat_context=chat_context, room=room, message=message, toolkits=toolkits)
+
+        msg = create_reply_email_message(message=message, from_address=self._email_address, body=body)
+
+        
+        reply_msg_dict = await save_email_message(room=room, content=msg.as_bytes(), role="agent")
+
+        logger.info(f"replying with message {reply_msg_dict}")
+        
+       
+        username = self._smtp.username
+        if username == None:
+            username = self.room.local_participant.get_attribute("name")
+        
+        password = self._smtp.password
+        if password == None:
+            password = self.room.protocol.token
+            
+        await aiosmtplib.send(msg, hostname=self._smtp.hostname, port=self._smtp.port, username=username, password=password)
+
+
+
+def base36encode(number: int):
+    if not isinstance(number, int):
+        raise TypeError('number must be an integer')
+    if number < 0:
+        raise ValueError('number must be non-negative')
+
+    alphabet = '0123456789abcdefghijklmnopqrstuvwxyz'
+    if number == 0:
+        return '0'
+    base36 = ''
+    while number:
+        number, i = divmod(number, 36)
+        base36 = alphabet[i] + base36
+    return base36
+
+def compress_uuid(guid_string: str):
+    guid_int = int(guid_string.replace('-', ''), 16)
+    return base36encode(guid_int)
+
+def base36decode(number_str: str) -> int:
+    """Decode a base36-encoded string into an integer."""
+    alphabet = '0123456789abcdefghijklmnopqrstuvwxyz'
+    base = 36
+    number = 0
+    for char in number_str:
+        try:
+            value = alphabet.index(char)
+        except ValueError:
+            raise ValueError(f"Invalid character '{char}' for base36 encoding")
+        number = number * base + value
+    return number
+
+def decompress_uuid(compressed_uuid: str) -> str:
+    """
+    Reverse the compressed UUID to its standard 36-character UUID format.
+
+    Args:
+        compressed_uuid: A base36 string that represents a UUID compressed from its standard form.
+
+    Returns:
+        A string in the UUID format (8-4-4-4-12 hexadecimal characters).
+    """
+    # Decode the base36 string back to the original integer.
+    guid_int = base36decode(compressed_uuid)
+    
+    # Convert the integer into a 32-digit hexadecimal string with leading zeros.
+    hex_str = f'{guid_int:032x}'
+    
+    # Reinsert dashes to match the standard UUID format: 8-4-4-4-12.
+    standard_uuid = f'{hex_str[0:8]}-{hex_str[8:12]}-{hex_str[12:16]}-{hex_str[16:20]}-{hex_str[20:32]}'
+    return standard_uuid
+
+
+def room_address(*, project_id: str, room_name: str, domain: str = os.getenv("MESHAGENT_MAIL_DOMAIN", "mail.meshagent.com")):
+    return f"{compress_uuid(project_id)}+{room_name}@{domain}"

meshagent_agents-0.0.24/meshagent/agents/version.py

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

meshagent_agents-0.0.24/meshagent/agents/worker.py

@@ -0,0 +1,105 @@
+from .agent import SingleRoomAgent
+from meshagent.api.chan import Chan
+from meshagent.api import RoomMessage, RoomException, RoomClient, RemoteParticipant
+from meshagent.agents import AgentChatContext
+from meshagent.tools import Toolkit
+from .adapter import LLMAdapter, ToolResponseAdapter
+import asyncio
+from typing import Optional
+import json
+from meshagent.tools import ToolContext
+import logging
+
+logger = logging.getLogger("chat")
+
+
+class Worker(SingleRoomAgent):
+    def __init__(self, *, queue: str,  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):
+        super().__init__(
+            name=name,
+            title=title,
+            description=description,
+            requires=requires,
+        )
+
+        self._queue = queue
+
+        if toolkits == None:
+            toolkits = []
+
+        self._llm_adapter = llm_adapter
+        self._tool_adapter = tool_adapter
+
+        self._message_channel = Chan[RoomMessage]()
+
+        self._room : RoomClient | None = None
+        self._toolkits = toolkits
+
+        if rules == None:
+            rules = []
+
+        self._rules = rules
+        self._done = False
+       
+
+    async def start(self, *, room: RoomClient):
+        self._done = False
+
+        await super().start(room=room)
+
+        
+        self._main_task = asyncio.create_task(self.run(room=room))
+
+    async def stop(self):
+
+        self._done = True
+
+        await asyncio.gather(self._main_task)
+
+        await super().stop()
+
+
+    async def append_message_context(self, *, room: RoomClient, message: dict, chat_context: AgentChatContext):
+        chat_context.append_user_message(message=json.dumps(message))
+        
+    async def process_message(self, *, chat_context: AgentChatContext, room: RoomClient, message: dict, toolkits: list[Toolkit]):
+
+        return await self._llm_adapter.next(
+            context=chat_context,
+            room=room,
+            toolkits=toolkits,
+            tool_adapter=self._tool_adapter,
+        )
+
+
+    async def run(self, *, room: RoomClient):
+
+        toolkits = [
+            *await self.get_required_toolkits(ToolContext(room=room, caller=room.local_participant)),
+            *self._toolkits
+        ]
+        
+        while not self._done:
+
+            message = await room.queues.receive(name=self._queue, create=True, wait=True)
+            if message != None:
+                
+                logger.info(f"received message on worker queue {message}")
+                try:
+
+                    chat_context = await self.init_chat_context()
+
+                    chat_context.append_rules(
+                        rules=[
+                            *self._rules,
+                        ]
+                    )
+                    
+                    await self.append_message_context(room=room, message=message, chat_context=chat_context)
+                        
+
+                    await self.process_message(chat_context=chat_context, room=room, message=message, toolkits=toolkits)
+       
+                except Exception as e:
+
+                    logger.error(f"Failed to process a message {message}", exc_info=e)

{meshagent_agents-0.0.22 → meshagent_agents-0.0.24/meshagent_agents.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-agents
-Version: 0.0.22
+Version: 0.0.24
 Summary: Agent Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,18 +12,21 @@ License-File: LICENSE
 Requires-Dist: pyjwt~=2.10.1
 Requires-Dist: pytest~=8.3.5
 Requires-Dist: pytest-asyncio~=0.26.0
-Requires-Dist: meshagent-api~=0.0.22
-Requires-Dist: meshagent-tools~=0.0.22
-Requires-Dist: meshagent-openai~=0.0.22
+Requires-Dist: meshagent-api~=0.0.24
+Requires-Dist: meshagent-tools~=0.0.24
+Requires-Dist: meshagent-openai~=0.0.24
 Requires-Dist: pydantic~=2.11.1
 Requires-Dist: pydantic-ai~=0.0.48
 Provides-Extra: all
-Requires-Dist: meshagent-api[all]~=0.0.22; extra == "all"
+Requires-Dist: meshagent-api[all]~=0.0.24; extra == "all"
 Requires-Dist: chonkie~=0.5.1; extra == "all"
 Requires-Dist: chonkie[semantic]~=0.5.1; extra == "all"
 Requires-Dist: chonkie[openai]~=0.5.1; extra == "all"
+Requires-Dist: aiosmtplib~=4.0.1; extra == "all"
 Provides-Extra: sync
-Requires-Dist: meshagent-api[sync]~=0.0.22; extra == "sync"
+Requires-Dist: meshagent-api[sync]~=0.0.24; extra == "sync"
+Provides-Extra: mail
+Requires-Dist: aiosmtplib~=4.0.1; extra == "mail"
 Provides-Extra: rag
 Requires-Dist: chonkie~=0.5.1; extra == "rag"
 Requires-Dist: chonkie[semantic]~=0.5.1; extra == "rag"

{meshagent_agents-0.0.22 → meshagent_agents-0.0.24}/meshagent_agents.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ meshagent/agents/development.py
 meshagent/agents/hosting.py
 meshagent/agents/indexer.py
 meshagent/agents/listener.py
+meshagent/agents/mail.py
 meshagent/agents/planning.py
 meshagent/agents/prompt.py
 meshagent/agents/pydantic.py

{meshagent_agents-0.0.22 → meshagent_agents-0.0.24}/meshagent_agents.egg-info/requires.txt

@@ -1,17 +1,21 @@
 pyjwt~=2.10.1
 pytest~=8.3.5
 pytest-asyncio~=0.26.0
-meshagent-api~=0.0.22
-meshagent-tools~=0.0.22
-meshagent-openai~=0.0.22
+meshagent-api~=0.0.24
+meshagent-tools~=0.0.24
+meshagent-openai~=0.0.24
 pydantic~=2.11.1
 pydantic-ai~=0.0.48
 
 [all]
-meshagent-api[all]~=0.0.22
+meshagent-api[all]~=0.0.24
 chonkie~=0.5.1
 chonkie[semantic]~=0.5.1
 chonkie[openai]~=0.5.1
+aiosmtplib~=4.0.1
+
+[mail]
+aiosmtplib~=4.0.1
 
 [rag]
 chonkie~=0.5.1
@@ -19,4 +23,4 @@ chonkie[semantic]~=0.5.1
 chonkie[openai]~=0.5.1
 
 [sync]
-meshagent-api[sync]~=0.0.22
+meshagent-api[sync]~=0.0.24

{meshagent_agents-0.0.22 → meshagent_agents-0.0.24}/pyproject.toml

@@ -17,23 +17,28 @@ dependencies = [
   "pyjwt~=2.10.1",
   "pytest~=8.3.5",
   "pytest-asyncio~=0.26.0",
-  "meshagent-api~=0.0.22",
-  "meshagent-tools~=0.0.22",
-  "meshagent-openai~=0.0.22",
+  "meshagent-api~=0.0.24",
+  "meshagent-tools~=0.0.24",
+  "meshagent-openai~=0.0.24",
   "pydantic~=2.11.1",
   "pydantic-ai~=0.0.48",
 ]
 
 [project.optional-dependencies]
 all = [
-    "meshagent-api[all]~=0.0.22",
+    "meshagent-api[all]~=0.0.24",
     "chonkie~=0.5.1",
     "chonkie[semantic]~=0.5.1",
-    "chonkie[openai]~=0.5.1"
+    "chonkie[openai]~=0.5.1",
+    "aiosmtplib~=4.0.1"
 ]
 
 sync = [
-    "meshagent-api[sync]~=0.0.22",
+    "meshagent-api[sync]~=0.0.24",
+]
+
+mail = [
+   "aiosmtplib~=4.0.1"
 ]
 
 rag = [

meshagent_agents-0.0.22/meshagent/agents/version.py

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

meshagent_agents-0.0.22/meshagent/agents/worker.py

@@ -1,114 +0,0 @@
-from .agent import TaskRunner, AgentCallContext
-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 json
-
-import logging
-
-logger = logging.getLogger("chat")
-
-
-
-# todo: thread should stop when participant stops?
-
-class Worker(TaskRunner):
-    def __init__(self, *, queue: str, prompt: str,  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, supports_tools: bool = True):
-        super().__init__(
-            name=name,
-            title=title,
-            description=description,
-            requires=requires,
-            output_schema=None,
-            supports_tools=supports_tools
-        )
-
-        self._queue = queue
-        self._prompt = prompt
-
-        if toolkits == None:
-            toolkits = []
-
-        self._llm_adapter = llm_adapter
-        self._tool_adapter = tool_adapter
-
-        self._message_channel = Chan[RoomMessage]()
-
-        self._room : RoomClient | None = None
-        self._toolkits = toolkits
-
-        if rules == None:
-            rules = []
-
-        self._rules = rules
-
-
-    async def ask(self, *, context: AgentCallContext, arguments: dict):
-        
-        queue = self._queue
-        prompt = self._prompt
-
-        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, also should be set to true if we get stuck in a loop, or if the user did not make a request",
-                    "type" : "boolean"
-                }
-            }
-        }
-        
-        # todo: add graceful exit 
-
-        while True:
-
-            message = await self.room.queues.receive(name=queue, create=True, wait=True)
-            if message != None:
-                
-                # for each message, create a new chat context
-
-                chat_context = await self.init_chat_context()
-
-            
-                chat_context.append_rules(
-                    rules=[
-                        *self._rules,
-                    ]
-                )
-                
-                chat_context.append_user_message(message=prompt)
-                chat_context.append_user_message(message=json.dumps(message))
-                
-                try:
-                    while True:
-
-                        tool_target = context.caller
-                        if context.on_behalf_of != None:
-                            tool_target = context.on_behalf_of
-
-                        response = await self._llm_adapter.next(
-                            context=chat_context,
-                            room=self._room,
-                            toolkits=context.toolkits,
-                            tool_adapter=self._tool_adapter,
-                            output_schema=step_schema,
-                        )
-
-                        if response["finished"] or len(context.toolkits) == 0:
-                            break
-                        else:
-                            chat_context.append_user_message(message="proceed to the next step if you are ready")
-                    
-                except Exception as e:
-
-                    logger.error(f"Failed to process a message {message}", exc_info=e)