substrai-agentdeploy 0.1.0__py3-none-any.whl

agentdeploy/__init__.py

@@ -0,0 +1,38 @@
+"""
+AgentDeploy - Zero-to-Production AI Agent Deployment Framework
+
+Takes any agent definition (LangChain, CrewAI, custom) and deploys it
+as a production-grade serverless API with auth, scaling, monitoring,
+cost controls, multi-tenancy, and session management.
+
+Usage:
+    from agentdeploy import agent, Tool, Session
+
+    @agent(name="my-agent", model="bedrock/claude-3-sonnet")
+    def my_agent(message: str, session: Session) -> str:
+        return "Hello!"
+"""
+
+__version__ = "0.1.0"
+
+from agentdeploy.core.agent import agent, AgentConfig
+from agentdeploy.core.runtime import AgentRuntime, InvocationResult
+from agentdeploy.session.manager import Session, SessionManager
+from agentdeploy.tools.registry import Tool, ToolRegistry, ToolPermission
+from agentdeploy.adapters.base import BaseAdapter
+from agentdeploy.cost.enforcer import CostEnforcer, CostBudget
+
+__all__ = [
+    "agent",
+    "AgentConfig",
+    "AgentRuntime",
+    "InvocationResult",
+    "Session",
+    "SessionManager",
+    "Tool",
+    "ToolRegistry",
+    "ToolPermission",
+    "BaseAdapter",
+    "CostEnforcer",
+    "CostBudget",
+]

agentdeploy/adapters/base.py

@@ -0,0 +1,60 @@
+"""Base adapter interface for agent frameworks."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from agentdeploy.session.manager import Session
+
+
+class BaseAdapter(ABC):
+    """Base class for agent framework adapters.
+
+    Implement this to support any agent framework (LangChain, CrewAI, etc.)
+    """
+
+    name: str = "base"
+
+    @abstractmethod
+    def invoke(self, message: str, session: Session, **kwargs) -> str:
+        """Invoke the agent with a message.
+
+        Args:
+            message: User message
+            session: Current session with history
+
+        Returns:
+            Agent response string
+        """
+        pass
+
+    def get_tool_calls(self) -> list:
+        """Get tool calls made during last invocation."""
+        return []
+
+    def get_token_usage(self) -> Dict[str, int]:
+        """Get token usage from last invocation."""
+        return {"input_tokens": 0, "output_tokens": 0}
+
+
+class CustomAdapter(BaseAdapter):
+    """Adapter for custom agent functions (default)."""
+
+    name = "custom"
+
+    def __init__(self, agent_fn):
+        self.agent_fn = agent_fn
+
+    def invoke(self, message: str, session: Session, **kwargs) -> str:
+        result = self.agent_fn(message, session)
+        return str(result) if result else ""
+
+
+class EchoAdapter(BaseAdapter):
+    """Simple echo adapter for testing."""
+
+    name = "echo"
+
+    def invoke(self, message: str, session: Session, **kwargs) -> str:
+        return f"Echo: {message}"

agentdeploy/core/agent.py

@@ -0,0 +1,109 @@
+"""Agent decorator and configuration.
+
+The @agent decorator turns a Python function into a deployable agent
+with session management, tool access, and cost tracking.
+"""
+
+from __future__ import annotations
+
+import functools
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for a deployed agent."""
+
+    name: str
+    model: str = "bedrock/claude-3-sonnet"
+    system_prompt: str = "You are a helpful assistant."
+    tools: List[Any] = field(default_factory=list)
+    max_iterations: int = 10
+    timeout_seconds: int = 60
+    memory_strategy: str = "sliding_window"
+    memory_window_size: int = 20
+    memory_ttl_hours: int = 24
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "model": self.model,
+            "system_prompt": self.system_prompt[:50] + "..." if len(self.system_prompt) > 50 else self.system_prompt,
+            "tools": [getattr(t, "name", str(t)) for t in self.tools],
+            "max_iterations": self.max_iterations,
+            "timeout_seconds": self.timeout_seconds,
+            "memory_strategy": self.memory_strategy,
+        }
+
+
+class AgentFunction:
+    """Wrapper around a decorated agent function."""
+
+    def __init__(self, fn: Callable, config: AgentConfig):
+        self.fn = fn
+        self.config = config
+        self.name = config.name
+        functools.update_wrapper(self, fn)
+
+    def __call__(self, *args, **kwargs):
+        return self.fn(*args, **kwargs)
+
+    def invoke(self, message: str, session_id: Optional[str] = None) -> Dict[str, Any]:
+        """Invoke the agent with a message.
+
+        Args:
+            message: User message
+            session_id: Optional session ID for conversation continuity
+
+        Returns:
+            Dict with response and metadata
+        """
+        from agentdeploy.core.runtime import AgentRuntime
+        runtime = AgentRuntime(self.config)
+        return runtime.invoke(message, session_id=session_id, agent_fn=self.fn)
+
+    def __repr__(self) -> str:
+        return f"AgentFunction(name='{self.name}', model='{self.config.model}')"
+
+
+def agent(
+    name: str,
+    model: str = "bedrock/claude-3-sonnet",
+    system_prompt: str = "You are a helpful assistant.",
+    tools: Optional[List[Any]] = None,
+    max_iterations: int = 10,
+    timeout_seconds: int = 60,
+    memory_strategy: str = "sliding_window",
+    **kwargs,
+) -> Callable:
+    """Decorator to turn a function into a deployable agent.
+
+    Usage:
+        @agent(name="my-agent", model="bedrock/claude-3-sonnet", tools=[search_kb])
+        def my_agent(message: str, session: Session) -> str:
+            pass
+
+    Args:
+        name: Agent name (used for deployment and routing)
+        model: LLM model identifier
+        system_prompt: System prompt for the agent
+        tools: List of Tool-decorated functions
+        max_iterations: Max reasoning loops
+        timeout_seconds: Max execution time
+        memory_strategy: Session memory strategy
+    """
+    def decorator(fn: Callable) -> AgentFunction:
+        config = AgentConfig(
+            name=name,
+            model=model,
+            system_prompt=system_prompt,
+            tools=tools or [],
+            max_iterations=max_iterations,
+            timeout_seconds=timeout_seconds,
+            memory_strategy=memory_strategy,
+            metadata=kwargs,
+        )
+        return AgentFunction(fn, config)
+    return decorator

