agentdeploy 0.1.1__tar.gz → 0.2.0__tar.gz

{agentdeploy-0.1.1 → agentdeploy-0.2.0}/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-07-29
+
+### Added
+- `KubernetesTarget.with_canary()` — progressive canary rollout support with
+  two strategies:
+  - `native`: two Deployments with disjoint `track` labels, traffic split by
+    replica ratio. No service mesh required.
+  - `istio`: exact percentage-based traffic splitting via `DestinationRule` +
+    `VirtualService`. Generates `destination-rule.yaml` and `virtual-service.yaml`.
+- `BuildResult.next_steps` now includes explicit promote and rollback commands
+  when a canary is configured.
+
 ## [0.1.1] - 2026-07-28
 
 ### Changed
@@ -42,6 +54,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Test suite covering core wrappers, Kubernetes target, Docker Compose
   target, HITL gate, and telemetry.
 
-[Unreleased]: https://github.com/erenat77/agentdeploy/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/erenat77/agentdeploy/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/erenat77/agentdeploy/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/erenat77/agentdeploy/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/erenat77/agentdeploy/releases/tag/v0.1.0

{agentdeploy-0.1.1 → agentdeploy-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentdeploy
-Version: 0.1.1
+Version: 0.2.0
 Summary: Zero-boilerplate deployment for AI agent frameworks — LangGraph, CrewAI, OpenAI Agents SDK, and custom agents
 Project-URL: Homepage, https://github.com/erenat77/agentdeploy
 Project-URL: Repository, https://github.com/erenat77/agentdeploy

{agentdeploy-0.1.1 → agentdeploy-0.2.0}/pyproject.toml

@@ -57,7 +57,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentdeploy"
-version = "0.1.1"
+version = "0.2.0"
 description = "Zero-boilerplate deployment for AI agent frameworks — LangGraph, CrewAI, OpenAI Agents SDK, and custom agents"
 readme = "README.md"
 requires-python = ">=3.11"

{agentdeploy-0.1.1 → agentdeploy-0.2.0}/src/agentdeploy/__init__.py

@@ -19,7 +19,7 @@ from agentdeploy.core.deploy import deploy
 from agentdeploy.core.hitl import CheckpointResult, HITLDecision, HITLGate
 from agentdeploy.core.observability import Telemetry
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"
 
 __all__ = [
     "AgentApp",

{agentdeploy-0.1.1 → agentdeploy-0.2.0}/src/agentdeploy/targets/kubernetes.py

@@ -2,26 +2,44 @@
 KubernetesTarget — generates production-ready Kubernetes manifests
 and a Dockerfile from an AgentApp.
 
-Outputs:
+Outputs (standard):
   ./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)
+  ./deploy/<name>/k8s/kustomization.yaml
+
+Outputs (canary, native strategy):
+  ./deploy/<name>/k8s/deployment-stable.yaml
+  ./deploy/<name>/k8s/deployment-canary.yaml
+  (+ service, hpa, kustomization as above)
+
+Outputs (canary, istio strategy):
+  (+ destination-rule.yaml, virtual-service.yaml)
 """
 
 from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Any
 
 import yaml
 
-from agentdeploy.core.app import AgentApp
+from agentdeploy.adapters.base import AgentAdapter
+from agentdeploy.core.app import AgentApp, AgentConfig
 from agentdeploy.core.hitl import HITLConfig
 from agentdeploy.core.observability import OtelConfig
 
 
+@dataclass
+class CanaryConfig:
+    stable_image: str
+    percent: int
+    strategy: str = "native"
+
+
 @dataclass
 class KubernetesTarget:
     app: AgentApp
@@ -38,6 +56,7 @@ class KubernetesTarget:
     _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)
+    _canary: CanaryConfig | None = field(default=None, init=False)
 
     def with_replicas(self, count: int) -> KubernetesTarget:
         self._replicas = count
@@ -89,51 +108,137 @@ class KubernetesTarget:
         self._base_image = image
         return self
 
+    def with_canary(
+        self,
+        *,
+        percent: int,
+        stable_image: str,
+        strategy: str = "native",
+    ) -> KubernetesTarget:
+        """Enable canary rollout for this deployment.
+
+        Args:
+            percent: Percentage of traffic (or replica share) to route to the
+                canary. Must be between 1 and 99 exclusive.
+            stable_image: The currently-running image that will serve stable
+                traffic. The new image (self.image) becomes the canary.
+            strategy: "native" (replica-ratio split, no service mesh) or
+                "istio" (exact weight split via VirtualService).
+        """
+        if not stable_image:
+            raise ValueError(
+                "stable_image is required — it is the currently-running image "
+                "that will continue to serve stable traffic."
+            )
+        if not isinstance(percent, (int, float)) or not (0 < int(percent) < 100):
+            raise ValueError(f"percent must be between 1 and 99 (exclusive), got {percent!r}.")
+        if strategy not in ("native", "istio"):
+            raise ValueError(f"strategy must be 'native' or 'istio', got {strategy!r}.")
+        self._canary = CanaryConfig(
+            stable_image=stable_image,
+            percent=int(percent),
+            strategy=strategy,
+        )
+        return self
+
     def build(self) -> BuildResult:
         """Generate all deployment artifacts and write them to disk."""
         cfg = self.app.to_config()
         adapter = self.app._adapter
+        assert adapter is not None, "AgentApp has no wrapped agent — call .wrap() first"
         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] = []
+        k8s_resources: list[str] = []
 
-        dockerfile = self._generate_dockerfile(cfg, adapter)
         df_path = out / "Dockerfile"
-        df_path.write_text(dockerfile)
+        df_path.write_text(self._generate_dockerfile(cfg, adapter))
         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)
+        server_path.write_text(adapter.entrypoint_code(cfg.name, self.app._port))
         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)
+        if self._canary:
+            canary_replicas = max(1, round(self._replicas * self._canary.percent / 100))
+            stable_replicas = max(1, self._replicas - canary_replicas)
+
+            stable_path = k8s_dir / "deployment-stable.yaml"
+            stable_path.write_text(
+                yaml.dump(
+                    self._build_deployment_dict(
+                        cfg,
+                        name=cfg.name,
+                        image=self._canary.stable_image,
+                        replicas=stable_replicas,
+                        track="stable",
+                    ),
+                    default_flow_style=False,
+                )
+            )
+            files.append(stable_path)
+            k8s_resources.append("deployment-stable.yaml")
+
+            canary_path = k8s_dir / "deployment-canary.yaml"
+            canary_path.write_text(
+                yaml.dump(
+                    self._build_deployment_dict(
+                        cfg,
+                        name=f"{cfg.name}-canary",
+                        image=self.image,
+                        replicas=canary_replicas,
+                        track="canary",
+                    ),
+                    default_flow_style=False,
+                )
+            )
+            files.append(canary_path)
+            k8s_resources.append("deployment-canary.yaml")
+
+            if self._canary.strategy == "istio":
+                dr_path = k8s_dir / "destination-rule.yaml"
+                dr_path.write_text(
+                    yaml.dump(self._istio_destination_rule(cfg), default_flow_style=False)
+                )
+                files.append(dr_path)
+
+                vs_path = k8s_dir / "virtual-service.yaml"
+                vs_path.write_text(
+                    yaml.dump(self._istio_virtual_service(cfg), default_flow_style=False)
+                )
+                files.append(vs_path)
+        else:
+            dep_path = k8s_dir / "deployment.yaml"
+            dep_path.write_text(yaml.dump(self._deployment_manifest(cfg), default_flow_style=False))
+            files.append(dep_path)
+            k8s_resources.append("deployment.yaml")
 
-        svc_manifest = self._service_manifest(cfg)
         svc_path = k8s_dir / "service.yaml"
-        svc_path.write_text(yaml.dump(svc_manifest, default_flow_style=False))
+        svc_path.write_text(yaml.dump(self._service_manifest(cfg), default_flow_style=False))
         files.append(svc_path)
+        k8s_resources.append("service.yaml")
 
-        hpa_manifest = self._hpa_manifest(cfg)
         hpa_path = k8s_dir / "hpa.yaml"
-        hpa_path.write_text(yaml.dump(hpa_manifest, default_flow_style=False))
+        hpa_path.write_text(yaml.dump(self._hpa_manifest(cfg), default_flow_style=False))
         files.append(hpa_path)
+        k8s_resources.append("hpa.yaml")
 
         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))
+            sec_path.write_text(yaml.dump(self._secret_placeholder(cfg), default_flow_style=False))
             files.append(sec_path)
+            k8s_resources.append("secret.yaml")
+
+        if self._canary and self._canary.strategy == "istio":
+            k8s_resources.extend(["destination-rule.yaml", "virtual-service.yaml"])
 
-        kustomization = self._kustomization(cfg)
         kust_path = k8s_dir / "kustomization.yaml"
-        kust_path.write_text(yaml.dump(kustomization, default_flow_style=False))
+        kust_path.write_text(
+            yaml.dump(self._kustomization(k8s_resources), default_flow_style=False)
+        )
         files.append(kust_path)
 
         return BuildResult(
@@ -146,7 +251,7 @@ class KubernetesTarget:
             next_steps=self._next_steps(cfg),
         )
 
-    def _generate_dockerfile(self, cfg, adapter) -> str:
+    def _generate_dockerfile(self, cfg: AgentConfig, adapter: AgentAdapter) -> 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())
@@ -178,9 +283,18 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \\
 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()]
+    def _build_deployment_dict(
+        self,
+        cfg: AgentConfig,
+        *,
+        name: str,
+        image: str,
+        replicas: int,
+        track: str | None = None,
+    ) -> dict[str, Any]:
+        """Core deployment manifest builder shared by standard and canary paths."""
+        full_image = f"{self.registry}/{image}" if self.registry else image
+        env_vars: list[dict[str, Any]] = [{"name": k, "value": v} for k, v in cfg.env_vars.items()]
         for secret_name in cfg.secrets:
             env_vars.append(
                 {
@@ -193,19 +307,26 @@ CMD ["python", "server.py"]
                     },
                 }
             )
+
+        pod_labels: dict[str, str] = {"app": cfg.name, "version": cfg.version}
+        selector_labels: dict[str, str] = {"app": cfg.name}
+        if track:
+            pod_labels["track"] = track
+            selector_labels["track"] = track
+
         return {
             "apiVersion": "apps/v1",
             "kind": "Deployment",
             "metadata": {
-                "name": cfg.name,
+                "name": name,
                 "namespace": self.namespace,
                 "labels": {"app": cfg.name, "version": cfg.version},
             },
             "spec": {
-                "replicas": self._replicas,
-                "selector": {"matchLabels": {"app": cfg.name}},
+                "replicas": replicas,
+                "selector": {"matchLabels": selector_labels},
                 "template": {
-                    "metadata": {"labels": {"app": cfg.name, "version": cfg.version}},
+                    "metadata": {"labels": pod_labels},
                     "spec": {
                         "containers": [
                             {
@@ -248,7 +369,12 @@ CMD ["python", "server.py"]
             },
         }
 
-    def _service_manifest(self, cfg) -> dict:
+    def _deployment_manifest(self, cfg: AgentConfig) -> dict[str, Any]:
+        return self._build_deployment_dict(
+            cfg, name=cfg.name, image=self.image, replicas=self._replicas
+        )
+
+    def _service_manifest(self, cfg: AgentConfig) -> dict[str, Any]:
         return {
             "apiVersion": "v1",
             "kind": "Service",
@@ -260,7 +386,7 @@ CMD ["python", "server.py"]
             },
         }
 
-    def _hpa_manifest(self, cfg) -> dict:
+    def _hpa_manifest(self, cfg: AgentConfig) -> dict[str, Any]:
         return {
             "apiVersion": "autoscaling/v2",
             "kind": "HorizontalPodAutoscaler",
@@ -288,7 +414,7 @@ CMD ["python", "server.py"]
             },
         }
 
-    def _secret_placeholder(self, cfg) -> dict:
+    def _secret_placeholder(self, cfg: AgentConfig) -> dict[str, Any]:
         return {
             "apiVersion": "v1",
             "kind": "Secret",
@@ -300,18 +426,80 @@ CMD ["python", "server.py"]
             "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")
+    def _kustomization(self, resources: list[str]) -> dict[str, Any]:
         return {
             "apiVersion": "kustomize.config.k8s.io/v1beta1",
             "kind": "Kustomization",
             "resources": resources,
         }
 
-    def _next_steps(self, cfg) -> list[str]:
+    def _istio_destination_rule(self, cfg: AgentConfig) -> dict[str, Any]:
+        return {
+            "apiVersion": "networking.istio.io/v1alpha1",
+            "kind": "DestinationRule",
+            "metadata": {"name": cfg.name, "namespace": self.namespace},
+            "spec": {
+                "host": cfg.name,
+                "subsets": [
+                    {"name": "stable", "labels": {"track": "stable"}},
+                    {"name": "canary", "labels": {"track": "canary"}},
+                ],
+            },
+        }
+
+    def _istio_virtual_service(self, cfg: AgentConfig) -> dict[str, Any]:
+        assert self._canary is not None
+        stable_weight = 100 - self._canary.percent
+        canary_weight = self._canary.percent
+        return {
+            "apiVersion": "networking.istio.io/v1alpha1",
+            "kind": "VirtualService",
+            "metadata": {"name": cfg.name, "namespace": self.namespace},
+            "spec": {
+                "hosts": [cfg.name],
+                "http": [
+                    {
+                        "route": [
+                            {
+                                "destination": {"host": cfg.name, "subset": "stable"},
+                                "weight": stable_weight,
+                            },
+                            {
+                                "destination": {"host": cfg.name, "subset": "canary"},
+                                "weight": canary_weight,
+                            },
+                        ]
+                    }
+                ],
+            },
+        }
+
+    def _next_steps(self, cfg: AgentConfig) -> list[str]:
         full_image = f"{self.registry}/{self.image}" if self.registry else self.image
+
+        if self._canary:
+            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}",
+                f"5. kubectl rollout status deployment/{cfg.name}-canary -n {self.namespace}",
+                f"6. # Monitor: kubectl get pods -l app={cfg.name},track=canary -n {self.namespace}",
+            ]
+            if self._canary.strategy == "istio":
+                steps += [
+                    f"7. # Promote: set canary weight to 100 in virtual-service.yaml → kubectl apply -k ./deploy/{cfg.name}/k8s/",
+                    f"8. # Rollback: set canary weight to 0 in virtual-service.yaml → kubectl apply -k ./deploy/{cfg.name}/k8s/",
+                ]
+            else:
+                steps += [
+                    f"7. # Promote: kubectl scale deployment/{cfg.name}-canary --replicas={self._replicas} -n {self.namespace} && kubectl delete deployment/{cfg.name} -n {self.namespace}",
+                    f"8. # Rollback: kubectl delete deployment/{cfg.name}-canary -n {self.namespace}",
+                ]
+            if cfg.secrets:
+                steps.insert(2, f"   (fill in ./deploy/{cfg.name}/k8s/secret.yaml before applying)")
+            return steps
+
         steps = [
             f"1. docker build -t {full_image} ./deploy/{cfg.name}",
             f"2. docker push {full_image}",

{agentdeploy-0.1.1 → agentdeploy-0.2.0}/tests/test_core.py

@@ -306,6 +306,136 @@ class TestAdapterDetection:
         assert adapter.framework_name == "openai-agents"
 
 
+class TestCanaryRollout:
+    def _make_app(self, name: str = "canary-agent"):
+        from agentdeploy import AgentApp
+
+        return AgentApp(name).wrap(_make_langgraph()).resources(memory_mb=1024)
+
+    def test_canary_generates_two_deployments_not_one(self, tmp_path):
+        from agentdeploy import deploy
+
+        (
+            deploy(self._make_app())
+            .to_kubernetes(image="my-agent:0.2.0")
+            .with_replicas(10)
+            .with_canary(percent=10, stable_image="my-agent:0.1.0")
+            .with_output_dir(str(tmp_path))
+            .build()
+        )
+        k8s = tmp_path / "canary-agent" / "k8s"
+        assert (k8s / "deployment-stable.yaml").exists()
+        assert (k8s / "deployment-canary.yaml").exists()
+        assert not (k8s / "deployment.yaml").exists()
+
+    def test_native_replica_split(self, tmp_path):
+        import yaml
+
+        from agentdeploy import deploy
+
+        (
+            deploy(self._make_app())
+            .to_kubernetes(image="my-agent:0.2.0")
+            .with_replicas(10)
+            .with_canary(percent=10, stable_image="my-agent:0.1.0")
+            .with_output_dir(str(tmp_path))
+            .build()
+        )
+        k8s = tmp_path / "canary-agent" / "k8s"
+        stable = yaml.safe_load((k8s / "deployment-stable.yaml").read_text())
+        canary = yaml.safe_load((k8s / "deployment-canary.yaml").read_text())
+        assert stable["spec"]["replicas"] == 9
+        assert canary["spec"]["replicas"] == 1
+
+    def test_deployment_selectors_are_disjoint_and_service_is_broad(self, tmp_path):
+        import yaml
+
+        from agentdeploy import deploy
+
+        (
+            deploy(self._make_app())
+            .to_kubernetes(image="my-agent:0.2.0")
+            .with_replicas(4)
+            .with_canary(percent=25, stable_image="my-agent:0.1.0")
+            .with_output_dir(str(tmp_path))
+            .build()
+        )
+        k8s = tmp_path / "canary-agent" / "k8s"
+        stable = yaml.safe_load((k8s / "deployment-stable.yaml").read_text())
+        canary = yaml.safe_load((k8s / "deployment-canary.yaml").read_text())
+        svc = yaml.safe_load((k8s / "service.yaml").read_text())
+        stable_sel = stable["spec"]["selector"]["matchLabels"]
+        canary_sel = canary["spec"]["selector"]["matchLabels"]
+        assert stable_sel != canary_sel
+        assert "track" in stable_sel
+        assert "track" in canary_sel
+        assert "track" not in svc["spec"]["selector"]
+
+    def test_istio_strategy_generates_mesh_files(self, tmp_path):
+        from agentdeploy import deploy
+
+        (
+            deploy(self._make_app())
+            .to_kubernetes(image="my-agent:0.2.0")
+            .with_replicas(4)
+            .with_canary(percent=20, stable_image="my-agent:0.1.0", strategy="istio")
+            .with_output_dir(str(tmp_path))
+            .build()
+        )
+        k8s = tmp_path / "canary-agent" / "k8s"
+        assert (k8s / "destination-rule.yaml").exists()
+        assert (k8s / "virtual-service.yaml").exists()
+
+    def test_native_strategy_does_not_generate_mesh_files(self, tmp_path):
+        from agentdeploy import deploy
+
+        (
+            deploy(self._make_app())
+            .to_kubernetes(image="my-agent:0.2.0")
+            .with_replicas(4)
+            .with_canary(percent=20, stable_image="my-agent:0.1.0", strategy="native")
+            .with_output_dir(str(tmp_path))
+            .build()
+        )
+        k8s = tmp_path / "canary-agent" / "k8s"
+        assert not (k8s / "destination-rule.yaml").exists()
+        assert not (k8s / "virtual-service.yaml").exists()
+
+    def test_with_canary_validation(self):
+        from agentdeploy import deploy
+
+        app = self._make_app()
+        with pytest.raises(ValueError, match="percent"):
+            deploy(app).to_kubernetes(image="img:new").with_canary(
+                percent=0, stable_image="img:old"
+            )
+        with pytest.raises(ValueError, match="percent"):
+            deploy(app).to_kubernetes(image="img:new").with_canary(
+                percent=100, stable_image="img:old"
+            )
+        with pytest.raises(ValueError, match="stable_image"):
+            deploy(app).to_kubernetes(image="img:new").with_canary(percent=10, stable_image="")
+        with pytest.raises(ValueError, match="strategy"):
+            deploy(app).to_kubernetes(image="img:new").with_canary(
+                percent=10, stable_image="img:old", strategy="linkerd"
+            )
+
+    def test_canary_next_steps_include_promote_and_rollback(self, tmp_path):
+        from agentdeploy import deploy
+
+        result = (
+            deploy(self._make_app())
+            .to_kubernetes(image="my-agent:0.2.0")
+            .with_replicas(10)
+            .with_canary(percent=10, stable_image="my-agent:0.1.0")
+            .with_output_dir(str(tmp_path))
+            .build()
+        )
+        steps_text = " ".join(result.next_steps).lower()
+        assert "promote" in steps_text
+        assert "rollback" in steps_text
+
+
 class TestHITLGate:
     @pytest.mark.asyncio
     async def test_console_approve(self, monkeypatch):