universal-mcp-agents 0.1.19rc1__py3-none-any.whl → 0.1.24rc3__py3-none-any.whl

universal_mcp/agents/__init__.py

@@ -3,32 +3,29 @@ from typing import Literal
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.bigtool import BigToolAgent
 from universal_mcp.agents.builder.builder import BuilderAgent
-from universal_mcp.agents.codeact import CodeActAgent as CodeActScript
-from universal_mcp.agents.codeact0 import CodeActPlaybookAgent as CodeActRepl
+from universal_mcp.agents.codeact0 import CodeActPlaybookAgent
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
-from universal_mcp.agents.unified import UnifiedAgent
+from universal_mcp.agents.codeact00 import CodeActPlaybookAgent as CodeAct00Agent
+from universal_mcp.agents.codeact01 import CodeActPlaybookAgent as CodeAct01Agent
 
 
-def get_agent(agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-script", "codeact-repl"]):
+def get_agent(
+    agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-repl", "codeact-00", "codeact-01"],
+):
+    print("agent_name", agent_name)
     if agent_name == "react":
         return ReactAgent
     elif agent_name == "simple":
         return SimpleAgent
-    elif agent_name == "builder":
-        return BuilderAgent
-    elif agent_name == "bigtool":
-        return BigToolAgent
-    elif agent_name == "codeact-script":
-        return CodeActScript
     elif agent_name == "codeact-repl":
-        return CodeActRepl
-    elif agent_name == "unified":
-        return UnifiedAgent
+        return CodeActPlaybookAgent
+    elif agent_name == "codeact-00":
+        return CodeAct00Agent
+    elif agent_name == "codeact-01":
+        return CodeAct01Agent
     else:
-        raise ValueError(
-            f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, bigtool, codeact-script, codeact-repl"
-        )
+        raise ValueError(f"Unknown agent: {agent_name}. Possible values:  react, simple, codeact-repl, codeact-00, codeact-01")
 
 
 __all__ = [
@@ -39,4 +36,6 @@ __all__ = [
     "BigToolAgent",
     "CodeActScript",
     "CodeActRepl",
+    "CodeAct00Agent",
+    "CodeAct01Agent",
 ]

universal_mcp/agents/base.py

@@ -1,4 +1,4 @@
-# agents/base.py
+import asyncio
 from typing import cast
 from uuid import uuid4
 
@@ -49,44 +49,55 @@ class BaseAgent:
             run_metadata.update(metadata)
 
         run_config = {
+            "recursion_limit": 50,
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
+            "run_id": thread_id,
+            "run_name": self.name,
         }
 
-        async for event, meta in self._graph.astream(
-            {"messages": [{"role": "user", "content": user_input}]},
-            config=run_config,
-            context={"system_prompt": self.instructions, "model": self.model},
-            stream_mode="messages",
-            stream_usage=True,
-        ):
-            # Only forward assistant token chunks that are not tool-related.
-            type_ = type(event)
-            tags = meta.get("tags", []) if isinstance(meta, dict) else []
-            is_quiet = isinstance(tags, list) and ("quiet" in tags)
-            if is_quiet:
-                continue
-            # Handle different types of messages
-            if type_ == AIMessageChunk:
-                # Accumulate billing and aggregate message
-                aggregate = event if aggregate is None else aggregate + event
-            # Ignore intermeddite finish messages
-            if "finish_reason" in event.response_metadata:
-                # Got LLM finish reason ignore it
-                logger.debug(
-                    f"Finish event: {event}, reason: {event.response_metadata['finish_reason']}, Metadata: {meta}"
-                )
-                pass
-            else:
-                logger.debug(f"Event: {event}, Metadata: {meta}")
+        last_ai_chunk = None
+        try:
+            async for event, meta in self._graph.astream(
+                {"messages": [{"role": "user", "content": user_input}]},
+                config=run_config,
+                context={"system_prompt": self.instructions, "model": self.model},
+                stream_mode=["messages", "custom"],
+                stream_usage=True,
+            ):
+                if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:  # noqa: PLR2004
+                    payload, meta_dict = meta
+                    metadata = getattr(payload, "metadata", {}) or {}
+                    if metadata and "quiet" in metadata.get("tags"):
+                        continue
+                    if meta_dict.get("tags") and "quiet" in meta_dict.get("tags"):
+                        continue
+                    if isinstance(payload, AIMessageChunk):
+                        last_ai_chunk = payload
+                        aggregate = payload if aggregate is None else aggregate + payload
+                    if "finish_reason" in payload.response_metadata:
+                        logger.debug(
+                            f"Finish event: {payload}, reason: {payload.response_metadata['finish_reason']}, Metadata: {meta_dict}"
+                        )
+                        pass
+                    logger.debug(f"Event: {payload}, Metadata: {meta_dict}")
+                    yield payload
+
+                if event == "custom":
+                    yield meta
+
+        except asyncio.CancelledError:
+            logger.info(f"Stream for thread_id {thread_id} was cancelled by the user.")
+            # Perform any cleanup here if necessary
+        finally:
+            # This block will run whether the stream finished normally or was cancelled
+            # Send a final finished message if we saw any AI chunks (to carry usage)
+            if last_ai_chunk is not None and aggregate is not None:
+                event = cast(AIMessageChunk, last_ai_chunk)
+                event.usage_metadata = aggregate.usage_metadata
+                logger.debug(f"Usage metadata: {event.usage_metadata}")
+                event.content = ""  # Clear the message
                 yield event
-        # Send a final finished message
-        # The last event would be finish
-        event = cast(AIMessageChunk, event)
-        event.usage_metadata = aggregate.usage_metadata
-        logger.debug(f"Usage metadata: {event.usage_metadata}")
-        event.content = ""  # Clear the message since it would have already been streamed above
-        yield event
 
     async def stream_interactive(self, thread_id: str, user_input: str):
         await self.ainit()
@@ -113,7 +124,7 @@ class BaseAgent:
             run_metadata.update(metadata)
 
         run_config = {
-            "recursion_limit": 25,
+            "recursion_limit": 50,
             "configurable": {"thread_id": thread_id},
             "metadata": run_metadata,
             "run_id": thread_id,

universal_mcp/agents/bigtool/state.py

@@ -1,6 +1,6 @@
 from typing import Annotated
 
-from langgraph.prebuilt.chat_agent_executor import AgentState
+from langchain.agents import AgentState
 
 
 def _enqueue(left: list, right: list) -> list:

universal_mcp/agents/cli.py

@@ -18,19 +18,16 @@ app = Typer()
     mcp client run --config client_config.json
     """,
 )
-def run(name: str = "react"):
+def run(name: str = "codeact-repl"):
     """Run the agent CLI"""
 
     setup_logger(log_file=None, level="ERROR")
     client = AgentrClient()
     params = {
         "instructions": "You are a helpful assistant",
-        "model": "anthropic/claude-sonnet-4-20250514",
+        "model": "anthropic:claude-4-sonnet-20250514",
         "registry": AgentrRegistry(client=client),
         "memory": MemorySaver(),
-        "tools": {
-            "google_mail": ["send_email"],
-        },
     }
     agent_cls = get_agent(name)
     agent = agent_cls(name=name, **params)

universal_mcp/agents/codeact0/__init__.py

@@ -1,4 +1,3 @@
-from .agent import CodeActAgent
-from .playbook_agent import CodeActPlaybookAgent
+from .agent import CodeActPlaybookAgent
 
-__all__ = ["CodeActAgent", "CodeActPlaybookAgent"]
+__all__ = ["CodeActPlaybookAgent"]

universal_mcp/agents/codeact0/__main__.py

@@ -4,24 +4,21 @@ from langgraph.checkpoint.memory import MemorySaver
 from rich import print
 from universal_mcp.agentr.registry import AgentrRegistry
 
-from universal_mcp.agents.codeact0.agent import CodeActAgent
+from universal_mcp.agents.codeact0.agent import CodeActPlaybookAgent
 from universal_mcp.agents.utils import messages_to_list
 
 
 async def main():
     memory = MemorySaver()
-    agent = CodeActAgent(
+    agent = CodeActPlaybookAgent(
         name="CodeAct Agent",
         instructions="Be very concise in your answers.",
-        model="anthropic:claude-4-sonnet-20250514",
-        tools={"google_mail": ["list_messages"]},
+        model="azure/gpt-4.1",
         registry=AgentrRegistry(),
         memory=memory,
     )
     print("Starting agent...")
-    result = await agent.invoke(
-        user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
-    )
+    result = await agent.invoke(user_input="Check my google calendar and show my todays agenda")
     print(messages_to_list(result["messages"]))