substrai-agentdeploy 0.1.0__tar.gz

substrai_agentdeploy-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,68 @@
+# 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/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "substrai-agentdeploy"
+version = "0.1.0"
+description = "Zero-to-production AI agent deployment framework"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [{name = "Gaurav Kumar Sinha", email = "gaurav@substrai.dev"}]
+keywords = ["ai-agent", "deployment", "serverless", "lambda", "llm", "multi-tenancy", "production"]
+dependencies = ["pyyaml>=6.0"]
+
+[project.optional-dependencies]
+aws = ["boto3>=1.28.0"]
+dev = ["pytest>=7.0"]
+
+[project.scripts]
+agentdeploy = "agentdeploy.cli.main:main"
+
+[project.urls]
+Homepage = "https://github.com/substrai/agentdeploy"
+Repository = "https://github.com/substrai/agentdeploy"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

substrai_agentdeploy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

substrai_agentdeploy-0.1.0/src/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",
+]

substrai_agentdeploy-0.1.0/src/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}"

substrai_agentdeploy-0.1.0/src/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

substrai_agentdeploy-0.1.0/src/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