supyagent 0.1.0__py3-none-any.whl

supyagent/core/executor.py

@@ -0,0 +1,232 @@
+"""
+Execution runner for non-interactive agent execution.
+
+Execution agents are stateless, input→output pipelines designed for automation.
+"""
+
+import json
+import os
+import re
+from typing import Any
+
+from supyagent.core.credentials import CredentialManager
+from supyagent.core.llm import LLMClient
+from supyagent.core.tools import (
+    discover_tools,
+    execute_tool,
+    filter_tools,
+    is_credential_request,
+    supypowers_to_openai_tools,
+)
+from supyagent.models.agent_config import AgentConfig
+
+
+class ExecutionRunner:
+    """
+    Runs agents in non-interactive execution mode.
+
+    Key differences from interactive mode:
+    - No session persistence
+    - No credential prompting (must be pre-provided)
+    - Single input → output execution
+    - Designed for automation and pipelines
+    """
+
+    def __init__(
+        self,
+        config: AgentConfig,
+        credential_manager: CredentialManager | None = None,
+    ):
+        """
+        Initialize the execution runner.
+
+        Args:
+            config: Agent configuration
+            credential_manager: Optional credential manager for stored credentials
+        """
+        self.config = config
+        self.credential_manager = credential_manager or CredentialManager()
+
+        # Initialize LLM client
+        self.llm = LLMClient(
+            model=config.model.provider,
+            temperature=config.model.temperature,
+            max_tokens=config.model.max_tokens,
+        )
+
+        # Load available tools (excluding credential request tool for execution mode)
+        self.tools = self._load_tools()
+
+    def _load_tools(self) -> list[dict[str, Any]]:
+        """
+        Load tools for execution mode.
+
+        Note: Does NOT include request_credential tool since
+        execution mode cannot prompt for credentials.
+        """
+        # If no tools allowed, return empty
+        if not self.config.tools.allow:
+            return []
+
+        # Discover tools from supypowers
+        sp_tools = discover_tools()
+        openai_tools = supypowers_to_openai_tools(sp_tools)
+        filtered = filter_tools(openai_tools, self.config.tools)
+
+        return filtered
+
+    def run(
+        self,
+        task: str | dict[str, Any],
+        secrets: dict[str, str] | None = None,
+        output_format: str = "raw",
+    ) -> dict[str, Any]:
+        """
+        Execute a task and return the result.
+
+        Args:
+            task: Task description (string) or structured input (dict)
+            secrets: Pre-provided credentials (KEY=VALUE)
+            output_format: "raw" | "json" | "markdown"
+
+        Returns:
+            {"ok": True, "data": ...} or {"ok": False, "error": ...}
+        """
+        # Merge secrets: stored credentials + provided secrets
+        all_secrets = self.credential_manager.get_all_for_tools(self.config.name)
+        if secrets:
+            all_secrets.update(secrets)
+
+        # Inject secrets into environment for this execution
+        for key, value in all_secrets.items():
+            os.environ[key] = value
+
+        try:
+            # Build the prompt
+            if isinstance(task, dict):
+                user_content = self._format_structured_input(task)
+            else:
+                user_content = str(task)
+
+            messages: list[dict[str, Any]] = [
+                {"role": "system", "content": self.config.system_prompt},
+                {"role": "user", "content": user_content},
+            ]
+
+            # Run with tool loop (max iterations for safety)
+            max_iterations = self.config.limits.get("max_tool_calls_per_turn", 20)
+            iterations = 0
+
+            while iterations < max_iterations:
+                iterations += 1
+
+                response = self.llm.chat(
+                    messages=messages,
+                    tools=self.tools if self.tools else None,
+                )
+                assistant_msg = response.choices[0].message
+
+                # Build message for history
+                msg_dict: dict[str, Any] = {
+                    "role": "assistant",
+                    "content": assistant_msg.content,
+                }
+
+                if assistant_msg.tool_calls:
+                    msg_dict["tool_calls"] = [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments,
+                            },
+                        }
+                        for tc in assistant_msg.tool_calls
+                    ]
+
+                messages.append(msg_dict)
+
+                # If no tool calls, we're done
+                if not assistant_msg.tool_calls:
+                    return self._format_output(assistant_msg.content or "", output_format)
+
+                # Execute tools
+                for tool_call in assistant_msg.tool_calls:
+                    # Credential requests fail in execution mode
+                    if is_credential_request(tool_call):
+                        try:
+                            args = json.loads(tool_call.function.arguments)
+                            cred_name = args.get("name", "unknown")
+                        except json.JSONDecodeError:
+                            cred_name = "unknown"
+
+                        return {
+                            "ok": False,
+                            "error": f"Credential '{cred_name}' required but not provided. "
+                            f"Pass it via --secrets {cred_name}=<value>",
+                        }
+
+                    result = self._execute_tool(tool_call, all_secrets)
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": json.dumps(result),
+                    })
+
+            return {"ok": False, "error": "Max tool iterations exceeded"}
+
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+    def _format_structured_input(self, task: dict[str, Any]) -> str:
+        """Format a structured input dict into a prompt."""
+        return json.dumps(task, indent=2)
+
+    def _format_output(self, content: str, output_format: str) -> dict[str, Any]:
+        """Format the output according to requested format."""
+        if output_format == "json":
+            # Try to parse as JSON
+            try:
+                data = json.loads(content)
+                return {"ok": True, "data": data}
+            except json.JSONDecodeError:
+                pass
+
+            # Try to extract JSON from markdown code block
+            match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", content)
+            if match:
+                try:
+                    data = json.loads(match.group(1))
+                    return {"ok": True, "data": data}
+                except json.JSONDecodeError:
+                    pass
+
+            # Return as-is
+            return {"ok": True, "data": content}
+
+        elif output_format == "markdown":
+            return {"ok": True, "data": content, "format": "markdown"}
+
+        else:  # raw
+            return {"ok": True, "data": content}
+
+    def _execute_tool(
+        self,
+        tool_call: Any,
+        secrets: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Execute a tool call."""
+        name = tool_call.function.name
+        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}"}
+
+        if "__" not in name:
+            return {"ok": False, "error": f"Invalid tool name format: {name}"}
+
+        script, func = name.split("__", 1)
+        return execute_tool(script, func, args, secrets=secrets)

supyagent/core/llm.py

@@ -0,0 +1,73 @@
+"""
+LiteLLM wrapper for unified LLM access.
+"""
+
+from typing import Any
+
+from litellm import completion
+from litellm.types.utils import ModelResponse
+
+
+class LLMClient:
+    """
+    Wrapper around LiteLLM for consistent LLM access.
+
+    Supports any provider that LiteLLM supports:
+    - OpenAI: openai/gpt-4o
+    - Anthropic: anthropic/claude-3-5-sonnet-20241022
+    - Ollama: ollama/llama3
+    - And 100+ more...
+    """
+
+    def __init__(
+        self,
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ):
+        """
+        Initialize the LLM client.
+
+        Args:
+            model: LiteLLM model identifier (e.g., 'anthropic/claude-3-5-sonnet-20241022')
+            temperature: Sampling temperature (0-2)
+            max_tokens: Maximum tokens in response
+        """
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+    def chat(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        stream: bool = False,
+    ) -> ModelResponse:
+        """
+        Send a chat completion request.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            tools: Optional list of tool definitions (OpenAI format)
+            stream: Whether to stream the response
+
+        Returns:
+            LiteLLM ModelResponse
+        """
+        kwargs: dict[str, Any] = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "stream": stream,
+        }
+
+        if tools:
+            kwargs["tools"] = tools
+            kwargs["tool_choice"] = "auto"
+
+        return completion(**kwargs)
+
+    def change_model(self, model: str) -> None:
+        """Change the model being used."""
+        self.model = model

supyagent/core/registry.py

@@ -0,0 +1,238 @@
+"""
+Agent Registry for tracking active agent instances.
+
+Enables multi-agent orchestration by tracking parent-child relationships
+and managing agent lifecycles.
+"""
+
+import json
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, UTC
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from supyagent.core.agent import Agent
+
+
+@dataclass
+class AgentInstance:
+    """
+    Metadata for a running agent instance.
+
+    Attributes:
+        name: The agent type name (e.g., "planner", "researcher")
+        instance_id: Unique identifier for this instance
+        created_at: When the instance was created
+        parent_id: Instance ID of the parent agent (if spawned by another)
+        status: Current status (active, completed, failed)
+    """
+
+    name: str
+    instance_id: str
+    created_at: datetime
+    parent_id: str | None = None
+    status: str = "active"
+    depth: int = 0  # Delegation depth for preventing infinite loops
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dictionary."""
+        return {
+            "name": self.name,
+            "instance_id": self.instance_id,
+            "created_at": self.created_at.isoformat(),
+            "parent_id": self.parent_id,
+            "status": self.status,
+            "depth": self.depth,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AgentInstance":
+        """Deserialize from dictionary."""
+        created_at = data["created_at"]
+        if isinstance(created_at, str):
+            # Handle both aware and naive datetime strings
+            if created_at.endswith("Z"):
+                created_at = created_at[:-1] + "+00:00"
+            created_at = datetime.fromisoformat(created_at)
+
+        return cls(
+            name=data["name"],
+            instance_id=data["instance_id"],
+            created_at=created_at,
+            parent_id=data.get("parent_id"),
+            status=data.get("status", "active"),
+            depth=data.get("depth", 0),
+        )
+
+
+class AgentRegistry:
+    """
+    Manages agent instances and their relationships.
+
+    Enables agents to spawn and communicate with sub-agents while
+    tracking the hierarchy for debugging and resource management.
+    """
+
+    # Maximum delegation depth to prevent infinite loops
+    MAX_DEPTH = 5
+
+    def __init__(self, base_dir: Path | None = None):
+        """
+        Initialize the registry.
+
+        Args:
+            base_dir: Base directory for storing registry data.
+                      Defaults to ~/.supyagent/
+        """
+        if base_dir is None:
+            base_dir = Path.home() / ".supyagent"
+
+        self.base_dir = Path(base_dir)
+        self.registry_path = self.base_dir / "registry.json"
+
+        self._instances: dict[str, AgentInstance] = {}
+        self._agents: dict[str, "Agent"] = {}  # Live agent objects
+
+        self._load()
+
+    def _load(self) -> None:
+        """Load registry from disk."""
+        if self.registry_path.exists():
+            try:
+                with open(self.registry_path) as f:
+                    data = json.load(f)
+                    for item in data.get("instances", []):
+                        inst = AgentInstance.from_dict(item)
+                        self._instances[inst.instance_id] = inst
+            except (json.JSONDecodeError, KeyError):
+                # Corrupted registry, start fresh
+                self._instances = {}
+
+    def _save(self) -> None:
+        """Persist registry to disk."""
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+
+        with open(self.registry_path, "w") as f:
+            json.dump(
+                {
+                    "instances": [
+                        inst.to_dict()
+                        for inst in self._instances.values()
+                    ]
+                },
+                f,
+                indent=2,
+            )
+
+    def register(
+        self,
+        agent: "Agent",
+        parent_id: str | None = None,
+    ) -> str:
+        """
+        Register an agent instance and return its ID.
+
+        Args:
+            agent: The agent to register
+            parent_id: Instance ID of the parent agent (if any)
+
+        Returns:
+            The new instance ID
+
+        Raises:
+            ValueError: If max delegation depth would be exceeded
+        """
+        instance_id = str(uuid.uuid4())[:8]
+
+        # Calculate depth
+        depth = 0
+        if parent_id:
+            parent = self._instances.get(parent_id)
+            if parent:
+                depth = parent.depth + 1
+
+            if depth > self.MAX_DEPTH:
+                raise ValueError(
+                    f"Maximum delegation depth ({self.MAX_DEPTH}) exceeded. "
+                    "Cannot create more sub-agents."
+                )
+
+        instance = AgentInstance(
+            name=agent.config.name,
+            instance_id=instance_id,
+            created_at=datetime.now(UTC),
+            parent_id=parent_id,
+            depth=depth,
+        )
+
+        self._instances[instance_id] = instance
+        self._agents[instance_id] = agent
+        self._save()
+
+        return instance_id
+
+    def get_agent(self, instance_id: str) -> "Agent | None":
+        """Get a live agent by instance ID."""
+        return self._agents.get(instance_id)
+
+    def get_instance(self, instance_id: str) -> AgentInstance | None:
+        """Get instance metadata by ID."""
+        return self._instances.get(instance_id)
+
+    def list_all(self) -> list[AgentInstance]:
+        """List all registered instances."""
+        return list(self._instances.values())
+
+    def list_active(self) -> list[AgentInstance]:
+        """List all active instances."""
+        return [i for i in self._instances.values() if i.status == "active"]
+
+    def list_children(self, parent_id: str) -> list[AgentInstance]:
+        """List all agents spawned by a parent."""
+        return [i for i in self._instances.values() if i.parent_id == parent_id]
+
+    def mark_completed(self, instance_id: str) -> None:
+        """Mark an agent as completed."""
+        if instance_id in self._instances:
+            self._instances[instance_id].status = "completed"
+            self._save()
+
+    def mark_failed(self, instance_id: str) -> None:
+        """Mark an agent as failed."""
+        if instance_id in self._instances:
+            self._instances[instance_id].status = "failed"
+            self._save()
+
+    def cleanup(self, instance_id: str) -> None:
+        """Remove an agent instance."""
+        if instance_id in self._agents:
+            del self._agents[instance_id]
+
+        if instance_id in self._instances:
+            del self._instances[instance_id]
+            self._save()
+
+    def cleanup_completed(self) -> int:
+        """
+        Remove all completed/failed instances.
+
+        Returns:
+            Number of instances removed
+        """
+        to_remove = [
+            iid
+            for iid, inst in self._instances.items()
+            if inst.status in ("completed", "failed")
+        ]
+
+        for iid in to_remove:
+            self.cleanup(iid)
+
+        return len(to_remove)
+
+    def get_depth(self, instance_id: str) -> int:
+        """Get the delegation depth of an instance."""
+        inst = self._instances.get(instance_id)
+        return inst.depth if inst else 0