agentdeploy 0.1.1__py3-none-any.whl

agentdeploy/__init__.py

@@ -0,0 +1,32 @@
+"""
+AgentDeploy — zero-boilerplate deployment for AI agent frameworks.
+
+Wrap any LangGraph, CrewAI, OpenAI Agents SDK, or custom agent and
+generate production-ready Kubernetes manifests, Docker Compose files,
+Lambda handlers, or Cloud Run services.
+
+Public API:
+    AgentApp         — wrap and configure an agent
+    deploy           — start a deployment pipeline for an AgentApp
+    HITLGate         — human-in-the-loop checkpoint primitive
+    HITLDecision     — APPROVE / REJECT / MODIFY enum
+    CheckpointResult — result returned by a HITL checkpoint
+    Telemetry        — OpenTelemetry-backed agent tracing with cost tracking
+"""
+
+from agentdeploy.core.app import AgentApp
+from agentdeploy.core.deploy import deploy
+from agentdeploy.core.hitl import CheckpointResult, HITLDecision, HITLGate
+from agentdeploy.core.observability import Telemetry
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "AgentApp",
+    "deploy",
+    "HITLGate",
+    "HITLDecision",
+    "CheckpointResult",
+    "Telemetry",
+    "__version__",
+]

agentdeploy/adapters/__init__.py

@@ -0,0 +1,6 @@
+"""Framework adapters and the auto-detection registry."""
+
+from agentdeploy.adapters.base import AgentAdapter
+from agentdeploy.adapters.registry import AdapterRegistry
+
+__all__ = ["AgentAdapter", "AdapterRegistry"]

agentdeploy/adapters/base.py

