meshagent-agents 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

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/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/version.py

@@ -1 +1 @@
-__version__ = "0.0.22"
+__version__ = "0.0.24"

meshagent/agents/worker.py

@@ -1,33 +1,28 @@
-from .agent import TaskRunner, AgentCallContext
+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")
 
 
-
-# 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):
+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,
-            output_schema=None,
-            supports_tools=supports_tools
         )
 
         self._queue = queue
-        self._prompt = prompt
 
         if toolkits == None:
             toolkits = []
@@ -44,71 +39,67 @@ class Worker(TaskRunner):
             rules = []
 
         self._rules = rules
+        self._done = False
+       
 
+    async def start(self, *, room: RoomClient):
+        self._done = False
+
+        await super().start(room=room)
 
-    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"
-                }
-            }
-        }
+        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))
         
-        # todo: add graceful exit 
+    async def process_message(self, *, chat_context: AgentChatContext, room: RoomClient, message: dict, toolkits: list[Toolkit]):
 
-        while True:
+        return await self._llm_adapter.next(
+            context=chat_context,
+            room=room,
+            toolkits=toolkits,
+            tool_adapter=self._tool_adapter,
+        )
 
-            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()
+    async def run(self, *, room: RoomClient):
 
-            
-                chat_context.append_rules(
-                    rules=[
-                        *self._rules,
-                    ]
-                )
-                
-                chat_context.append_user_message(message=prompt)
-                chat_context.append_user_message(message=json.dumps(message))
+        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:
-                    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")
+
+                    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.dist-info → meshagent_agents-0.0.24.dist-info}/METADATA

@@ -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.dist-info → meshagent_agents-0.0.24.dist-info}/RECORD

@@ -6,15 +6,16 @@ meshagent/agents/context.py,sha256=6eFK7wizjzZmZyhbqwazlT_E_e_Cpb17Qa3tBk2BJzw,3
 meshagent/agents/development.py,sha256=04VYL1Q_BWUTQeVuiVOpyjcs8bzUIX1eQ4VyTtjc5s0,926
 meshagent/agents/hosting.py,sha256=QFSppE-nbL31yuGvzSpES7FyNHpuHCTDDYSnroottn8,4936
 meshagent/agents/indexer.py,sha256=Lz7hJvC7hbvnmiFQLEzmakw_1OPh93pp96iSwIv1fQc,19410
-meshagent/agents/listener.py,sha256=T205pkkkJyOEDjKpSTrsA1XToGLWfwje_84SQu5V-vM,5359
+meshagent/agents/listener.py,sha256=39u20ZwTNUVR0CRUOi4CTgBreg2ZPbrHQOohwjsfijg,5359
+meshagent/agents/mail.py,sha256=8OyzV0PU8Zd-_1Ohwbm_4riIHYUAh29HJ5cK9eK7hgc,10950
 meshagent/agents/planning.py,sha256=NtXzYiwykeYdQghWjwsChy4f9OgIsQZWiIstpZvtGtU,21811
 meshagent/agents/prompt.py,sha256=sidiyLLC6Lr9KO3cUTKttd2oROlcizle_4iKoaNrfhA,1864
 meshagent/agents/pydantic.py,sha256=My9sv1A56unA0qVoPSH-mYtxcgl0AKyxFgyOM70pjLM,6062
 meshagent/agents/single_shot_writer.py,sha256=QsGvTIw1qtp8nGLfzuJwdZj6ucY4cW9rdecqNwv83FA,3355
 meshagent/agents/thread_schema.py,sha256=-KGAMNxQsVuXpvc0avV-OYHe2LMXpjTu5PyQ-1nBnyE,2667
 meshagent/agents/utils.py,sha256=upMbvG4KODZijeTO3IdW4GgzFPz4jXTzNhZBDmtroic,1431
-meshagent/agents/version.py,sha256=NoiGDztYD4fsDDnfSPiSzRkknkNHhFUtKZj0mhQiTYM,22
-meshagent/agents/worker.py,sha256=3y7D59ea7c09bwMFAjw1SUspAxe1Gzsta7lzsoyJgKA,3901
+meshagent/agents/version.py,sha256=sE45w-zCTIpVQyXYRbP5E390wIU6bNzRFuAh6ySoc1w,22
+meshagent/agents/worker.py,sha256=G2Q3UpUCQQ8GtPK5_LW4q8uDOyuJXJM_zdRPsx4puck,3260
 meshagent/agents/writer.py,sha256=2Nk52JcjdRz3EnGBO4EHnv49QzByWiije1LKMNuCAIo,2687
 meshagent/agents/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 meshagent/agents/schemas/document.py,sha256=GrHkyJ6ZsImqL33FnGKqjBmBpX4u2lAsUMLW4AzDHEM,1318
@@ -22,8 +23,8 @@ meshagent/agents/schemas/gallery.py,sha256=fzAdlDrn_dJz4FDPkSTH9ir7QmRpV8wFjj6RT
 meshagent/agents/schemas/presentation.py,sha256=DreBXAU7Lx92NBPTlEOZq1gdaRs0OkZrJgPT5N7fYH4,1265
 meshagent/agents/schemas/schema.py,sha256=O52T5nUGRNQ8AsamZ_W_IQ8WRDqSBo3vWFDSQcC7Lcg,4473
 meshagent/agents/schemas/super_editor_document.py,sha256=lFpbZn_s_6hchimddzpnGneJ7LaB6dTN_AnLZsx2r9c,1469
-meshagent_agents-0.0.22.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
-meshagent_agents-0.0.22.dist-info/METADATA,sha256=5XTwW4njBDDj7ZotG9hCM335klUWYsZ46CJXXI8h91M,1187
-meshagent_agents-0.0.22.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-meshagent_agents-0.0.22.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_agents-0.0.22.dist-info/RECORD,,
+meshagent_agents-0.0.24.dist-info/licenses/LICENSE,sha256=eTt0SPW-sVNdkZe9PS_S8WfCIyLjRXRl7sUBWdlteFg,10254
+meshagent_agents-0.0.24.dist-info/METADATA,sha256=hlnWqDYCabQsCnWFJdUsKomagFPAoTLtAvxRCqOfAKE,1307
+meshagent_agents-0.0.24.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+meshagent_agents-0.0.24.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_agents-0.0.24.dist-info/RECORD,,

{meshagent_agents-0.0.22.dist-info → meshagent_agents-0.0.24.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any