agentdeploy/core/runtime.py

@@ -0,0 +1,191 @@
+"""Agent runtime - handles the request lifecycle."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+from agentdeploy.core.agent import AgentConfig
+from agentdeploy.session.manager import Session, SessionManager
+from agentdeploy.tools.registry import ToolRegistry, ToolCallResult
+from agentdeploy.cost.enforcer import CostEnforcer, CostBudget
+
+
+@dataclass
+class InvocationResult:
+    """Result of an agent invocation."""
+
+    response: str
+    session_id: str
+    success: bool = True
+    latency_ms: float = 0.0
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cost: float = 0.0
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    turn_count: int = 0
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "response": self.response,
+            "session_id": self.session_id,
+            "success": self.success,
+            "latency_ms": self.latency_ms,
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "cost": self.cost,
+            "tool_calls": self.tool_calls,
+            "turn_count": self.turn_count,
+            "error": self.error,
+        }
+
+
+class AgentRuntime:
+    """Handles the full agent request lifecycle.
+
+    Request flow:
+    1. Load/create session
+    2. Check cost budget
+    3. Execute agent function
+    4. Track tool calls
+    5. Record cost
+    6. Save session
+    7. Return result with metadata
+
+    Usage:
+        runtime = AgentRuntime(config)
+        result = runtime.invoke("Hello!", session_id="sess-123")
+    """
+
+    def __init__(
+        self,
+        config: AgentConfig,
+        session_manager: Optional[SessionManager] = None,
+        tool_registry: Optional[ToolRegistry] = None,
+        cost_enforcer: Optional[CostEnforcer] = None,
+    ):
+        self.config = config
+        self.session_manager = session_manager or SessionManager(ttl_hours=config.memory_ttl_hours)
+        self.tool_registry = tool_registry or ToolRegistry()
+        self.cost_enforcer = cost_enforcer or CostEnforcer()
+        self._invocation_log: List[InvocationResult] = []
+
+        # Register tools
+        for tool in config.tools:
+            if hasattr(tool, "definition"):
+                self.tool_registry.register(tool)
+
+    def invoke(
+        self,
+        message: str,
+        session_id: Optional[str] = None,
+        tenant_id: str = "default",
+        agent_fn: Optional[Callable] = None,
+    ) -> InvocationResult:
+        """Invoke the agent with full lifecycle management.
+
+        Args:
+            message: User message
+            session_id: Optional session ID
+            tenant_id: Tenant making the request
+            agent_fn: Agent function to call
+
+        Returns:
+            InvocationResult with response and metadata
+        """
+        start_time = time.time()
+
+        # 1. Load/create session
+        session = self.session_manager.get_or_create(
+            session_id, self.config.name, tenant_id
+        )
+
+        # 2. Check cost budget
+        cost_check = self.cost_enforcer.check_request(
+            session_id=session.session_id, estimated_cost=0.01
+        )
+        if not cost_check.allowed:
+            return InvocationResult(
+                response="",
+                session_id=session.session_id,
+                success=False,
+                error=cost_check.message,
+                latency_ms=(time.time() - start_time) * 1000,
+            )
+
+        # 3. Add user message to session
+        session.add_message("user", message)
+
+        # 4. Execute agent
+        try:
+            if agent_fn:
+                response = agent_fn(message, session)
+                if response is None:
+                    # Default behavior: echo with context
+                    response = f"[{self.config.name}] Received: {message}"
+            else:
+                response = f"[{self.config.name}] Received: {message}"
+        except Exception as e:
+            return InvocationResult(
+                response="",
+                session_id=session.session_id,
+                success=False,
+                error=str(e),
+                latency_ms=(time.time() - start_time) * 1000,
+            )
+
+        # 5. Add assistant response to session
+        session.add_message("assistant", response)
+
+        # 6. Calculate cost (estimate)
+        input_tokens = len(message) // 4
+        output_tokens = len(response) // 4
+        cost = self._estimate_cost(input_tokens, output_tokens)
+
+        # 7. Record cost
+        session.total_tokens += input_tokens + output_tokens
+        session.total_cost += cost
+        self.cost_enforcer.record_cost(session.session_id, cost, input_tokens + output_tokens)
+
+        # 8. Save session
+        self.session_manager.save(session)
+
+        latency_ms = (time.time() - start_time) * 1000
+
+        result = InvocationResult(
+            response=response,
+            session_id=session.session_id,
+            success=True,
+            latency_ms=round(latency_ms, 2),
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cost=round(cost, 8),
+            tool_calls=[r.__dict__ for r in self.tool_registry.call_log[-5:]],
+            turn_count=session.turn_count,
+        )
+
+        self._invocation_log.append(result)
+        return result
+
+    def get_session(self, session_id: str) -> Optional[Session]:
+        """Get a session by ID."""
+        return self.session_manager.get(session_id)
+
+    @property
+    def invocation_history(self) -> List[InvocationResult]:
+        return self._invocation_log
+
+    def _estimate_cost(self, input_tokens: int, output_tokens: int) -> float:
+        """Estimate cost based on model."""
+        pricing = {
+            "bedrock/claude-3-haiku": (0.00025, 0.00125),
+            "bedrock/claude-3-sonnet": (0.003, 0.015),
+            "bedrock/claude-3-opus": (0.015, 0.075),
+            "openai/gpt-4o-mini": (0.00015, 0.0006),
+            "openai/gpt-4o": (0.005, 0.015),
+        }
+        input_price, output_price = pricing.get(self.config.model, (0.001, 0.002))
+        return (input_tokens / 1000) * input_price + (output_tokens / 1000) * output_price

agentdeploy/cost/enforcer.py

@@ -0,0 +1,173 @@
+"""Cost enforcement - circuit breakers and budget tracking."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class BudgetAction(Enum):
+    ALLOW = "allow"
+    BLOCK = "block"
+    DOWNGRADE = "downgrade"
+    ALERT = "alert"
+    KILL = "kill"
+
+
+@dataclass
+class CostBudget:
+    """Budget configuration for cost enforcement."""
+
+    max_cost_per_request: float = 0.50
+    max_cost_per_session: float = 5.00
+    daily_budget: float = 50.00
+    monthly_budget: float = 1000.00
+    on_exceed: str = "block"  # block | downgrade | alert | kill
+
+    def get_action(self) -> BudgetAction:
+        return BudgetAction(self.on_exceed)
+
+
+@dataclass
+class CostRecord:
+    """Tracks cost for a specific scope."""
+
+    scope: str  # "request", "session", "tenant", "global"
+    scope_id: str
+    total_cost: float = 0.0
+    request_count: int = 0
+    period_start: float = field(default_factory=time.time)
+
+
+@dataclass
+class CostCheckResult:
+    """Result of a cost enforcement check."""
+
+    allowed: bool
+    action: BudgetAction
+    current_cost: float
+    budget_limit: float
+    usage_percent: float
+    message: str
+    suggested_model: Optional[str] = None  # for downgrade action
+
+
+class CostEnforcer:
+    """Enforces cost budgets and circuit breakers.
+
+    Usage:
+        enforcer = CostEnforcer(budget)
+        check = enforcer.check_request(session_id="sess-1", estimated_cost=0.05)
+        if not check.allowed:
+            return error_response(check.message)
+        # ... execute agent ...
+        enforcer.record_cost(session_id="sess-1", cost=0.03)
+    """
+
+    def __init__(self, budget: Optional[CostBudget] = None):
+        self.budget = budget or CostBudget()
+        self._session_costs: Dict[str, CostRecord] = {}
+        self._daily_cost: CostRecord = CostRecord(scope="daily", scope_id="global")
+        self._request_log: List[Dict[str, Any]] = []
+
+    def check_request(
+        self, session_id: str, estimated_cost: float = 0.0, tenant_id: str = "default"
+    ) -> CostCheckResult:
+        """Check if a request is within budget.
+
+        Args:
+            session_id: Current session ID
+            estimated_cost: Estimated cost of this request
+            tenant_id: Tenant making the request
+
+        Returns:
+            CostCheckResult with allow/deny decision
+        """
+        # Check session budget
+        session_record = self._session_costs.get(session_id)
+        if session_record:
+            projected = session_record.total_cost + estimated_cost
+            if projected > self.budget.max_cost_per_session:
+                return CostCheckResult(
+                    allowed=False,
+                    action=self.budget.get_action(),
+                    current_cost=session_record.total_cost,
+                    budget_limit=self.budget.max_cost_per_session,
+                    usage_percent=session_record.total_cost / self.budget.max_cost_per_session,
+                    message=f"Session budget exceeded: ${session_record.total_cost:.4f} >= ${self.budget.max_cost_per_session}",
+                    suggested_model="bedrock/claude-3-haiku" if self.budget.on_exceed == "downgrade" else None,
+                )
+
+        # Check per-request budget
+        if estimated_cost > self.budget.max_cost_per_request:
+            return CostCheckResult(
+                allowed=False,
+                action=BudgetAction.BLOCK,
+                current_cost=estimated_cost,
+                budget_limit=self.budget.max_cost_per_request,
+                usage_percent=estimated_cost / self.budget.max_cost_per_request,
+                message=f"Request cost ${estimated_cost:.4f} exceeds per-request limit ${self.budget.max_cost_per_request}",
+            )
+
+        # Check daily budget
+        daily_projected = self._daily_cost.total_cost + estimated_cost
+        if daily_projected > self.budget.daily_budget:
+            return CostCheckResult(
+                allowed=False,
+                action=self.budget.get_action(),
+                current_cost=self._daily_cost.total_cost,
+                budget_limit=self.budget.daily_budget,
+                usage_percent=self._daily_cost.total_cost / self.budget.daily_budget,
+                message=f"Daily budget exceeded: ${self._daily_cost.total_cost:.2f} >= ${self.budget.daily_budget}",
+                suggested_model="bedrock/claude-3-haiku" if self.budget.on_exceed == "downgrade" else None,
+            )
+
+        # Allowed
+        usage_pct = self._daily_cost.total_cost / self.budget.daily_budget if self.budget.daily_budget > 0 else 0
+        return CostCheckResult(
+            allowed=True,
+            action=BudgetAction.ALLOW,
+            current_cost=self._daily_cost.total_cost,
+            budget_limit=self.budget.daily_budget,
+            usage_percent=usage_pct,
+            message="Within budget",
+        )
+
+    def record_cost(self, session_id: str, cost: float, tokens: int = 0) -> None:
+        """Record actual cost after execution."""
+        # Session cost
+        if session_id not in self._session_costs:
+            self._session_costs[session_id] = CostRecord(scope="session", scope_id=session_id)
+        self._session_costs[session_id].total_cost += cost
+        self._session_costs[session_id].request_count += 1
+
+        # Daily cost
+        self._daily_cost.total_cost += cost
+        self._daily_cost.request_count += 1
+
+        # Log
+        self._request_log.append({
+            "session_id": session_id,
+            "cost": cost,
+            "tokens": tokens,
+            "timestamp": time.time(),
+        })
+
+    def get_session_cost(self, session_id: str) -> float:
+        """Get total cost for a session."""
+        record = self._session_costs.get(session_id)
+        return record.total_cost if record else 0.0
+
+    def get_daily_cost(self) -> float:
+        """Get total daily cost."""
+        return self._daily_cost.total_cost
+
+    def get_daily_remaining(self) -> float:
+        """Get remaining daily budget."""
+        return max(self.budget.daily_budget - self._daily_cost.total_cost, 0)
+
+    def reset_daily(self) -> None:
+        """Reset daily cost counter."""
+        self._daily_cost = CostRecord(scope="daily", scope_id="global")

