supyagent 0.1.0__py3-none-any.whl

supyagent/core/__init__.py

@@ -0,0 +1,21 @@
+"""Core module for supyagent."""
+
+from supyagent.core.agent import Agent
+from supyagent.core.context import DelegationContext
+from supyagent.core.credentials import CredentialManager
+from supyagent.core.delegation import DelegationManager
+from supyagent.core.executor import ExecutionRunner
+from supyagent.core.llm import LLMClient
+from supyagent.core.registry import AgentRegistry
+from supyagent.core.session_manager import SessionManager
+
+__all__ = [
+    "Agent",
+    "AgentRegistry",
+    "CredentialManager",
+    "DelegationContext",
+    "DelegationManager",
+    "ExecutionRunner",
+    "LLMClient",
+    "SessionManager",
+]

supyagent/core/agent.py

@@ -0,0 +1,379 @@
+"""
+Core Agent class.
+
+The Agent handles the conversation loop, tool execution, and message management.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from supyagent.core.credentials import CredentialManager
+from supyagent.core.llm import LLMClient
+from supyagent.core.session_manager import SessionManager
+from supyagent.core.tools import (
+    REQUEST_CREDENTIAL_TOOL,
+    discover_tools,
+    execute_tool,
+    filter_tools,
+    is_credential_request,
+    supypowers_to_openai_tools,
+)
+from supyagent.models.agent_config import AgentConfig
+from supyagent.models.session import Message, Session
+
+if TYPE_CHECKING:
+    from supyagent.core.delegation import DelegationManager
+    from supyagent.core.registry import AgentRegistry
+
+
+class Agent:
+    """
+    An LLM agent that can use supypowers tools.
+
+    The agent maintains a conversation history and handles the loop of:
+    1. Send user message to LLM
+    2. If LLM wants to call tools, execute them
+    3. Feed tool results back to LLM
+    4. Repeat until LLM gives final response
+
+    Agents can also delegate tasks to other agents if configured with delegates.
+    """
+
+    def __init__(
+        self,
+        config: AgentConfig,
+        session: Session | None = None,
+        session_manager: SessionManager | None = None,
+        credential_manager: CredentialManager | None = None,
+        registry: "AgentRegistry | None" = None,
+        parent_instance_id: str | None = None,
+    ):
+        """
+        Initialize an agent from configuration.
+
+        Args:
+            config: Agent configuration
+            session: Optional existing session to resume
+            session_manager: Optional session manager (creates one if not provided)
+            credential_manager: Optional credential manager (creates one if not provided)
+            registry: Optional agent registry for multi-agent support
+            parent_instance_id: Instance ID of parent agent (if this is a sub-agent)
+        """
+        self.config = config
+
+        # Initialize LLM client
+        self.llm = LLMClient(
+            model=config.model.provider,
+            temperature=config.model.temperature,
+            max_tokens=config.model.max_tokens,
+        )
+
+        # Initialize session management
+        self.session_manager = session_manager or SessionManager()
+
+        # Initialize credential management
+        self.credential_manager = credential_manager or CredentialManager()
+
+        # Initialize multi-agent support
+        self.instance_id: str | None = None
+        self.delegation_mgr: "DelegationManager | None" = None
+
+        if config.delegates:
+            # Lazy import to avoid circular dependency
+            from supyagent.core.delegation import DelegationManager
+            from supyagent.core.registry import AgentRegistry
+
+            self.registry = registry or AgentRegistry()
+            self.delegation_mgr = DelegationManager(
+                self.registry,
+                self,
+                grandparent_instance_id=parent_instance_id,
+            )
+            self.instance_id = self.delegation_mgr.parent_id
+        else:
+            self.registry = registry
+
+        # Load available tools (including delegation tools)
+        self.tools = self._load_tools()
+
+        # Initialize session
+        if session:
+            self.session = session
+            self.messages = self._reconstruct_messages(session)
+        else:
+            self.session = self.session_manager.create_session(
+                config.name, config.model.provider
+            )
+            self.messages: list[dict[str, Any]] = [
+                {"role": "system", "content": config.system_prompt}
+            ]
+
+    def _load_tools(self) -> list[dict[str, Any]]:
+        """
+        Discover and filter available tools.
+
+        Returns:
+            List of tools in OpenAI function calling format
+        """
+        tools: list[dict[str, Any]] = []
+
+        # Discover tools from supypowers
+        sp_tools = discover_tools()
+
+        # Convert to OpenAI format
+        openai_tools = supypowers_to_openai_tools(sp_tools)
+
+        # Filter by permissions
+        filtered = filter_tools(openai_tools, self.config.tools)
+        tools.extend(filtered)
+
+        # Always add the credential request tool
+        tools.append(REQUEST_CREDENTIAL_TOOL)
+
+        # Add delegation tools if this agent can delegate
+        if self.delegation_mgr:
+            tools.extend(self.delegation_mgr.get_delegation_tools())
+
+        return tools
+
+    def _reconstruct_messages(self, session: Session) -> list[dict[str, Any]]:
+        """
+        Reconstruct LLM message format from session history.
+
+        Args:
+            session: Session with message history
+
+        Returns:
+            List of messages in OpenAI format
+        """
+        messages: list[dict[str, Any]] = [
+            {"role": "system", "content": self.config.system_prompt}
+        ]
+
+        for msg in session.messages:
+            if msg.type == "user":
+                messages.append({"role": "user", "content": msg.content})
+            elif msg.type == "assistant":
+                m: dict[str, Any] = {"role": "assistant", "content": msg.content}
+                if msg.tool_calls:
+                    m["tool_calls"] = msg.tool_calls
+                messages.append(m)
+            elif msg.type == "tool_result":
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": msg.tool_call_id,
+                    "content": msg.content,
+                })
+
+        return messages
+
+    def send_message(self, content: str) -> str:
+        """
+        Send a user message and get the agent's response.
+
+        This handles the full tool-use loop:
+        1. Add user message
+        2. Get LLM response
+        3. If tools requested, execute them and continue
+        4. Return final text response
+
+        Args:
+            content: User's message
+
+        Returns:
+            Agent's final text response
+        """
+        # Record user message
+        user_msg = Message(type="user", content=content)
+        self.session_manager.append_message(self.session, user_msg)
+        self.messages.append({"role": "user", "content": content})
+
+        # Maximum iterations to prevent infinite loops
+        max_iterations = self.config.limits.get("max_tool_calls_per_turn", 20)
+        iterations = 0
+
+        while iterations < max_iterations:
+            iterations += 1
+
+            # Call LLM
+            response = self.llm.chat(
+                messages=self.messages,
+                tools=self.tools if self.tools else None,
+            )
+
+            assistant_message = response.choices[0].message
+
+            # Build message dict for history
+            msg_dict: dict[str, Any] = {
+                "role": "assistant",
+                "content": assistant_message.content,
+            }
+
+            # Build tool_calls list for session storage
+            tool_calls_for_session: list[dict[str, Any]] = []
+
+            if assistant_message.tool_calls:
+                msg_dict["tool_calls"] = [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments,
+                        },
+                    }
+                    for tc in assistant_message.tool_calls
+                ]
+                tool_calls_for_session = msg_dict["tool_calls"]
+
+            # Record assistant message to session
+            asst_record = Message(
+                type="assistant",
+                content=assistant_message.content,
+                tool_calls=tool_calls_for_session if tool_calls_for_session else None,
+            )
+            self.session_manager.append_message(self.session, asst_record)
+
+            # Add to LLM message history
+            self.messages.append(msg_dict)
+
+            # If no tool calls, we're done
+            if not assistant_message.tool_calls:
+                return assistant_message.content or ""
+
+            # Execute each tool call
+            for tool_call in assistant_message.tool_calls:
+                # Handle credential requests specially
+                if is_credential_request(tool_call):
+                    result = self._handle_credential_request(tool_call)
+                else:
+                    result = self._execute_tool_call(tool_call)
+
+                # Record tool result to session
+                tool_msg = Message(
+                    type="tool_result",
+                    tool_call_id=tool_call.id,
+                    name=tool_call.function.name,
+                    content=json.dumps(result),
+                )
+                self.session_manager.append_message(self.session, tool_msg)
+
+                # Add to LLM message history
+                self.messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": json.dumps(result),
+                })
+
+        # If we hit max iterations, return what we have
+        return self.messages[-1].get("content", "") or ""
+
+    def _handle_credential_request(self, tool_call: Any) -> dict[str, Any]:
+        """
+        Handle a credential request from the LLM.
+
+        Args:
+            tool_call: The tool call requesting credentials
+
+        Returns:
+            Result dict indicating success or failure
+        """
+        try:
+            args = json.loads(tool_call.function.arguments)
+        except json.JSONDecodeError:
+            return {"ok": False, "error": "Invalid credential request arguments"}
+
+        name = args.get("name", "")
+        description = args.get("description", "")
+        service = args.get("service")
+
+        if not name:
+            return {"ok": False, "error": "Credential name is required"}
+
+        # Check if we already have it
+        existing = self.credential_manager.get(self.config.name, name)
+        if existing:
+            return {
+                "ok": True,
+                "message": f"Credential {name} is already available",
+            }
+
+        # Prompt user for the credential
+        result = self.credential_manager.prompt_for_credential(
+            name=name,
+            description=description,
+            service=service,
+        )
+
+        if result is None:
+            return {
+                "ok": False,
+                "error": f"User declined to provide credential {name}",
+            }
+
+        value, persist = result
+        self.credential_manager.set(self.config.name, name, value, persist=persist)
+
+        return {
+            "ok": True,
+            "message": f"Credential {name} has been provided and is now available",
+        }
+
+    def _execute_tool_call(self, tool_call: Any) -> dict[str, Any]:
+        """
+        Execute a single tool call.
+
+        Args:
+            tool_call: Tool call from LLM response
+
+        Returns:
+            Result dict from tool execution
+        """
+        name = tool_call.function.name
+
+        # Check if this is a delegation tool
+        if self.delegation_mgr and self.delegation_mgr.is_delegation_tool(name):
+            return self.delegation_mgr.execute_delegation(tool_call)
+
+        # Parse arguments
+        arguments_str = tool_call.function.arguments
+        try:
+            args = json.loads(arguments_str)
+        except json.JSONDecodeError:
+            return {"ok": False, "error": f"Invalid JSON arguments: {arguments_str}"}
+
+        # Parse script__function format
+        if "__" not in name:
+            return {"ok": False, "error": f"Invalid tool name format: {name}"}
+
+        script, func = name.split("__", 1)
+
+        # Get credentials for tool execution
+        secrets = self.credential_manager.get_all_for_tools(self.config.name)
+
+        # Execute via supypowers
+        return execute_tool(script, func, args, secrets=secrets)
+
+    def get_available_tools(self) -> list[str]:
+        """
+        Get list of available tool names.
+
+        Returns:
+            List of tool names
+        """
+        return [
+            tool.get("function", {}).get("name", "unknown")
+            for tool in self.tools
+        ]
+
+    def clear_history(self) -> None:
+        """Clear conversation history and start a new session."""
+        # Create a new session
+        self.session = self.session_manager.create_session(
+            self.config.name, self.config.model.provider
+        )
+        self.messages = [
+            {"role": "system", "content": self.config.system_prompt}
+        ]

supyagent/core/context.py

@@ -0,0 +1,158 @@
+"""
+Context passing for multi-agent delegation.
+
+Enables rich context to be passed from parent to child agents,
+including conversation summaries and relevant facts.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from supyagent.core.llm import LLMClient
+
+
+@dataclass
+class DelegationContext:
+    """
+    Context passed from parent to child agent.
+
+    Attributes:
+        parent_agent: Name of the parent agent
+        parent_task: The task the parent is working on
+        conversation_summary: Summary of relevant conversation history
+        relevant_facts: Key facts relevant to the delegation
+        shared_data: Arbitrary data to pass to the child
+    """
+
+    parent_agent: str
+    parent_task: str
+    conversation_summary: str | None = None
+    relevant_facts: list[str] = field(default_factory=list)
+    shared_data: dict[str, Any] = field(default_factory=dict)
+
+    def to_prompt(self) -> str:
+        """
+        Convert context to a prompt prefix for the child agent.
+
+        Returns:
+            A formatted string to prepend to the child's task
+        """
+        parts = [
+            f"You are being called by the '{self.parent_agent}' agent.",
+            f"Parent's current task: {self.parent_task}",
+        ]
+
+        if self.conversation_summary:
+            parts.append(f"\nConversation context:\n{self.conversation_summary}")
+
+        if self.relevant_facts:
+            parts.append("\nRelevant information:")
+            for fact in self.relevant_facts:
+                parts.append(f"- {fact}")
+
+        if self.shared_data:
+            parts.append("\nShared data:")
+            for key, value in self.shared_data.items():
+                parts.append(f"- {key}: {value}")
+
+        return "\n".join(parts)
+
+
+def summarize_conversation(
+    messages: list[dict[str, Any]],
+    llm: LLMClient,
+    max_messages: int = 10,
+) -> str | None:
+    """
+    Use LLM to create a summary of the conversation for context passing.
+
+    Args:
+        messages: List of conversation messages
+        llm: LLM client for generating summary
+        max_messages: Maximum number of recent messages to include
+
+    Returns:
+        A concise summary of the conversation, or None if no messages
+    """
+    # Extract just user and assistant messages
+    conversation = []
+    for msg in messages[-max_messages:]:
+        role = msg.get("role")
+        if role in ("user", "assistant"):
+            role_label = "User" if role == "user" else "Assistant"
+            content = msg.get("content", "")
+            if content:
+                # Truncate long messages
+                if len(content) > 300:
+                    content = content[:300] + "..."
+                conversation.append(f"{role_label}: {content}")
+
+    if not conversation:
+        return None
+
+    summary_prompt = f"""Summarize this conversation in 2-3 sentences, focusing on the main task and key decisions:
+
+{chr(10).join(conversation)}
+
+Summary:"""
+
+    try:
+        response = llm.chat([{"role": "user", "content": summary_prompt}])
+        return response.choices[0].message.content
+    except Exception:
+        # If summarization fails, return None
+        return None
+
+
+def extract_relevant_facts(
+    messages: list[dict[str, Any]],
+    task: str,
+    llm: LLMClient,
+) -> list[str]:
+    """
+    Extract facts from the conversation relevant to a specific task.
+
+    Args:
+        messages: Conversation messages
+        task: The task to extract relevant facts for
+        llm: LLM client
+
+    Returns:
+        List of relevant facts
+    """
+    # Extract content from recent messages
+    content_parts = []
+    for msg in messages[-5:]:
+        if msg.get("content"):
+            content_parts.append(msg["content"])
+
+    if not content_parts:
+        return []
+
+    context = "\n---\n".join(content_parts)
+
+    prompt = f"""Given this conversation context and the upcoming task, list 2-4 key facts that would be relevant.
+
+Conversation context:
+{context}
+
+Upcoming task: {task}
+
+List the relevant facts (one per line, start each with "- "):"""
+
+    try:
+        response = llm.chat([{"role": "user", "content": prompt}])
+        content = response.choices[0].message.content or ""
+
+        # Parse bullet points
+        facts = []
+        for line in content.split("\n"):
+            line = line.strip()
+            if line.startswith("- "):
+                facts.append(line[2:])
+            elif line.startswith("• "):
+                facts.append(line[2:])
+
+        return facts[:4]  # Limit to 4 facts
+    except Exception:
+        return []