@@ -0,0 +1,46 @@
+"""
+AgentAdapter — abstract base class for framework adapters.
+
+Each adapter knows how to:
+  - validate the wrapped agent object
+  - generate the entrypoint server code
+  - declare framework-specific dependencies
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class AgentAdapter(ABC):
+    """Base class for all framework adapters."""
+
+    framework_name: str = "unknown"
+
+    def __init__(self, agent: Any) -> None:
+        self.agent = agent
+        self.validate()
+
+    @abstractmethod
+    def validate(self) -> None:
+        """Raise ValueError if the wrapped object is not the expected type."""
+
+    @abstractmethod
+    def entrypoint_code(self, app_name: str, port: int) -> str:
+        """
+        Return a string of Python code that starts an HTTP server
+        exposing POST /invoke and GET /health for this agent.
+        This code is written into the container image as server.py.
+        """
+
+    @abstractmethod
+    def pip_extras(self) -> list[str]:
+        """
+        Return the pip package names required by this framework
+        (e.g. ['langgraph>=0.2', 'langchain-core']).
+        These are injected into the generated Dockerfile.
+        """
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(framework={self.framework_name!r})"

agentdeploy/adapters/registry.py

@@ -0,0 +1,221 @@
+"""
+Concrete framework adapters and AdapterRegistry.
+
+The registry inspects the wrapped object's type and module to
+automatically select the right adapter without the user having
+to specify the framework.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentdeploy.adapters.base import AgentAdapter
+
+
+class _LangGraphAdapter(AgentAdapter):
+    framework_name = "langgraph"
+
+    def validate(self) -> None:
+        cls_name = type(self.agent).__name__
+        if "CompiledGraph" not in cls_name and "CompiledStateGraph" not in cls_name:
+            raise ValueError(
+                f"Expected a LangGraph CompiledGraph, got {cls_name}. "
+                "Did you forget to call graph.compile()?"
+            )
+
+    def pip_extras(self) -> list[str]:
+        return ["langgraph>=0.2", "langchain-core>=0.2"]
+
+    def entrypoint_code(self, app_name: str, port: int) -> str:
+        return f"""
+import json, os
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import uvicorn
+from agent import graph  # imported from user's agent module
+
+server = FastAPI(title="{app_name}")
+
+@server.get("/health")
+async def health():
+    return {{"status": "ok", "framework": "langgraph"}}
+
+@server.post("/invoke")
+async def invoke(request: Request):
+    body = await request.json()
+    result = await graph.ainvoke(body.get("input", {{}}), config=body.get("config", {{}}))
+    return JSONResponse(result)
+
+if __name__ == "__main__":
+    uvicorn.run(server, host="0.0.0.0", port={port})
+"""
+
+
+class _CrewAIAdapter(AgentAdapter):
+    framework_name = "crewai"
+
+    def validate(self) -> None:
+        cls_name = type(self.agent).__name__
+        module = type(self.agent).__module__
+        if "crewai" not in module and cls_name != "Crew":
+            raise ValueError(f"Expected a CrewAI Crew object, got {cls_name} from {module}.")
+
+    def pip_extras(self) -> list[str]:
+        return ["crewai>=0.70"]
+
+    def entrypoint_code(self, app_name: str, port: int) -> str:
+        return f"""
+import os
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import uvicorn
+from agent import crew  # imported from user's agent module
+
+server = FastAPI(title="{app_name}")
+
+@server.get("/health")
+async def health():
+    return {{"status": "ok", "framework": "crewai"}}
+
+@server.post("/invoke")
+async def invoke(request: Request):
+    body = await request.json()
+    result = crew.kickoff(inputs=body.get("inputs", {{}}))
+    return JSONResponse({{"result": str(result)}})
+
+if __name__ == "__main__":
+    uvicorn.run(server, host="0.0.0.0", port={port})
+"""
+
+
+class _OpenAIAgentAdapter(AgentAdapter):
+    framework_name = "openai-agents"
+
+    # Modules that legitimately host the OpenAI Agents SDK Agent class.
+    _MODULE_PREFIXES = ("agents.", "openai.agents", "openai_agents")
+
+    def validate(self) -> None:
+        module = type(self.agent).__module__
+        cls_name = type(self.agent).__name__
+        # Be strict: match real module roots, not any module containing
+        # the substring "agents" (which would otherwise catch
+        # langchain.agents, llama_index.agent, etc.).
+        if not (module == "agents" or module.startswith(self._MODULE_PREFIXES)):
+            raise ValueError(
+                f"Expected an OpenAI Agents SDK Agent, got {cls_name} from "
+                f"module {module!r}. Install with `pip install openai-agents` "
+                "and pass the Agent instance to .wrap()."
+            )
+        if cls_name != "Agent":
+            raise ValueError(f"Expected an OpenAI Agents SDK Agent class, got {cls_name}.")
+
+    def pip_extras(self) -> list[str]:
+        return ["openai>=1.50", "openai-agents>=0.1"]
+
+    def entrypoint_code(self, app_name: str, port: int) -> str:
+        return f"""
+import os
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from agents import Runner
+import uvicorn
+from agent import agent  # imported from user's agent module
+
+server = FastAPI(title="{app_name}")
+
+@server.get("/health")
+async def health():
+    return {{"status": "ok", "framework": "openai-agents"}}
+
+@server.post("/invoke")
+async def invoke(request: Request):
+    body = await request.json()
+    result = await Runner.run(agent, input=body.get("input", ""))
+    return JSONResponse({{"result": result.final_output}})
+
+if __name__ == "__main__":
+    uvicorn.run(server, host="0.0.0.0", port={port})
+"""
+
+
+class _CallableAdapter(AgentAdapter):
+    """Fallback: any async callable is treated as a BYOF agent."""
+
+    framework_name = "callable"
+
+    def validate(self) -> None:
+        if not callable(self.agent):
+            raise ValueError(f"Expected a callable agent, got {type(self.agent).__name__}.")
+
+    def pip_extras(self) -> list[str]:
+        return []
+
+    def entrypoint_code(self, app_name: str, port: int) -> str:
+        return f"""
+import os
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import uvicorn
+from agent import agent  # your callable
+
+server = FastAPI(title="{app_name}")
+
+@server.get("/health")
+async def health():
+    return {{"status": "ok", "framework": "callable"}}
+
+@server.post("/invoke")
+async def invoke(request: Request):
+    body = await request.json()
+    result = await agent(body.get("input", {{}}))
+    return JSONResponse({{"result": result}})
+
+if __name__ == "__main__":
+    uvicorn.run(server, host="0.0.0.0", port={port})
+"""
+
+
+class AdapterRegistry:
+    """
+    Auto-detect the right adapter by inspecting the agent object's
+    type name and module path. Ordered from most-specific to most-general.
+    """
+
+    _registry: list[tuple[str, type[AgentAdapter]]] = [
+        ("langgraph", _LangGraphAdapter),
+        ("crewai", _CrewAIAdapter),
+        ("openai", _OpenAIAgentAdapter),
+        ("callable", _CallableAdapter),
+    ]
+
+    @classmethod
+    def detect(cls, agent: Any) -> AgentAdapter:
+        module = type(agent).__module__
+        cls_name = type(agent).__name__
+
+        # LangGraph (most specific)
+        if "langgraph" in module or "CompiledGraph" in cls_name or "CompiledStateGraph" in cls_name:
+            return _LangGraphAdapter(agent)
+        # CrewAI
+        if "crewai" in module or cls_name == "Crew":
+            return _CrewAIAdapter(agent)
+        # OpenAI Agents SDK — strict module-root match to avoid catching
+        # langchain.agents / llama_index.agent / etc.
+        if (
+            module == "agents" or module.startswith(_OpenAIAgentAdapter._MODULE_PREFIXES)
+        ) and cls_name == "Agent":
+            return _OpenAIAgentAdapter(agent)
+        # Fallback: any callable
+        if callable(agent):
+            return _CallableAdapter(agent)
+
+        raise ValueError(
+            f"Could not detect framework for {cls_name} from {module}. "
+            "Wrap it manually: app.wrap(agent, adapter=MyAdapter(agent))"
+        )
+
+    @classmethod
+    def register(cls, key: str, adapter_class: type[AgentAdapter]) -> None:
+        """Register a custom adapter for a new framework."""
+        cls._registry.insert(0, (key, adapter_class))

agentdeploy/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI entry point — exposes the `agentdeploy` Typer app."""
+
+from agentdeploy.cli.main import app
+
+__all__ = ["app"]

agentdeploy/cli/main.py

@@ -0,0 +1,266 @@
+"""
+AgentDeploy CLI — agentdeploy <command>
+
+Commands:
+  init      Scaffold a new agentdeploy project
+  validate  Check an AgentApp config without building
+  build     Run build() from a config file
+  version   Print the SDK version
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+app = typer.Typer(
+    name="agentdeploy",
+    help="Zero-boilerplate deployment for AI agent frameworks.",
+    add_completion=False,
+)
+console = Console()
+
+
+@app.command()
+def version():
+    """Print the installed AgentDeploy version."""
+    from agentdeploy import __version__
+
+    console.print(f"[bold]AgentDeploy[/bold] v{__version__}")
+
+
+@app.command()
+def init(
+    name: str = typer.Argument(..., help="Agent name (used as directory and K8s name)"),
+    framework: str = typer.Option(
+        "langgraph",
+        "--framework",
+        "-f",
+        help="Agent framework: langgraph | crewai | openai | callable",
+    ),
+    target: str = typer.Option(
+        "kubernetes",
+        "--target",
+        "-t",
+        help="Deploy target: kubernetes | docker-compose | lambda | cloud-run",
+    ),
+):
+    """Scaffold a new AgentDeploy project with example files."""
+    proj_dir = Path(name)
+    if proj_dir.exists():
+        console.print(f"[red]Directory '{name}' already exists.[/red]")
+        raise typer.Exit(1)
+
+    proj_dir.mkdir()
+    (proj_dir / "agent.py").write_text(_agent_stub(framework))
+    (proj_dir / "agentdeploy_config.py").write_text(_config_stub(name, framework, target))
+    (proj_dir / "requirements.txt").write_text(_requirements(framework))
+    (proj_dir / ".gitignore").write_text("deploy/\n__pycache__/\n.env\n*.pyc\n")
+    (proj_dir / ".env.example").write_text("OPENAI_API_KEY=\nANTHROPIC_API_KEY=\n")
+
+    console.print(
+        Panel(
+            f"[bold green]Project '{name}' created.[/bold green]\n\n"
+            f"  [dim]cd {name}[/dim]\n"
+            f"  [dim]# Edit agent.py with your {framework} agent[/dim]\n"
+            f"  [dim]# Edit agentdeploy_config.py to configure deployment[/dim]\n"
+            f"  [dim]agentdeploy build[/dim]",
+            title="agentdeploy init",
+        )
+    )
+
+
+@app.command()
+def validate(
+    config: str = typer.Option(
+        "agentdeploy_config.py",
+        "--config",
+        "-c",
+        help="Path to the agentdeploy config file",
+    ),
+):
+    """Validate an AgentApp configuration without generating files."""
+    cfg_path = Path(config)
+    if not cfg_path.exists():
+        console.print(f"[red]Config file not found: {config}[/red]")
+        raise typer.Exit(1)
+
+    try:
+        agent_app = _load_app_from_config(cfg_path)
+    except Exception as e:
+        console.print(f"[red]Config error:[/red] {e}")
+        raise typer.Exit(1) from e
+
+    table = Table(title="AgentApp validation", show_header=False)
+    table.add_column("Field", style="dim")
+    table.add_column("Value")
+    table.add_row("Name", agent_app.name)
+    table.add_row("Version", agent_app.version)
+    table.add_row(
+        "Framework", agent_app._adapter.framework_name if agent_app._adapter else "not wrapped"
+    )
+    table.add_row("Memory", f"{agent_app._memory_mb} MB")
+    table.add_row("Timeout", f"{agent_app._timeout_seconds}s")
+    table.add_row("Port", str(agent_app._port))
+    table.add_row("Secrets", ", ".join(agent_app._secrets) or "none")
+    console.print(table)
+    console.print("[green]Validation passed.[/green]")
+
+
+@app.command()
+def build(
+    config: str = typer.Option(
+        "agentdeploy_config.py",
+        "--config",
+        "-c",
+        help="Path to the agentdeploy config file",
+    ),
+    output: str = typer.Option(
+        "./deploy",
+        "--output",
+        "-o",
+        help="Output directory for generated artifacts",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Validate and show what would be generated without writing files",
+    ),
+):
+    """Generate deployment artifacts from an agentdeploy config."""
+    cfg_path = Path(config)
+    if not cfg_path.exists():
+        console.print(f"[red]Config file not found: {config}[/red]")
+        raise typer.Exit(1)
+
+    with console.status("[bold]Loading config...[/bold]"):
+        try:
+            agent_app = _load_app_from_config(cfg_path)
+        except Exception as e:
+            console.print(f"[red]Config load error:[/red] {e}")
+            raise typer.Exit(1) from e
+
+    console.print(f"[bold]Building[/bold] {agent_app}")
+
+    if dry_run:
+        console.print("[yellow]Dry run — no files written.[/yellow]")
+        return
+
+    try:
+        from agentdeploy.core.deploy import deploy as _deploy
+
+        result = _deploy(agent_app).to_kubernetes().with_output_dir(output).build()
+    except Exception as e:
+        console.print(f"[red]Build failed:[/red] {e}")
+        raise typer.Exit(1) from e
+
+    console.print(
+        Panel(
+            "\n".join(f"  [dim]{f}[/dim]" for f in result.files),
+            title=f"[green]Build complete[/green] — {result.output_dir}",
+        )
+    )
+    console.print("\n[bold]Next steps:[/bold]")
+    for step in result.next_steps:
+        console.print(f"  {step}")
+
+
+def _load_app_from_config(cfg_path: Path):
+    """
+    Import the config module and return the AgentApp it exports.
+    Expects the config file to expose `app = AgentApp(...).wrap(...)`.
+    """
+    spec = importlib.util.spec_from_file_location("agentdeploy_config", cfg_path)
+    module = importlib.util.module_from_spec(spec)
+    sys.path.insert(0, str(cfg_path.parent))
+    spec.loader.exec_module(module)
+    sys.path.pop(0)
+    if not hasattr(module, "app"):
+        raise AttributeError(
+            f"Config file '{cfg_path}' must define a top-level `app = AgentApp(...)` variable."
+        )
+    return module.app
+
+
+def _agent_stub(framework: str) -> str:
+    stubs = {
+        "langgraph": """from langgraph.graph import StateGraph, END
+from typing import TypedDict
+
+class State(TypedDict):
+    input: str
+    output: str
+
+def process(state: State) -> State:
+    # TODO: add your logic here
+    return {"output": f"processed: {state['input']}"}
+
+builder = StateGraph(State)
+builder.add_node("process", process)
+builder.set_entry_point("process")
+builder.add_edge("process", END)
+graph = builder.compile()
+""",
+        "crewai": """from crewai import Agent, Task, Crew
+
+researcher = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="Expert researcher with broad knowledge",
+)
+
+task = Task(
+    description="Research the topic: {topic}",
+    expected_output="A concise summary",
+    agent=researcher,
+)
+
+crew = Crew(agents=[researcher], tasks=[task])
+""",
+        "callable": """async def agent(input: dict) -> dict:
+    # TODO: implement your agent logic here
+    return {"result": f"processed: {input}"}
+""",
+    }
+    return stubs.get(framework, stubs["callable"])
+
+
+def _config_stub(name: str, framework: str, target: str) -> str:
+    agent_obj = {"langgraph": "graph", "crewai": "crew", "callable": "agent"}.get(
+        framework, "agent"
+    )
+    return f"""from agentdeploy import AgentApp, deploy
+from agent import {agent_obj}
+
+app = (
+    AgentApp("{name}", description="My {framework} agent")
+    .wrap({agent_obj})
+    .env("ANTHROPIC_API_KEY", from_secret="anthropic-key")
+    .resources(memory_mb=1024, timeout_seconds=120)
+)
+
+# Uncomment to run deployment programmatically:
+# result = deploy(app).to_{target.replace("-", "_")}().build()
+# print(result)
+"""
+
+
+def _requirements(framework: str) -> str:
+    base = "agentdeploy\nfastapi\nuvicorn\n"
+    extras = {
+        "langgraph": "langgraph>=0.2\nlangchain-core>=0.2\n",
+        "crewai": "crewai>=0.70\n",
+        "openai": "openai>=1.50\n",
+        "callable": "",
+    }
+    return base + extras.get(framework, "")
+
+
+if __name__ == "__main__":
+    app()

agentdeploy/core/__init__.py

@@ -0,0 +1 @@
+"""Core primitives: AgentApp, deploy(), HITLGate, Telemetry."""

agentdeploy/core/app.py

@@ -0,0 +1,104 @@
+"""
+AgentApp — wraps any agent framework into a deployable unit.
+
+Supports LangGraph, CrewAI, OpenAI Agents SDK, Claude SDK,
+and any custom callable agent (BYOF — Bring Your Own Framework).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from pydantic import BaseModel
+
+from agentdeploy.adapters.base import AgentAdapter
+from agentdeploy.adapters.registry import AdapterRegistry
+
+
+class AgentConfig(BaseModel):
+    name: str
+    description: str = ""
+    version: str = "0.1.0"
+    env_vars: dict[str, str] = {}
+    secrets: list[str] = []
+    memory_mb: int = 1024
+    timeout_seconds: int = 300
+
+
+@dataclass
+class AgentApp:
+    """
+    Entry point for AgentDeploy. Wrap your agent, configure it,
+    then call deploy() to generate deployment artifacts.
+
+    Usage:
+        app = AgentApp("my-agent", description="Summarisation crew")
+        app.wrap(my_langgraph_graph)
+        app.env("OPENAI_API_KEY", from_secret="openai-secret")
+    """
+
+    name: str
+    description: str = ""
+    version: str = "0.1.0"
+    _agent: Any = field(default=None, init=False, repr=False)
+    _adapter: AgentAdapter | None = field(default=None, init=False, repr=False)
+    _env: dict[str, str] = field(default_factory=dict, init=False)
+    _secrets: list[str] = field(default_factory=list, init=False)
+    _memory_mb: int = field(default=1024, init=False)
+    _timeout_seconds: int = field(default=300, init=False)
+    _health_path: str = field(default="/health", init=False)
+    _port: int = field(default=8080, init=False)
+
+    def wrap(self, agent: Any) -> AgentApp:
+        """
+        Detect the framework of `agent` automatically and wrap it.
+
+        Supported: LangGraph CompiledGraph, CrewAI Crew,
+                   OpenAI Agent, Anthropic Claude SDK agent,
+                   or any async callable (BYOF).
+        """
+        self._agent = agent
+        self._adapter = AdapterRegistry.detect(agent)
+        return self
+
+    def env(self, key: str, value: str = "", *, from_secret: str = "") -> AgentApp:
+        """Set an environment variable. Use from_secret for sensitive values."""
+        if from_secret:
+            self._secrets.append(from_secret)
+            self._env[key] = f"secret:{from_secret}"
+        else:
+            self._env[key] = value
+        return self
+
+    def resources(self, *, memory_mb: int = 1024, timeout_seconds: int = 300) -> AgentApp:
+        """Set resource limits for the container."""
+        self._memory_mb = memory_mb
+        self._timeout_seconds = timeout_seconds
+        return self
+
+    def port(self, port: int) -> AgentApp:
+        """Override the default HTTP port (default: 8080)."""
+        self._port = port
+        return self
+
+    def health_path(self, path: str) -> AgentApp:
+        """Override the default health check path (default: /health)."""
+        self._health_path = path
+        return self
+
+    def to_config(self) -> AgentConfig:
+        plain_env = {k: v for k, v in self._env.items() if not v.startswith("secret:")}
+        return AgentConfig(
+            name=self.name,
+            description=self.description,
+            version=self.version,
+            env_vars=plain_env,
+            secrets=self._secrets,
+            memory_mb=self._memory_mb,
+            timeout_seconds=self._timeout_seconds,
+        )
+
+    def __repr__(self) -> str:
+        framework = self._adapter.framework_name if self._adapter else "unwrapped"
+        return f"AgentApp(name={self.name!r}, framework={framework!r}, port={self._port})"