agentdeploy/session/manager.py

@@ -0,0 +1,154 @@
+"""Session management - conversation persistence."""
+
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class Message:
+    """A single message in a conversation."""
+
+    role: str  # "user", "assistant", "system", "tool"
+    content: str
+    timestamp: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    tool_call_id: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"role": self.role, "content": self.content, "timestamp": self.timestamp}
+
+
+@dataclass
+class Session:
+    """Agent conversation session with memory."""
+
+    session_id: str
+    agent_name: str
+    tenant_id: str = "default"
+    messages: List[Message] = field(default_factory=list)
+    created_at: float = field(default_factory=time.time)
+    last_active: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    total_tokens: int = 0
+    total_cost: float = 0.0
+    turn_count: int = 0
+
+    def add_message(self, role: str, content: str, **kwargs) -> None:
+        """Add a message to the session."""
+        self.messages.append(Message(role=role, content=content, **kwargs))
+        self.last_active = time.time()
+        if role in ("user", "assistant"):
+            self.turn_count += 1
+
+    def get_history(self, strategy: str = "full", window_size: int = 20) -> List[Message]:
+        """Get conversation history based on strategy.
+
+        Args:
+            strategy: "full", "sliding_window", "last_n"
+            window_size: Number of messages for sliding window
+
+        Returns:
+            List of messages
+        """
+        if strategy == "full":
+            return list(self.messages)
+        elif strategy == "sliding_window":
+            return list(self.messages[-window_size:])
+        elif strategy == "last_n":
+            return list(self.messages[-window_size:])
+        return list(self.messages)
+
+    @property
+    def duration_seconds(self) -> float:
+        return self.last_active - self.created_at
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self.messages) == 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "session_id": self.session_id,
+            "agent_name": self.agent_name,
+            "tenant_id": self.tenant_id,
+            "turn_count": self.turn_count,
+            "total_tokens": self.total_tokens,
+            "total_cost": self.total_cost,
+            "created_at": self.created_at,
+            "last_active": self.last_active,
+            "message_count": len(self.messages),
+        }
+
+
+class SessionManager:
+    """Manages agent sessions (in-memory for local, DynamoDB for prod).
+
+    Usage:
+        manager = SessionManager()
+        session = manager.get_or_create("session-123", "my-agent")
+        session.add_message("user", "Hello!")
+        manager.save(session)
+    """
+
+    def __init__(self, ttl_hours: int = 24, max_sessions: int = 10000):
+        self._sessions: Dict[str, Session] = {}
+        self.ttl_seconds = ttl_hours * 3600
+        self.max_sessions = max_sessions
+
+    def get_or_create(
+        self, session_id: Optional[str], agent_name: str, tenant_id: str = "default"
+    ) -> Session:
+        """Get existing session or create new one."""
+        if session_id and session_id in self._sessions:
+            session = self._sessions[session_id]
+            session.last_active = time.time()
+            return session
+
+        # Create new session
+        sid = session_id or f"sess-{uuid.uuid4().hex[:12]}"
+        session = Session(session_id=sid, agent_name=agent_name, tenant_id=tenant_id)
+        self._sessions[sid] = session
+        self._cleanup()
+        return session
+
+    def get(self, session_id: str) -> Optional[Session]:
+        """Get a session by ID."""
+        return self._sessions.get(session_id)
+
+    def save(self, session: Session) -> None:
+        """Save/update a session."""
+        self._sessions[session.session_id] = session
+
+    def delete(self, session_id: str) -> bool:
+        """Delete a session."""
+        if session_id in self._sessions:
+            del self._sessions[session_id]
+            return True
+        return False
+
+    def list_sessions(
+        self, agent_name: Optional[str] = None, tenant_id: Optional[str] = None
+    ) -> List[Session]:
+        """List sessions with optional filters."""
+        sessions = list(self._sessions.values())
+        if agent_name:
+            sessions = [s for s in sessions if s.agent_name == agent_name]
+        if tenant_id:
+            sessions = [s for s in sessions if s.tenant_id == tenant_id]
+        return sorted(sessions, key=lambda s: s.last_active, reverse=True)
+
+    def get_active_count(self) -> int:
+        """Count active (non-expired) sessions."""
+        cutoff = time.time() - self.ttl_seconds
+        return sum(1 for s in self._sessions.values() if s.last_active > cutoff)
+
+    def _cleanup(self) -> None:
+        """Remove expired sessions."""
+        cutoff = time.time() - self.ttl_seconds
+        expired = [sid for sid, s in self._sessions.items() if s.last_active < cutoff]
+        for sid in expired:
+            del self._sessions[sid]

