universal-mcp-agents 0.1.20rc1__tar.gz → 0.1.22__tar.gz

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.20rc1
+Version: 0.1.22
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

universal_mcp_agents-0.1.22/bech.py

@@ -0,0 +1,38 @@
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents import get_agent
+from langgraph.checkpoint.memory import MemorySaver
+from universal_mcp.agents.utils import messages_to_list
+import time
+from loguru import logger
+
+
+async def main():
+    start_time = time.time()
+    memory = MemorySaver()
+    logger.info(f"Checkpointer: Time consumed: {time.time() - start_time}")
+    agent_cls = get_agent("codeact-repl")
+    logger.info(f"Get class: Time consumed: {time.time() - start_time}")
+    registry = AgentrRegistry()
+    logger.info(f"Init Registry: Time consumed: {time.time() - start_time}")
+    agent = agent_cls(
+        name="CodeAct Agent",
+        instructions="Be very concise in your answers.",
+        model="anthropic:claude-4-sonnet-20250514",
+        tools={},
+        registry=registry,
+        memory=memory,
+    )
+    logger.info(f"Create agent: Time consumed: {time.time() - start_time}")
+    print("Init agent...")
+    await agent.ainit()
+    logger.info(f"Init Agent: Time consumed: {time.time() - start_time}")
+    print("Starting agent...")
+    async for e in agent.stream(user_input="hi"):
+        logger.info(f"First token: Time consumed: {time.time() - start_time}")
+        print(e)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.22}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-agents"
-version = "0.1.20-rc1"
+version = "0.1.22"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.22}/src/universal_mcp/agents/base.py

@@ -56,40 +56,41 @@ class BaseAgent:
             "run_name": self.name,
         }
 
+        last_ai_chunk = None
         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_mode=["messages", "custom"],
             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}")
-                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
+            if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:
+                payload, meta_dict = meta
+                is_playbook = isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "playbook"
+                additional_kwargs = getattr(payload, "additional_kwargs", {}) or {}
+                if is_playbook and not additional_kwargs.get("stream"):
+                    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
+
+        # 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 since it would have already been streamed above
+            yield event
 
     async def stream_interactive(self, thread_id: str, user_input: str):
         await self.ainit()

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.22}/src/universal_mcp/agents/codeact0/agent.py

@@ -1,33 +1,35 @@
 import json
 import re
-from collections.abc import Callable
 from typing import Literal, cast
+import uuid
 
 from langchain_core.messages import AIMessage, ToolMessage
 from langchain_core.tools import StructuredTool
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import START, StateGraph
-from langgraph.types import Command, RetryPolicy
+from langgraph.types import Command, RetryPolicy, StreamWriter
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig, ToolFormat
 
 from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.codeact0.llm_tool import ai_classify, call_llm, data_extractor, smart_print
+from universal_mcp.agents.codeact0.llm_tool import smart_print
 from universal_mcp.agents.codeact0.prompts import (
-    PLAYBOOK_CONFIRMING_PROMPT,
     PLAYBOOK_GENERATING_PROMPT,
     PLAYBOOK_PLANNING_PROMPT,
+    PLAYBOOK_META_PROMPT,
     create_default_prompt,
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
-from universal_mcp.agents.codeact0.state import CodeActState
+from universal_mcp.agents.codeact0.state import CodeActState, PlaybookCode, PlaybookPlan, PlaybookMeta
 from universal_mcp.agents.codeact0.tools import (
     create_meta_tools,
     enter_playbook_mode,
     get_valid_tools,
 )
+from universal_mcp.agents.codeact0.utils import add_tools
 from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.agents.utils import convert_tool_ids_to_dict, filter_retry_on, get_message_text
+from universal_mcp.agents.codeact0.utils import get_connected_apps_string
 
 
 class CodeActPlaybookAgent(BaseAgent):
@@ -51,16 +53,22 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.tools_config = tools or []
+        self.playbook_model_instance = load_chat_model("azure/gpt-4.1")
+        self.tools_config = tools or {}
         self.registry = registry
         self.playbook_registry = playbook_registry
+        self.playbook = playbook_registry.get_agent() if playbook_registry else None
         self.eval_fn = eval_unsafe
         self.sandbox_timeout = sandbox_timeout
-        self.processed_tools: list[StructuredTool | Callable] = []
+        self.default_tools = {
+            "llm": ["generate_text", "classify_data", "extract_data", "call_llm"],
+        }
+        add_tools(self.tools_config, self.default_tools)
+
 
     async def _build_graph(self):
         meta_tools = create_meta_tools(self.registry)
-        additional_tools = [smart_print, data_extractor, ai_classify, call_llm, meta_tools["web_search"]]
+        additional_tools = [smart_print, meta_tools["web_search"]]
         self.additional_tools = [
             t if isinstance(t, StructuredTool) else StructuredTool.from_function(t) for t in additional_tools
         ]
@@ -145,7 +153,7 @@ class CodeActPlaybookAgent(BaseAgent):
                     else:
                         raise Exception(
                             f"Unexpected tool call: {tool_call['name']}. "
-                            "tool calls must be one of 'enter_playbook_mode', 'execute_ipython_cell', 'load_functions', or 'search_functions'"
+                            "tool calls must be one of 'enter_playbook_mode', 'execute_ipython_cell', 'load_functions', or 'search_functions'. For using functions, call them in code using 'execute_ipython_cell'."
                         )
                 except Exception as e:
                     tool_result = str(e)
@@ -161,7 +169,7 @@ class CodeActPlaybookAgent(BaseAgent):
                 self.tools_config.extend(new_tool_ids)
                 self.exported_tools = await self.registry.export_tools(new_tool_ids, ToolFormat.LANGCHAIN)
                 self.final_instructions, self.tools_context = create_default_prompt(
-                    self.exported_tools, self.additional_tools, self.instructions
+                    self.exported_tools, self.additional_tools, self.instructions, await get_connected_apps_string(self.registry)
                 )
             if ask_user:
                 tool_messages.append(AIMessage(content=ai_msg))
@@ -184,41 +192,80 @@ class CodeActPlaybookAgent(BaseAgent):
                 },
             )
 
