agentdeploy 0.1.1__py3-none-any.whl

agentdeploy/targets/docker_compose.py

@@ -0,0 +1,145 @@
+"""
+DockerComposeTarget — generates docker-compose.yml for local development
+and staging. Includes the agent container, an optional Redis sidecar
+for inter-agent state, and an OTEL collector sidecar.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from agentdeploy.core.app import AgentApp
+
+
+@dataclass
+class DockerComposeTarget:
+    app: AgentApp
+    output_dir: str = "."
+    network: str = "agent-net"
+
+    _redis: bool = field(default=False, init=False)
+    _otel_collector: bool = field(default=False, init=False)
+    _extra_services: dict = field(default_factory=dict, init=False)
+
+    def with_redis(self) -> DockerComposeTarget:
+        """Add a Redis sidecar for shared agent state / queue."""
+        self._redis = True
+        return self
+
+    def with_otel_collector(self) -> DockerComposeTarget:
+        """Add an OpenTelemetry collector sidecar for local trace collection."""
+        self._otel_collector = True
+        return self
+
+    def with_service(self, name: str, definition: dict) -> DockerComposeTarget:
+        """Add an arbitrary extra service to the compose file."""
+        self._extra_services[name] = definition
+        return self
+
+    def build(self) -> DockerComposeResult:
+        cfg = self.app.to_config()
+        adapter = self.app._adapter
+        out = Path(self.output_dir) / cfg.name
+        out.mkdir(parents=True, exist_ok=True)
+
+        dockerfile = self._generate_dockerfile(cfg, adapter)
+        (out / "Dockerfile").write_text(dockerfile)
+
+        server_code = adapter.entrypoint_code(cfg.name, self.app._port)
+        (out / "server.py").write_text(server_code)
+
+        compose = self._compose_manifest(cfg)
+        compose_path = out / "docker-compose.yml"
+        compose_path.write_text(yaml.dump(compose, default_flow_style=False))
+
+        return DockerComposeResult(
+            app_name=cfg.name,
+            output_dir=str(out),
+            compose_path=str(compose_path),
+            next_steps=[
+                f"cd {out}",
+                "docker compose up --build",
+                f"curl http://localhost:{self.app._port}{self.app._health_path}",
+            ],
+        )
+
+    def _generate_dockerfile(self, cfg, adapter) -> str:
+        extras = adapter.pip_extras()
+        pip_install = " ".join(extras) if extras else ""
+        return f"""FROM python:3.11-slim
+WORKDIR /app
+RUN pip install --no-cache-dir fastapi uvicorn{(" " + pip_install) if pip_install else ""}
+COPY . .
+EXPOSE {self.app._port}
+CMD ["python", "server.py"]
+"""
+
+    def _compose_manifest(self, cfg) -> dict:
+        depends_on = []
+        services: dict = {}
+
+        agent_env = dict(cfg.env_vars)
+        if self._redis:
+            agent_env["REDIS_URL"] = "redis://redis:6379"
+            depends_on.append("redis")
+        if self._otel_collector:
+            agent_env["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://otel-collector:4317"
+            depends_on.append("otel-collector")
+
+        probe_url = f"http://localhost:{self.app._port}{self.app._health_path}"
+        # Stdlib urllib probe — no curl required, no apt-get layer in the image.
+        probe_script = (
+            "import urllib.request,sys; "
+            f"sys.exit(0 if urllib.request.urlopen('{probe_url}',timeout=5)"
+            ".status==200 else 1)"
+        )
+        agent_service: dict = {
+            "build": ".",
+            "ports": [f"{self.app._port}:{self.app._port}"],
+            "environment": agent_env,
+            "networks": [self.network],
+            "restart": "unless-stopped",
+            "healthcheck": {
+                "test": ["CMD", "python", "-c", probe_script],
+                "interval": "30s",
+                "timeout": "10s",
+                "retries": 3,
+            },
+        }
+        if depends_on:
+            agent_service["depends_on"] = depends_on
+
+        services[cfg.name] = agent_service
+
+        if self._redis:
+            services["redis"] = {
+                "image": "redis:7-alpine",
+                "networks": [self.network],
+                "restart": "unless-stopped",
+            }
+
+        if self._otel_collector:
+            services["otel-collector"] = {
+                "image": "otel/opentelemetry-collector-contrib:latest",
+                "networks": [self.network],
+                "ports": ["4317:4317", "4318:4318"],
+            }
+
+        services.update(self._extra_services)
+
+        return {
+            "version": "3.9",
+            "services": services,
+            "networks": {self.network: {"driver": "bridge"}},
+        }
+
+
+@dataclass
+class DockerComposeResult:
+    app_name: str
+    output_dir: str
+    compose_path: str
+    next_steps: list[str]

agentdeploy/targets/kubernetes.py

@@ -0,0 +1,344 @@
+"""
+KubernetesTarget — generates production-ready Kubernetes manifests
+and a Dockerfile from an AgentApp.
+
+Outputs:
+  ./deploy/<name>/Dockerfile
+  ./deploy/<name>/k8s/deployment.yaml
+  ./deploy/<name>/k8s/service.yaml
+  ./deploy/<name>/k8s/hpa.yaml
+  ./deploy/<name>/k8s/secret.yaml  (if secrets declared)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from agentdeploy.core.app import AgentApp
+from agentdeploy.core.hitl import HITLConfig
+from agentdeploy.core.observability import OtelConfig
+
+
+@dataclass
+class KubernetesTarget:
+    app: AgentApp
+    namespace: str = "default"
+    image: str = ""
+    registry: str = ""
+
+    _replicas: int = field(default=1, init=False)
+    _autoscale_min: int = field(default=1, init=False)
+    _autoscale_max: int = field(default=5, init=False)
+    _autoscale_cpu_pct: int = field(default=70, init=False)
+    _hitl: HITLConfig | None = field(default=None, init=False)
+    _otel: OtelConfig | None = field(default=None, init=False)
+    _output_dir: str = field(default="./deploy", init=False)
+    _python_version: str = field(default="3.11", init=False)
+    _base_image: str = field(default="python:3.11-slim", init=False)
+
+    def with_replicas(self, count: int) -> KubernetesTarget:
+        self._replicas = count
+        return self
+
+    def with_autoscale(
+        self,
+        *,
+        min: int = 1,
+        max: int = 10,
+        cpu_percent: int = 70,
+    ) -> KubernetesTarget:
+        self._autoscale_min = min
+        self._autoscale_max = max
+        self._autoscale_cpu_pct = cpu_percent
+        return self
+
+    def with_hitl_gate(
+        self,
+        *,
+        webhook: str = "",
+        slack_channel: str = "",
+        timeout_seconds: int = 3600,
+    ) -> KubernetesTarget:
+        self._hitl = HITLConfig(
+            webhook=webhook,
+            slack_channel=slack_channel,
+            timeout_seconds=timeout_seconds,
+        )
+        return self
+
+    def with_telemetry(
+        self,
+        *,
+        endpoint: str = "http://otel-collector:4317",
+        service_name: str = "",
+    ) -> KubernetesTarget:
+        self._otel = OtelConfig(
+            endpoint=endpoint,
+            service_name=service_name or self.app.name,
+        )
+        return self
+
+    def with_output_dir(self, path: str) -> KubernetesTarget:
+        self._output_dir = path
+        return self
+
+    def with_base_image(self, image: str) -> KubernetesTarget:
+        self._base_image = image
+        return self
+
+    def build(self) -> BuildResult:
+        """Generate all deployment artifacts and write them to disk."""
+        cfg = self.app.to_config()
+        adapter = self.app._adapter
+        out = Path(self._output_dir) / cfg.name
+        k8s_dir = out / "k8s"
+        out.mkdir(parents=True, exist_ok=True)
+        k8s_dir.mkdir(parents=True, exist_ok=True)
+
+        files: list[Path] = []
+
+        dockerfile = self._generate_dockerfile(cfg, adapter)
+        df_path = out / "Dockerfile"
+        df_path.write_text(dockerfile)
+        files.append(df_path)
+
+        server_code = adapter.entrypoint_code(cfg.name, self.app._port)
+        server_path = out / "server.py"
+        server_path.write_text(server_code)
+        files.append(server_path)
+
+        deploy_manifest = self._deployment_manifest(cfg)
+        dep_path = k8s_dir / "deployment.yaml"
+        dep_path.write_text(yaml.dump(deploy_manifest, default_flow_style=False))
+        files.append(dep_path)
+
+        svc_manifest = self._service_manifest(cfg)
+        svc_path = k8s_dir / "service.yaml"
+        svc_path.write_text(yaml.dump(svc_manifest, default_flow_style=False))
+        files.append(svc_path)
+
+        hpa_manifest = self._hpa_manifest(cfg)
+        hpa_path = k8s_dir / "hpa.yaml"
+        hpa_path.write_text(yaml.dump(hpa_manifest, default_flow_style=False))
+        files.append(hpa_path)
+
+        if cfg.secrets:
+            secret_manifest = self._secret_placeholder(cfg)
+            sec_path = k8s_dir / "secret.yaml"
+            sec_path.write_text(yaml.dump(secret_manifest, default_flow_style=False))
+            files.append(sec_path)
+
+        kustomization = self._kustomization(cfg)
+        kust_path = k8s_dir / "kustomization.yaml"
+        kust_path.write_text(yaml.dump(kustomization, default_flow_style=False))
+        files.append(kust_path)
+
+        return BuildResult(
+            app_name=cfg.name,
+            target="kubernetes",
+            output_dir=str(out),
+            files=[str(f) for f in files],
+            image=self.image,
+            namespace=self.namespace,
+            next_steps=self._next_steps(cfg),
+        )
+
+    def _generate_dockerfile(self, cfg, adapter) -> str:
+        extras = adapter.pip_extras()
+        pip_install = " ".join(extras) if extras else ""
+        env_lines = "\n".join(f'ENV {k}="{v}"' for k, v in cfg.env_vars.items())
+        # Healthcheck uses stdlib urllib so we don't need curl — keeps the
+        # image slim and avoids an apt-get layer + cache invalidation.
+        probe_url = f"http://localhost:{self.app._port}{self.app._health_path}"
+        healthcheck_probe = (
+            'python -c "import urllib.request,sys; '
+            f"sys.exit(0 if urllib.request.urlopen('{probe_url}',timeout=5)"
+            '.status==200 else 1)"'
+        )
+        return f"""FROM {self._base_image}
+
+WORKDIR /app
+
+COPY requirements.txt* ./
+RUN pip install --no-cache-dir fastapi uvicorn{(" " + pip_install) if pip_install else ""} \\
+    $(test -f requirements.txt && echo "-r requirements.txt" || echo "")
+
+COPY . .
+
+{env_lines}
+
+EXPOSE {self.app._port}
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \\
+    CMD {healthcheck_probe} || exit 1
+
+CMD ["python", "server.py"]
+"""
+
+    def _deployment_manifest(self, cfg) -> dict:
+        full_image = f"{self.registry}/{self.image}" if self.registry else self.image
+        env_vars = [{"name": k, "value": v} for k, v in cfg.env_vars.items()]
+        for secret_name in cfg.secrets:
+            env_vars.append(
+                {
+                    "name": secret_name.upper().replace("-", "_"),
+                    "valueFrom": {
+                        "secretKeyRef": {
+                            "name": f"{cfg.name}-secrets",
+                            "key": secret_name,
+                        }
+                    },
+                }
+            )
+        return {
+            "apiVersion": "apps/v1",
+            "kind": "Deployment",
+            "metadata": {
+                "name": cfg.name,
+                "namespace": self.namespace,
+                "labels": {"app": cfg.name, "version": cfg.version},
+            },
+            "spec": {
+                "replicas": self._replicas,
+                "selector": {"matchLabels": {"app": cfg.name}},
+                "template": {
+                    "metadata": {"labels": {"app": cfg.name, "version": cfg.version}},
+                    "spec": {
+                        "containers": [
+                            {
+                                "name": cfg.name,
+                                "image": full_image,
+                                "imagePullPolicy": "Always",
+                                "ports": [{"containerPort": self.app._port}],
+                                "env": env_vars,
+                                "resources": {
+                                    "requests": {
+                                        "memory": f"{cfg.memory_mb // 2}Mi",
+                                        "cpu": "250m",
+                                    },
+                                    "limits": {
+                                        "memory": f"{cfg.memory_mb}Mi",
+                                        "cpu": "1000m",
+                                    },
+                                },
+                                "livenessProbe": {
+                                    "httpGet": {
+                                        "path": self.app._health_path,
+                                        "port": self.app._port,
+                                    },
+                                    "initialDelaySeconds": 15,
+                                    "periodSeconds": 30,
+                                },
+                                "readinessProbe": {
+                                    "httpGet": {
+                                        "path": self.app._health_path,
+                                        "port": self.app._port,
+                                    },
+                                    "initialDelaySeconds": 5,
+                                    "periodSeconds": 10,
+                                },
+                            }
+                        ],
+                        "terminationGracePeriodSeconds": cfg.timeout_seconds,
+                    },
+                },
+            },
+        }
+
+    def _service_manifest(self, cfg) -> dict:
+        return {
+            "apiVersion": "v1",
+            "kind": "Service",
+            "metadata": {"name": cfg.name, "namespace": self.namespace},
+            "spec": {
+                "selector": {"app": cfg.name},
+                "ports": [{"port": 80, "targetPort": self.app._port, "protocol": "TCP"}],
+                "type": "ClusterIP",
+            },
+        }
+
+    def _hpa_manifest(self, cfg) -> dict:
+        return {
+            "apiVersion": "autoscaling/v2",
+            "kind": "HorizontalPodAutoscaler",
+            "metadata": {"name": f"{cfg.name}-hpa", "namespace": self.namespace},
+            "spec": {
+                "scaleTargetRef": {
+                    "apiVersion": "apps/v1",
+                    "kind": "Deployment",
+                    "name": cfg.name,
+                },
+                "minReplicas": self._autoscale_min,
+                "maxReplicas": self._autoscale_max,
+                "metrics": [
+                    {
+                        "type": "Resource",
+                        "resource": {
+                            "name": "cpu",
+                            "target": {
+                                "type": "Utilization",
+                                "averageUtilization": self._autoscale_cpu_pct,
+                            },
+                        },
+                    }
+                ],
+            },
+        }
+
+    def _secret_placeholder(self, cfg) -> dict:
+        return {
+            "apiVersion": "v1",
+            "kind": "Secret",
+            "metadata": {
+                "name": f"{cfg.name}-secrets",
+                "namespace": self.namespace,
+            },
+            "type": "Opaque",
+            "stringData": {s: f"<FILL_IN_{s.upper()}>" for s in cfg.secrets},
+        }
+
+    def _kustomization(self, cfg) -> dict:
+        resources = ["deployment.yaml", "service.yaml", "hpa.yaml"]
+        if cfg.secrets:
+            resources.append("secret.yaml")
+        return {
+            "apiVersion": "kustomize.config.k8s.io/v1beta1",
+            "kind": "Kustomization",
+            "resources": resources,
+        }
+
+    def _next_steps(self, cfg) -> list[str]:
+        full_image = f"{self.registry}/{self.image}" if self.registry else self.image
+        steps = [
+            f"1. docker build -t {full_image} ./deploy/{cfg.name}",
+            f"2. docker push {full_image}",
+            f"3. kubectl apply -k ./deploy/{cfg.name}/k8s/",
+            f"4. kubectl rollout status deployment/{cfg.name} -n {self.namespace}",
+        ]
+        if cfg.secrets:
+            steps.insert(2, f"   (fill in ./deploy/{cfg.name}/k8s/secret.yaml before applying)")
+        return steps
+
+
+@dataclass
+class BuildResult:
+    app_name: str
+    target: str
+    output_dir: str
+    files: list[str]
+    image: str
+    namespace: str
+    next_steps: list[str]
+
+    def __repr__(self) -> str:
+        files_str = "\n  ".join(self.files)
+        steps_str = "\n  ".join(self.next_steps)
+        return (
+            f"\nBuildResult for '{self.app_name}' -> {self.target}\n"
+            f"Output: {self.output_dir}\n"
+            f"Files:\n  {files_str}\n"
+            f"Next steps:\n  {steps_str}\n"
+        )

agentdeploy/targets/lambda_target.py

@@ -0,0 +1,160 @@
+"""
+LambdaTarget — generates a Lambda-compatible handler + SAM template.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from agentdeploy.core.app import AgentApp
+
+
+@dataclass
+class LambdaTarget:
+    app: AgentApp
+    region: str = "us-east-1"
+    function_name: str = ""
+    role_arn: str = ""
+
+    _memory_mb: int = field(default=0, init=False)
+    _timeout_seconds: int = field(default=0, init=False)
+    _output_dir: str = field(default="./deploy", init=False)
+
+    def with_output_dir(self, path: str) -> LambdaTarget:
+        self._output_dir = path
+        return self
+
+    def build(self) -> LambdaResult:
+        # Fail fast at build time rather than shipping a placeholder ARN that
+        # turns into an obscure AWS deploy failure later.
+        if not self.role_arn:
+            raise ValueError(
+                "LambdaTarget requires an IAM role ARN. Pass it via "
+                "deploy(app).to_lambda(role_arn='arn:aws:iam::ACCOUNT:role/...'). "
+                "The role must allow lambda.amazonaws.com to assume it and "
+                "include AWSLambdaBasicExecutionRole at minimum."
+            )
+        if not self.role_arn.startswith("arn:aws:iam::"):
+            raise ValueError(
+                f"role_arn must be a full IAM role ARN starting with "
+                f"'arn:aws:iam::ACCOUNT:role/...', got: {self.role_arn!r}"
+            )
+
+        cfg = self.app.to_config()
+        adapter = self.app._adapter
+        mem = self._memory_mb or cfg.memory_mb
+        timeout = self._timeout_seconds or min(cfg.timeout_seconds, 900)
+
+        out = Path(self._output_dir) / cfg.name
+        out.mkdir(parents=True, exist_ok=True)
+
+        handler_code = self._handler_code(cfg, adapter)
+        (out / "handler.py").write_text(handler_code)
+
+        sam = self._sam_template(cfg, mem, timeout)
+        sam_path = out / "template.yaml"
+        sam_path.write_text(yaml.dump(sam, default_flow_style=False))
+
+        dockerfile = self._dockerfile(cfg, adapter)
+        (out / "Dockerfile").write_text(dockerfile)
+
+        return LambdaResult(
+            app_name=cfg.name,
+            output_dir=str(out),
+            next_steps=[
+                f"cd {out}",
+                "sam build",
+                f"sam deploy --region {self.region} --stack-name {self.function_name}",
+            ],
+        )
+
+    def _handler_code(self, cfg, adapter) -> str:
+        extras = adapter.pip_extras()
+        return f"""
+import json, os, asyncio
+
+# Framework imports injected by adapter: {", ".join(extras)}
+from agent import agent  # your agent module
+
+def handler(event, context):
+    \"\"\"AWS Lambda entrypoint. Accepts API Gateway or direct invocation.\"\"\"
+    body = event.get("body", event)
+    if isinstance(body, str):
+        body = json.loads(body)
+
+    user_input = body.get("input", body)
+
+    try:
+        result = asyncio.run(_invoke(user_input))
+        return {{
+            "statusCode": 200,
+            "headers": {{"Content-Type": "application/json"}},
+            "body": json.dumps({{"result": result}}),
+        }}
+    except Exception as e:
+        return {{
+            "statusCode": 500,
+            "body": json.dumps({{"error": str(e)}}),
+        }}
+
+async def _invoke(user_input):
+    if hasattr(agent, "ainvoke"):
+        return await agent.ainvoke(user_input)
+    elif hasattr(agent, "kickoff"):
+        return str(agent.kickoff(inputs=user_input))
+    elif callable(agent):
+        result = agent(user_input)
+        if asyncio.iscoroutine(result):
+            return await result
+        return result
+    raise RuntimeError("Agent has no invocable method.")
+"""
+
+    def _sam_template(self, cfg, mem: int, timeout: int) -> dict:
+        env = {k: v for k, v in cfg.env_vars.items()}
+        return {
+            "AWSTemplateFormatVersion": "2010-09-09",
+            "Transform": "AWS::Serverless-2016-10-31",
+            "Description": cfg.description or cfg.name,
+            "Resources": {
+                cfg.name.replace("-", ""): {
+                    "Type": "AWS::Serverless::Function",
+                    "Properties": {
+                        "FunctionName": self.function_name or cfg.name,
+                        "Handler": "handler.handler",
+                        "Runtime": "python3.11",
+                        "MemorySize": mem,
+                        "Timeout": timeout,
+                        "Role": self.role_arn,
+                        "Environment": {"Variables": env},
+                        "Events": {
+                            "Api": {
+                                "Type": "Api",
+                                "Properties": {
+                                    "Path": "/invoke",
+                                    "Method": "post",
+                                },
+                            }
+                        },
+                    },
+                }
+            },
+        }
+
+    def _dockerfile(self, cfg, adapter) -> str:
+        extras = " ".join(adapter.pip_extras())
+        return f"""FROM public.ecr.aws/lambda/python:3.11
+RUN pip install --no-cache-dir {extras or ""}
+COPY . ${{LAMBDA_TASK_ROOT}}
+CMD ["handler.handler"]
+"""
+
+
+@dataclass
+class LambdaResult:
+    app_name: str
+    output_dir: str
+    next_steps: list[str]