agentdeploy/tools/registry.py

@@ -0,0 +1,167 @@
+"""Tool registry and @Tool decorator."""
+
+from __future__ import annotations
+
+import functools
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
+
+
+class ToolPermission(Enum):
+    READ = "read"
+    WRITE = "write"
+    ADMIN = "admin"
+    EXECUTE = "execute"
+
+
+@dataclass
+class ToolDefinition:
+    """Metadata for a registered tool."""
+
+    name: str
+    description: str
+    fn: Callable
+    permissions: List[ToolPermission] = field(default_factory=lambda: [ToolPermission.READ])
+    timeout_seconds: int = 30
+    requires_approval: bool = False
+    version: str = "1.0.0"
+    parameters: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "permissions": [p.value for p in self.permissions],
+            "timeout_seconds": self.timeout_seconds,
+            "requires_approval": self.requires_approval,
+            "version": self.version,
+        }
+
+
+@dataclass
+class ToolCallResult:
+    """Result of a tool execution."""
+
+    tool_name: str
+    success: bool
+    output: Any = None
+    error: Optional[str] = None
+    latency_ms: float = 0.0
+    timestamp: float = field(default_factory=time.time)
+
+
+class ToolFunction:
+    """Wrapper around a Tool-decorated function."""
+
+    def __init__(self, fn: Callable, definition: ToolDefinition):
+        self.fn = fn
+        self.definition = definition
+        self.name = definition.name
+        self.description = definition.description
+        functools.update_wrapper(self, fn)
+
+    def __call__(self, *args, **kwargs) -> Any:
+        return self.fn(*args, **kwargs)
+
+    def execute(self, **kwargs) -> ToolCallResult:
+        """Execute the tool with tracking."""
+        start = time.time()
+        try:
+            output = self.fn(**kwargs)
+            return ToolCallResult(
+                tool_name=self.name,
+                success=True,
+                output=output,
+                latency_ms=(time.time() - start) * 1000,
+            )
+        except Exception as e:
+            return ToolCallResult(
+                tool_name=self.name,
+                success=False,
+                error=str(e),
+                latency_ms=(time.time() - start) * 1000,
+            )
+
+    def __repr__(self) -> str:
+        return f"Tool(name='{self.name}')"
+
+
+def Tool(
+    description: str = "",
+    permissions: Optional[List[ToolPermission]] = None,
+    timeout_seconds: int = 30,
+    requires_approval: bool = False,
+    version: str = "1.0.0",
+) -> Callable:
+    """Decorator to register a function as an agent tool.
+
+    Usage:
+        @Tool(description="Search the knowledge base")
+        def search_kb(query: str) -> list:
+            return results
+    """
+    def decorator(fn: Callable) -> ToolFunction:
+        definition = ToolDefinition(
+            name=fn.__name__,
+            description=description or fn.__doc__ or "",
+            fn=fn,
+            permissions=permissions or [ToolPermission.READ],
+            timeout_seconds=timeout_seconds,
+            requires_approval=requires_approval,
+            version=version,
+        )
+        return ToolFunction(fn, definition)
+    return decorator
+
+
+class ToolRegistry:
+    """Central registry of all available tools.
+
+    Usage:
+        registry = ToolRegistry()
+        registry.register(search_kb)
+        result = registry.execute("search_kb", query="hello")
+    """
+
+    def __init__(self):
+        self._tools: Dict[str, ToolFunction] = {}
+        self._call_log: List[ToolCallResult] = []
+
+    def register(self, tool: ToolFunction) -> None:
+        """Register a tool."""
+        self._tools[tool.name] = tool
+
+    def get(self, name: str) -> Optional[ToolFunction]:
+        """Get a tool by name."""
+        return self._tools.get(name)
+
+    def execute(self, name: str, **kwargs) -> ToolCallResult:
+        """Execute a tool by name."""
+        tool = self._tools.get(name)
+        if not tool:
+            return ToolCallResult(tool_name=name, success=False, error=f"Tool '{name}' not found")
+        result = tool.execute(**kwargs)
+        self._call_log.append(result)
+        return result
+
+    def list_tools(self) -> List[ToolDefinition]:
+        """List all registered tools."""
+        return [t.definition for t in self._tools.values()]
+
+    def is_allowed(self, tool_name: str, allowed_tools: Optional[List[str]] = None, denied_tools: Optional[List[str]] = None) -> bool:
+        """Check if a tool is allowed for a tenant."""
+        if denied_tools and tool_name in denied_tools:
+            return False
+        if allowed_tools and allowed_tools != ["all"] and tool_name not in allowed_tools:
+            return False
+        return True
+
+    @property
+    def call_log(self) -> List[ToolCallResult]:
+        return self._call_log
+
+    @property
+    def tool_count(self) -> int:
+        return len(self._tools)