-        def playbook(state: CodeActState) -> Command[Literal["call_model"]]:
+        def playbook(state: CodeActState, writer: StreamWriter) -> Command[Literal["call_model"]]:
             playbook_mode = state.get("playbook_mode")
             if playbook_mode == "planning":
+                plan_id = str(uuid.uuid4())
+                writer({
+                    "type": "custom",
+                    id: plan_id,
+                    "name": "planning",
+                    "data": {"update": bool(self.playbook)}
+                })
                 planning_instructions = self.instructions + PLAYBOOK_PLANNING_PROMPT
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
-                response = self.model_instance.invoke(messages)
-                response = cast(AIMessage, response)
-                response_text = get_message_text(response)
-                # Extract plan from response text between triple backticks
-                plan_match = re.search(r"```(.*?)```", response_text, re.DOTALL)
-                if plan_match:
-                    plan = plan_match.group(1).strip()
-                else:
-                    plan = response_text.strip()
-                return Command(update={"messages": [response], "playbook_mode": "confirming", "plan": plan})
+                model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookPlan)
+                response = model_with_structured_output.invoke(messages)
+                plan = cast(PlaybookPlan, response)
+                
+                writer({"type": "custom", id: plan_id, "name": "planning", "data": {"plan": plan.steps}})
+                return Command(update={"messages": [AIMessage(content=json.dumps(plan.dict()), additional_kwargs={"type": "planning", "plan": plan.steps, "update": bool(self.playbook)})], "playbook_mode": "confirming", "plan": plan.steps})
 
             elif playbook_mode == "confirming":
-                confirmation_instructions = self.instructions + PLAYBOOK_CONFIRMING_PROMPT
-                messages = [{"role": "system", "content": confirmation_instructions}] + state["messages"]
-                response = self.model_instance.invoke(messages, stream=False)
-                response = get_message_text(response)
-                if "true" in response.lower():
-                    return Command(goto="playbook", update={"playbook_mode": "generating"})
-                else:
-                    return Command(goto="playbook", update={"playbook_mode": "planning"})
+                # Deterministic routing based on three exact button inputs from UI
+                user_text = ""
+                for m in reversed(state["messages"]):
+                    try:
+                        if getattr(m, "type", "") in {"human", "user"}:
+                            user_text = (get_message_text(m) or "").strip()
+                            if user_text:
+                                break
+                    except Exception:
+                        continue
+
+                t = user_text.lower()
+                if t == "yes, this is great":
+                    # Generate playbook metadata (name and description) before moving to generation
+                    meta_id = str(uuid.uuid4())
+                    writer({
+                        "type": "custom",
+                        id: meta_id,
+                        "name": "metadata",
+                        "data": {"update": bool(self.playbook)}
+                    })
+                    meta_instructions = self.instructions + PLAYBOOK_META_PROMPT
+                    messages = [{"role": "system", "content": meta_instructions}] + state["messages"]
+
+                    model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookMeta)
+                    meta_response = model_with_structured_output.invoke(messages)
+                    meta = cast(PlaybookMeta, meta_response)
+
+                    writer({"type": "custom", id: meta_id, "name": "metadata", "data": {"name": meta.name, "description": meta.description}})
+                    return Command(goto="playbook", update={"playbook_mode": "generating", "playbook_name": meta.name, "playbook_description": meta.description})
+                if t == "i would like to modify the plan":
+                    prompt_ai = AIMessage(content="What would you like to change about the plan? Let me know and I'll update the plan accordingly.", additional_kwargs={"stream": "true"})
+                    return Command(update={"playbook_mode": "planning", "messages": [prompt_ai]})
+                if t == "let's do something else":
+                    return Command(goto="call_model", update={"playbook_mode": "inactive"})
+
+                # Fallback safe default
+                return Command(goto="call_model", update={"playbook_mode": "inactive"})
 
             elif playbook_mode == "generating":
+                generate_id = str(uuid.uuid4())
+                writer({
+                    "type": "custom",
+                    id: generate_id,
+                    "name": "generating",
+                    "data": {"update": bool(self.playbook)}
+                })
                 generating_instructions = self.instructions + PLAYBOOK_GENERATING_PROMPT
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
-                response = cast(AIMessage, self.model_instance.invoke(messages))
-                raw_content = get_message_text(response)
-                func_code = raw_content.strip()
-                func_code = func_code.replace("```python", "").replace("```", "")
-                func_code = func_code.strip()
+                
+                model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookCode)
+                response = model_with_structured_output.invoke(messages)
+                func_code = cast(PlaybookCode, response).code
 
                 # Extract function name (handle both regular and async functions)
                 match = re.search(r"^\s*(?:async\s+)?def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", func_code, re.MULTILINE)
@@ -227,48 +274,44 @@ class CodeActPlaybookAgent(BaseAgent):
                 else:
                     function_name = "generated_playbook"
 
+                # Use generated metadata if available
+                final_name = state.get("playbook_name") or function_name
+                final_description = state.get("playbook_description") or f"Generated playbook: {function_name}"
+
                 # Save or update an Agent using the helper registry
-                saved_note = ""
                 try:
-                    if not self.playbook_registry:
+                    if not self.playbook_registry:  
                         raise ValueError("Playbook registry is not configured")
 
                     # Build instructions payload embedding the plan and function code
                     instructions_payload = {
                         "playbookPlan": state["plan"],
-                        "playbookScript": {
-                            "name": function_name,
-                            "code": func_code,
-                        },
+                        "playbookScript": func_code,
                     }
 
                     # Convert tool ids list to dict
                     tool_dict = convert_tool_ids_to_dict(state["selected_tool_ids"])
 
-                    res = self.playbook_registry.create_agent(
-                        name=function_name,
-                        description=f"Generated playbook: {function_name}",
+                    res = self.playbook_registry.upsert_agent(
+                        name=final_name,
+                        description=final_description,
                         instructions=instructions_payload,
                         tools=tool_dict,
                         visibility="private",
                     )
-                    saved_note = f"Successfully created your playbook! Check it out here: [View Playbook](https://wingmen.info/agents/{res.id})"
                 except Exception as e:
-                    saved_note = f"Failed to save generated playbook as Agent '{function_name}': {e}"
+                    raise e
 
-                # Mock tool call for exit_playbook_mode (for testing/demonstration)
-                mock_exit_tool_call = {"name": "exit_playbook_mode", "args": {}, "id": "mock_exit_playbook_123"}
-                mock_assistant_message = AIMessage(content=saved_note, tool_calls=[mock_exit_tool_call])
-
-                # Mock tool response for exit_playbook_mode
-                mock_exit_tool_response = ToolMessage(
-                    content=json.dumps(f"Exited Playbook Mode.{saved_note}"),
-                    name="exit_playbook_mode",
-                    tool_call_id="mock_exit_playbook_123",
-                )
+                writer({
+                    "type": "custom",
+                    id: generate_id,
+                    "name": "generating",
+                    "data": {"id": str(res.id), "update": bool(self.playbook)}
+                })
+                mock_assistant_message = AIMessage(content=json.dumps(response.dict()), additional_kwargs={"type": "generating", "id": str(res.id), "update": bool(self.playbook)})
 
                 return Command(
-                    update={"messages": [mock_assistant_message, mock_exit_tool_response], "playbook_mode": "normal"}
+                    update={"messages": [mock_assistant_message], "playbook_mode": "normal"}
                 )
 
         async def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
@@ -277,7 +320,7 @@ class CodeActPlaybookAgent(BaseAgent):
             self.tools_config.extend(state.get("selected_tool_ids", []))
             self.exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
             self.final_instructions, self.tools_context = create_default_prompt(
-                self.exported_tools, self.additional_tools, self.instructions
+                self.exported_tools, self.additional_tools, self.instructions, await get_connected_apps_string(self.registry)
             )
             if state.get("playbook_mode") in ["planning", "confirming", "generating"]:
                 return "playbook"

universal_mcp_agents-0.1.22/src/universal_mcp/agents/codeact0/llm_tool.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+from universal_mcp.agents.codeact0.utils import light_copy
+
+MAX_RETRIES = 3
+
+
+def get_context_str(source: Any | list[Any] | dict[str, Any]) -> str:
+    """Converts context to a string representation."""
+    if not isinstance(source, dict):
+        if isinstance(source, list):
+            source = {f"doc_{i + 1}": str(doc) for i, doc in enumerate(source)}
+        else:
+            source = {"content": str(source)}
+
+    return "\n".join(f"<{k}>\n{str(v)}\n</{k}>" for k, v in source.items())
+
+
+def smart_print(data: Any) -> None:
+    """Prints a dictionary or list of dictionaries with string values truncated to 30 characters.
+
+    Args:
+        data: Either a dictionary with string keys, or a list of such dictionaries
+    """
+    print(light_copy(data))  # noqa: T201