substrai_agentdeploy-0.1.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: substrai-agentdeploy
+Version: 0.1.0
+Summary: Zero-to-production AI agent deployment framework
+Author-email: Gaurav Kumar Sinha <gaurav@substrai.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/substrai/agentdeploy
+Project-URL: Repository, https://github.com/substrai/agentdeploy
+Keywords: ai-agent,deployment,serverless,lambda,llm,multi-tenancy,production
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: aws
+Requires-Dist: boto3>=1.28.0; extra == "aws"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# AgentDeploy
+
+**Zero-to-production AI agent deployment framework.**
+
+> Built by [SubstrAI](https://github.com/substrai) — Open-source GenAI frameworks for serverless infrastructure.
+
+[![PyPI version](https://badge.fury.io/py/substrai-agentdeploy.svg)](https://pypi.org/project/substrai-agentdeploy/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## The Problem
+
+Building an AI agent is easy. Deploying it to production with auth, scaling, sessions, cost controls, and multi-tenancy takes weeks of custom infrastructure — every time.
+
+## The Solution
+
+```python
+from agentdeploy import agent, Tool, Session
+
+@Tool(description="Search knowledge base")
+def search_kb(query: str) -> list:
+    return ["result 1", "result 2"]
+
+@agent(name="support-agent", model="bedrock/claude-3-sonnet", tools=[search_kb])
+def support_agent(message: str, session: Session) -> str:
+    return f"I can help with: {message}"
+```
+
+```bash
+agentdeploy deploy --env prod
+# ✓ Deployed: https://xxx.execute-api.us-east-1.amazonaws.com/prod/agent
+```
+
+## Features
+
+- **@agent decorator** — turn any function into a deployable agent
+- **Session management** — DynamoDB-backed conversation persistence
+- **Tool sandboxing** — per-tenant tool permissions with audit trail
+- **Cost circuit breakers** — auto-kill runs exceeding budget
+- **Multi-tenancy** — tenant isolation, rate limiting, cost tracking
+- **One-command deploy** — API Gateway + Lambda + DynamoDB
+- **Provider agnostic** — works with Bedrock, OpenAI, Anthropic, custom
+- **Adapter interface** — supports LangChain, CrewAI, Strands, custom agents
+
+## Installation
+
+```bash
+pip install substrai-agentdeploy
+```
+
+## Quick Start
+
+```bash
+agentdeploy init my-agent
+cd my-agent
+agentdeploy dev    # local dev server
+agentdeploy deploy --env prod
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE)
+
+## Author
+
+**Gaurav Kumar Sinha** — Founder, [SubstrAI](https://github.com/substrai)
+
+- Email: gaurav@substrai.dev
+- GitHub: [@substrai](https://github.com/substrai)

substrai_agentdeploy-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+agentdeploy/__init__.py,sha256=POWK2oIAFpb_F_9lwJRnUTt6dY-fLYttjzEVA3y0S9E,1101
+agentdeploy/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/adapters/base.py,sha256=yc2f3JCUY1nltMHAQY3bUIci07_yv2uOrI0sTH1Gtz4,1528
+agentdeploy/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/core/agent.py,sha256=8q2sVjh5_MwnRM3BMwjr7pCgup19XuSXGkKals25LC8,3555
+agentdeploy/core/runtime.py,sha256=CSfFXrWwDUhmYS1RpwW3nyElYC8LGFhPH3zxmmEw7C4,6338
+agentdeploy/cost/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/cost/enforcer.py,sha256=YtZ5_af3R3RRir_8TUniNwXW0RU2yUDth2FfflfyUKU,6290
+agentdeploy/observability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/session/manager.py,sha256=_RtsrJAETId5KYuAffS3-WDetDXibZUC6BV6WCf7wo0,5279
+agentdeploy/tenants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentdeploy/tools/registry.py,sha256=xif2j7usBI-KKTBx-vYx2-eORmfFrRROXhZogVVoBWU,4977
+substrai_agentdeploy-0.1.0.dist-info/licenses/LICENSE,sha256=S-Ig-oAs_ELQwQdVSgfhQHgu00NMQ4O1E0dvgsQPBLI,830
+substrai_agentdeploy-0.1.0.dist-info/METADATA,sha256=obGMb6vkvP-CqAKJ2Ln4X6DIBIcmCFrNJ1xTGJkZ4e8,2734
+substrai_agentdeploy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+substrai_agentdeploy-0.1.0.dist-info/entry_points.txt,sha256=D7VNYorBu05d66GUwb66-VAP7AL-sw3TdstbOVEvJkc,58
+substrai_agentdeploy-0.1.0.dist-info/top_level.txt,sha256=EA5y-wqe22J2XIJ4XEuRKZXABVM1PVmmDzu0FIo14lU,12
+substrai_agentdeploy-0.1.0.dist-info/RECORD,,

substrai_agentdeploy-0.1.0.dist-info/WHEEL

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

substrai_agentdeploy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentdeploy = agentdeploy.cli.main:main

substrai_agentdeploy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2025 Gaurav Kumar Sinha (Substrai AI)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

substrai_agentdeploy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentdeploy