iac-code 0.13.0__tar.gz → 0.14.0__tar.gz

{iac_code-0.13.0 → iac_code-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.13.0
+Version: 0.14.0
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -14,12 +14,13 @@ Provides-Extra: a2a
 Provides-Extra: a2a-grpc
 Provides-Extra: a2a-redis
 Provides-Extra: a2a-signing
+Provides-Extra: agui
 Provides-Extra: diagram
 Provides-Extra: http
 License-File: LICENSE
 
 <p align="center">
-  <img src="website/static/img/logo-with-front.png" alt="iac-code" width="200">
+  <img src="https://raw.githubusercontent.com/aliyun/iac-code/main/website/static/img/logo-with-front.png" alt="iac-code" width="200">
 </p>
 <p align="center">
   <em>AI-powered Infrastructure as Code assistant for cloud infrastructure through natural language interaction. Currently supports Alibaba Cloud ROS and Terraform workflows.</em>
@@ -29,9 +30,6 @@ License-File: LICENSE
   <a href="https://pypi.org/project/iac-code"><img src="https://img.shields.io/pypi/v/iac-code?color=%2334D058&label=pypi%20package" alt="PyPI Package"></a>
   <a href="https://pypi.org/project/iac-code"><img src="https://img.shields.io/pypi/pyversions/iac-code?color=%2334D058&label=python" alt="Python"></a>
 </p>
-<p align="center">
-  <strong>Language</strong>: English | <a href="readme/README.zh.md">中文</a> | <a href="readme/README.es.md">Español</a> | <a href="readme/README.fr.md">Français</a> | <a href="readme/README.de.md">Deutsch</a> | <a href="readme/README.ja.md">日本語</a> | <a href="readme/README.pt.md">Português</a>
-</p>
 
 > **Documentation**: [https://aliyun.github.io/iac-code/](https://aliyun.github.io/iac-code/)
 
@@ -56,7 +54,7 @@ No Python, pip, or terminal setup required — download the native app and start
 The Desktop app runs the same IaC Code engine and uses the same providers, cloud credentials, settings, projects, and sessions as the CLI and Web app. On first launch, select the project directory you want IaC Code to work in. Windows also checks for Git Bash and guides you through installation if it is missing.
 
 <p align="center">
-  <img src="website/static/img/screenshots/iac-code-desktop-en.jpg" alt="IaC Code Desktop app" width="100%">
+  <img src="https://raw.githubusercontent.com/aliyun/iac-code/main/website/static/img/screenshots/iac-code-desktop-en.jpg" alt="IaC Code Desktop app" width="100%">
 </p>
 
 macOS, Windows, and AppImage builds can check for and apply cryptographically signed updates in the app. The deb package is updated by installing a newer package. Stable macOS packages are signed with Apple Developer ID and notarized by Apple; stable Windows packages carry an Authenticode publisher signature. Always download from the official release page and verify the accompanying `SHA256SUMS`. See the [Desktop App guide](https://aliyun.github.io/iac-code/docs/desktop-app) for installation and troubleshooting details.
@@ -84,7 +82,7 @@ iac-code
 ```
 
 <p align="center">
-  <img src="website/static/img/demo_en.gif" alt="iac-code demo" width="100%">
+  <img src="https://raw.githubusercontent.com/aliyun/iac-code/main/website/static/img/demo_en.gif" alt="iac-code demo" width="100%">
 </p>
 
 ### Non-Interactive Mode
@@ -113,7 +111,7 @@ iac-code web
 By default it opens `http://127.0.0.1:8766` in your browser (loopback only). See the [Web App guide](https://aliyun.github.io/iac-code/web-app) for details.
 
 <p align="center">
-  <img src="website/static/img/screenshots/iac-code-web-en.jpg" alt="IaC Code Web app" width="100%">
+  <img src="https://raw.githubusercontent.com/aliyun/iac-code/main/website/static/img/screenshots/iac-code-web-en.jpg" alt="IaC Code Web app" width="100%">
 </p>
 
 ## Contributing
@@ -134,4 +132,4 @@ See the [Contributing Guide](https://aliyun.github.io/iac-code/getting-started/c
 
 | [DingTalk](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [Discord](https://discord.gg/qECFuFBwF) |
 | :----------------------------------------------------------: | :----------------------------------------------------------: |
-| [<img src="website/static/img/qrcode-dingtalk.jpg" width="120" height="120" alt="DingTalk">](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [<img src="website/static/img/qrcode-discord.jpg" width="120" height="120" alt="Discord">](https://discord.gg/qECFuFBwF) |
+| [<img src="https://raw.githubusercontent.com/aliyun/iac-code/main/website/static/img/qrcode-dingtalk.jpg" width="120" height="120" alt="DingTalk">](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [<img src="https://raw.githubusercontent.com/aliyun/iac-code/main/website/static/img/qrcode-discord.jpg" width="120" height="120" alt="Discord">](https://discord.gg/qECFuFBwF) |

{iac_code-0.13.0 → iac_code-0.14.0}/pyproject.toml

@@ -1,8 +1,7 @@
 [project]
 name = "iac_code"
-dynamic = ["version"]
+dynamic = ["version", "readme"]
 description = "Your AI-powered Infrastructure as Code assistant"
-readme = "README.md"
 requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -75,6 +74,12 @@ a2a-grpc = [
 a2a-redis = [
     "redis>=5.0.0",
 ]
+agui = [
+    "ag-ui-protocol==0.1.20",
+    "a2a-sdk[http-server,signing]>=1.0.2,<2",
+    "starlette>=0.39.0",
+    "uvicorn[standard]>=0.30.0",
+]
 diagram = ["termaid>=0.1; python_version >= '3.11'"]
 
 [dependency-groups]
@@ -147,6 +152,9 @@ default = true
 
 [tool.pytest.ini_options]
 timeout = 30
+markers = [
+    "integration: process-level integration tests that use local services only",
+]
 
 [tool.coverage.run]
 source_pkgs = ["iac_code"]

{iac_code-0.13.0 → iac_code-0.14.0}/setup.py

@@ -1,5 +1,6 @@
 """Custom build hook to inject __release_date__ at build time."""
 
+import os
 import platform
 import re
 import shutil
@@ -99,7 +100,19 @@ def _read_version():
 
 def _read_long_description():
     readme = Path("README.md")
-    return readme.read_text(encoding="utf-8") if readme.is_file() else ""
+    if not readme.is_file():
+        return ""
+    text = readme.read_text(encoding="utf-8")
+    # PyPI renders the package description standalone, where the README's
+    # relative image paths have no repository base and show up broken.
+    # Rewrite them to absolute raw URLs at build time so the checked-in
+    # README keeps GitHub-friendly relative paths.
+    # The language switcher links point at in-repo translated READMEs, which
+    # cannot resolve on PyPI's standalone rendering; drop the line there.
+    text = re.sub(r'<p align="center">\s*<strong>Language</strong>.*?</p>\n?', "", text, flags=re.S)
+    ref = os.environ.get("IAC_CODE_README_IMG_REF", "main")
+    base = "https://raw.githubusercontent.com/aliyun/iac-code/{}/website/static/img/".format(ref)
+    return text.replace('src="website/static/img/', 'src="{}'.format(base))
 
 
 def _try_import_babel():

iac_code-0.14.0/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.14.0"
+__release_date__ = "2026-08-28"

{iac_code-0.13.0 → iac_code-0.14.0}/src/iac_code/a2a/app.py

@@ -7,7 +7,9 @@ import hashlib
 import hmac
 import json
 import logging
+import math
 import os
+import signal
 from contextlib import asynccontextmanager, suppress
 from email.utils import formatdate
 from pathlib import Path
@@ -37,9 +39,12 @@ from iac_code.a2a.projection import (
     resolve_a2a_public_path_roots,
     resolve_a2a_public_path_roots_for_data,
 )
+from iac_code.a2a.types import validate_protocol_id
 from iac_code.i18n import _
 from iac_code.pipeline.config import get_run_mode
 from iac_code.services.configuration_readiness import configuration_readiness
+from iac_code.services.session_backup import SessionBackupError
+from iac_code.services.session_storage import SessionStorage
 
 logger = logging.getLogger(__name__)
 _V03_JSONRPC_METHODS = frozenset(
@@ -72,6 +77,58 @@ class _PrincipalUser(User):
         return self._principal
 
 
+class _A2AIdleShutdownController:
+    def __init__(self, timeout_seconds: float, callback: Callable[[], None]) -> None:
+        self._timeout_seconds = timeout_seconds
+        self._callback = callback
+        self._inflight_requests = 0
+        self._last_activity = 0.0
+
+    def touch(self) -> None:
+        self._last_activity = asyncio.get_running_loop().time()
+
+    def request_started(self) -> None:
+        self._inflight_requests += 1
+        self.touch()
+
+    def request_finished(self) -> None:
+        self._inflight_requests = max(0, self._inflight_requests - 1)
+        self.touch()
+
+    async def monitor(self, task_store: Any) -> None:
+        interval = min(1.0, max(0.05, self._timeout_seconds / 10))
+        while True:
+            await asyncio.sleep(interval)
+            if self._inflight_requests:
+                continue
+            now = asyncio.get_running_loop().time()
+            if now - self._last_activity < self._timeout_seconds:
+                continue
+            if await task_store.has_active_work():
+                self._last_activity = asyncio.get_running_loop().time()
+                continue
+            if self._inflight_requests:
+                continue
+            self._callback()
+            return
+
+
+class _A2AIdleActivityMiddleware:
+    def __init__(self, app: Any, *, controller: _A2AIdleShutdownController) -> None:
+        self._app = app
+        self._controller = controller
+
+    async def __call__(self, scope: dict[str, Any], receive: Any, send: Any) -> None:
+        if scope["type"] != "http":
+            await self._app(scope, receive, send)
+            return
+        self._controller.request_started()
+        try:
+            await self._app(scope, receive, send)
+        finally:
+            self._controller.request_finished()
+
+
 def resolve_token(cli_token: str | None) -> str | None:
     return cli_token or os.environ.get("IACCODE_A2A_HTTP_TOKEN")
 
@@ -338,7 +395,10 @@ def create_app(
     supported_interfaces: list[dict[str, str]] | None = None,
     agent_extensions: object | None = None,
     auto_approve_permissions: bool = False,
+    permission_wait: object | None = None,
     thinking_exposure: object | None = None,
+    idle_shutdown_seconds: float = 0,
+    idle_shutdown_callback: Callable[[], None] | None = None,
 ) -> Starlette:
     from iac_code.a2a.transports.dispatcher import create_runtime_components
 
@@ -367,20 +427,36 @@ def create_app(
         supported_interfaces=supported_interfaces,
         agent_extensions=agent_extensions,
         auto_approve_permissions=auto_approve_permissions,
+        permission_wait=permission_wait,
         thinking_exposure=thinking_exposure,
     )
     from iac_code.a2a.pipeline_recovery import A2APipelineRecoveryService
 
+    idle_controller: _A2AIdleShutdownController | None = None
+    if idle_shutdown_seconds > 0:
+        idle_controller = _A2AIdleShutdownController(
+            idle_shutdown_seconds,
+            idle_shutdown_callback or (lambda: os.kill(os.getpid(), signal.SIGTERM)),
+        )
+
     @asynccontextmanager
     async def lifespan(app: Starlette):
         push_worker_task: asyncio.Task[None] | None = None
+        idle_shutdown_task: asyncio.Task[None] | None = None
         components.start_background_services()
         try:
             await components.task_store.start_cleanup_loop()
             if components.push_worker is not None:
                 push_worker_task = asyncio.create_task(components.push_worker.serve_forever())
+            if idle_controller is not None:
+                idle_controller.touch()
+                idle_shutdown_task = asyncio.create_task(idle_controller.monitor(components.task_store))
             yield
         finally:
+            if idle_shutdown_task is not None:
+                idle_shutdown_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await idle_shutdown_task
             if push_worker_task is not None:
                 push_worker_task.cancel()
                 with suppress(asyncio.CancelledError):
@@ -404,6 +480,42 @@ def create_app(
     async def get_readiness(request: Request) -> JSONResponse:
         return JSONResponse(configuration_readiness(model=model))
 
+    async def ensure_session_restored(request: Request) -> JSONResponse:
+        try:
+            payload = await request.json()
+        except Exception:
+            return JSONResponse({"error": "Invalid session restore request."}, status_code=400)
+        if not isinstance(payload, dict):
+            return JSONResponse({"error": "Invalid session restore request."}, status_code=400)
+        raw_cwd = payload.get("cwd")
+        raw_session_id = payload.get("sessionId")
+        if not isinstance(raw_cwd, str) or not raw_cwd or not isinstance(raw_session_id, str):
+            return JSONResponse({"error": "Invalid session restore request."}, status_code=400)
+
+        executor = getattr(components.handler, "agent_executor", None)
+        resolve_cwd = getattr(executor, "_resolve_cwd", None)
+        backup_service = components.backup_service
+        if not callable(resolve_cwd) or backup_service is None:
+            return JSONResponse({"error": "Session restore is unavailable."}, status_code=503)
+        try:
+            session_id = validate_protocol_id(raw_session_id)
+            cwd = resolve_cwd({"iac_code": {"cwd": raw_cwd}})
+            result = await asyncio.to_thread(backup_service.reconcile_session, cwd, session_id)
+            exists = SessionStorage().exists(cwd, session_id)
+        except ValueError:
+            return JSONResponse({"error": "Invalid session restore request."}, status_code=400)
+        except SessionBackupError as exc:
+            logger.warning("A2A session restore failed error_type=%s", type(exc).__name__)
+            return JSONResponse({"error": "Unable to restore the A2A session."}, status_code=503)
+        except Exception as exc:
+            logger.warning("A2A session restore failed error_type=%s", type(exc).__name__)
+            return JSONResponse({"error": "Unable to restore the A2A session."}, status_code=503)
+
+        if not exists:
+            return JSONResponse({"status": "not_found"}, status_code=404)
+        status = "restored" if getattr(result, "action", None) == "restored" else "current"
+        return JSONResponse({"status": status})
+
     recovery_service = A2APipelineRecoveryService(task_store=components.task_store)
 
     async def recovery_path_roots(*, context_id: str | None, task_id: str | None) -> list[dict[str, str]]:
@@ -450,6 +562,7 @@ def create_app(
         Route("/health", health, methods=["GET"]),
         Route(AGENT_CARD_WELL_KNOWN_PATH, get_agent_card, methods=["GET"]),
         Route("/iac-code/readiness", get_readiness, methods=["GET"]),
+        Route("/iac-code/session/ensure-restored", ensure_session_restored, methods=["POST"]),
         Route("/iac-code/pipeline/state", get_pipeline_state, methods=["GET"]),
     ]
     install_jsonrpc_error_data_passthrough()
@@ -472,6 +585,8 @@ def create_app(
         api_key=api_key,
         api_key_header=api_key_header,
     )
+    if idle_controller is not None:
+        app.add_middleware(_A2AIdleActivityMiddleware, controller=idle_controller)
     return app
 
 
@@ -534,11 +649,22 @@ def run_server(
     push_consumer_name: str | None = None,
     push_lease_timeout_ms: int = 300_000,
     auto_approve_permissions: bool = False,
+    permission_wait: object | None = None,
     thinking_exposure: object | None = None,
+    idle_shutdown_seconds: float = 0,
 ) -> None:
     from iac_code.a2a.transports.base import normalize_transport_name, validate_transport_for_platform
 
     normalized_transport = normalize_transport_name(transport)
+    if isinstance(idle_shutdown_seconds, bool) or not isinstance(idle_shutdown_seconds, (int, float)):
+        raise ValueError("idle_shutdown_seconds must be a non-negative number.")
+    idle_shutdown_seconds = float(idle_shutdown_seconds)
+    if not math.isfinite(idle_shutdown_seconds):
+        raise ValueError("idle_shutdown_seconds must be a non-negative number.")
+    if idle_shutdown_seconds < 0:
+        raise ValueError("idle_shutdown_seconds must be a non-negative number.")
+    if idle_shutdown_seconds > 0 and normalized_transport != "http":
+        raise RuntimeError("idle_shutdown_seconds is only supported with the HTTP transport.")
     if persistence_dir is None:
         from iac_code.config import get_config_dir
 
@@ -595,6 +721,7 @@ def run_server(
         "push_lease_timeout_ms": push_lease_timeout_ms,
         "supported_interfaces": supported_interfaces,
         "auto_approve_permissions": auto_approve_permissions,
+        "permission_wait": permission_wait,
         "thinking_exposure": thinking_exposure,
     }
 
@@ -663,6 +790,13 @@ def run_server(
         )
         return
 
+    idle_server_holder: dict[str, Any] = {}
+
+    def request_idle_shutdown() -> None:
+        server = idle_server_holder.get("server")
+        if server is not None:
+            server.should_exit = True
+
     if normalized_transport == "websocket":
         from iac_code.a2a.transports.websocket import WebSocketA2AServerApp
 
@@ -693,7 +827,10 @@ def run_server(
             push_lease_timeout_ms=push_lease_timeout_ms,
             supported_interfaces=supported_interfaces,
             auto_approve_permissions=auto_approve_permissions,
+            permission_wait=permission_wait,
             thinking_exposure=thinking_exposure,
+            idle_shutdown_seconds=idle_shutdown_seconds,
+            idle_shutdown_callback=request_idle_shutdown,
         )
 
     try:
@@ -701,11 +838,16 @@ def run_server(
     except ImportError as exc:
         raise RuntimeError("A2A server dependencies are missing. Install with: pip install 'iac-code[a2a]'") from exc
 
-    uvicorn.run(
-        app,
-        host=host,
-        port=port,
-    )
+    if idle_shutdown_seconds > 0:
+        server = uvicorn.Server(uvicorn.Config(app, host=host, port=port))
+        idle_server_holder["server"] = server
+        server.run()
+    else:
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+        )
 
 
 async def _serve_async_transport(server, *, components) -> None:

{iac_code-0.13.0 → iac_code-0.14.0}/src/iac_code/a2a/backup.py

@@ -41,13 +41,14 @@ async def backup_session_async(
     critical: bool,
     metrics: Any | None = None,
     publication_proofs: dict[str, BackupPublicationProof] | None = None,
+    backup_call: Callable[..., Any] | None = None,
 ) -> Any | None:
     failed_recorded = False
     try:
         kwargs: dict[str, Any] = {"reason": reason, "critical": critical}
         if publication_proofs is not None:
             kwargs["publication_proofs"] = publication_proofs
-        result = await run_sync_fenced(backup_service.backup_session, cwd, session_id, **kwargs)
+        result = await run_sync_fenced(backup_call or backup_service.backup_session, cwd, session_id, **kwargs)
         retry_count = _retry_count(result)
         if getattr(result, "enabled", False) and not getattr(result, "succeeded", True):
             message = str(

{iac_code-0.13.0 → iac_code-0.14.0}/src/iac_code/a2a/client.py

@@ -154,22 +154,29 @@ class A2AClient:
         *,
         cwd: str,
         context_id: str | None = None,
+        task_id: str | None = None,
+        message_id: str | None = None,
         model: str | None = None,
         iac_code_api_key: str | None = None,
         thinking_enabled: bool | None = None,
         thinking_effort: str | None = None,
         thinking_budget: int | None = None,
+        iac_code_metadata: Mapping[str, Any] | None = None,
     ) -> A2AClientResponse:
         payload = self._message_payload(
             method="SendMessage",
             prompt=prompt,
+            parts=None,
             cwd=cwd,
             context_id=context_id,
+            task_id=task_id,
+            message_id=message_id,
             model=model,
             iac_code_api_key=iac_code_api_key,
             thinking_enabled=thinking_enabled,
             thinking_effort=thinking_effort,
             thinking_budget=thinking_budget,
+            additional_iac_code_metadata=iac_code_metadata,
         )
         transport = self._make_transport_client(url)
         response = await transport.send(payload)
@@ -182,22 +189,101 @@ class A2AClient:
         *,
         cwd: str,
         context_id: str | None = None,
+        task_id: str | None = None,
+        message_id: str | None = None,
         model: str | None = None,
         iac_code_api_key: str | None = None,
         thinking_enabled: bool | None = None,
         thinking_effort: str | None = None,
         thinking_budget: int | None = None,
+        iac_code_metadata: Mapping[str, Any] | None = None,
     ) -> AsyncIterator[dict[str, Any]]:
         payload = self._message_payload(
             method="SendStreamingMessage",
             prompt=prompt,
+            parts=None,
             cwd=cwd,
             context_id=context_id,
+            task_id=task_id,
+            message_id=message_id,
             model=model,
             iac_code_api_key=iac_code_api_key,
             thinking_enabled=thinking_enabled,
             thinking_effort=thinking_effort,
             thinking_budget=thinking_budget,
+            additional_iac_code_metadata=iac_code_metadata,
+        )
+        transport = self._make_transport_client(url)
+        async for event in transport.stream(payload):
+            yield event
+
+    async def send_message_parts(
+        self,
+        url: str,
+        parts: Sequence[Mapping[str, Any]],
+        *,
+        cwd: str,
+        context_id: str,
+        task_id: str | None = None,
+        message_id: str | None = None,
+        model: str | None = None,
+        iac_code_api_key: str | None = None,
+        thinking_enabled: bool | None = None,
+        thinking_effort: str | None = None,
+        thinking_budget: int | None = None,
+        iac_code_metadata: Mapping[str, Any] | None = None,
+    ) -> A2AClientResponse:
+        """Send pre-validated A2A parts while preserving iac-code request metadata."""
+        payload = self._message_payload(
+            method="SendMessage",
+            prompt=None,
+            parts=parts,
+            cwd=cwd,
+            context_id=context_id,
+            task_id=task_id,
+            message_id=message_id,
+            model=model,
+            iac_code_api_key=iac_code_api_key,
+            thinking_enabled=thinking_enabled,
+            thinking_effort=thinking_effort,
+            thinking_budget=thinking_budget,
+            additional_iac_code_metadata=iac_code_metadata,
+        )
+        transport = self._make_transport_client(url)
+        response = await transport.send(payload)
+        return A2AClientResponse(payload=response)
+
+    async def stream_message_parts(
+        self,
+        url: str,
+        parts: Sequence[Mapping[str, Any]],
+        *,
+        cwd: str,
+        context_id: str,
+        task_id: str | None = None,
+        message_id: str | None = None,
+        model: str | None = None,
+        iac_code_api_key: str | None = None,
+        thinking_enabled: bool | None = None,
+        thinking_effort: str | None = None,
+        thinking_budget: int | None = None,
+        iac_code_metadata: Mapping[str, Any] | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Stream a message whose parts were validated by an embedding protocol adapter."""
+        payload = self._message_payload(
+            method="SendStreamingMessage",
+            prompt=None,
+            parts=parts,
+            cwd=cwd,
+            context_id=context_id,
+            task_id=task_id,
+            message_id=message_id,
+            model=model,
+            iac_code_api_key=iac_code_api_key,
+            thinking_enabled=thinking_enabled,
+            thinking_effort=thinking_effort,
+            thinking_budget=thinking_budget,
+            additional_iac_code_metadata=iac_code_metadata,
         )
         transport = self._make_transport_client(url)
         async for event in transport.stream(payload):
@@ -209,6 +295,43 @@ class A2AClient:
             params["historyLength"] = history_length
         return await self._send_jsonrpc(url, method="GetTask", params=params)
 
+    async def get_pipeline_state(
+        self,
+        url: str,
+        *,
+        task_id: str,
+        after_sequence: int | None = None,
+    ) -> dict[str, Any] | None:
+        """Read iac-code's existing A2A pipeline recovery extension over HTTP."""
+
+        endpoint = url.rstrip("/") + "/iac-code/pipeline/state"
+        params = _without_none({"taskId": task_id, "afterSequence": after_sequence})
+        response = await self._http_client.get(endpoint, params=params, headers=self._jsonrpc_headers())
+        if response.status_code == 404:
+            return None
+        response.raise_for_status()
+        data = response.json()
+        if not isinstance(data, dict):
+            raise ValueError("A2A pipeline state response must be a JSON object")
+        return data
+
+    async def ensure_session_restored(self, url: str, *, cwd: str, session_id: str) -> bool:
+        """Ensure the A2A session payload is locally available before a cold resume."""
+
+        endpoint = url.rstrip("/") + "/iac-code/session/ensure-restored"
+        response = await self._http_client.post(
+            endpoint,
+            json={"cwd": cwd, "sessionId": session_id},
+            headers=self._jsonrpc_headers(),
+        )
+        if response.status_code == 404:
+            return False
+        response.raise_for_status()
+        data = response.json()
+        if not isinstance(data, dict) or data.get("status") not in {"current", "restored"}:
+            raise ValueError("A2A session restore response must report a ready session")
+        return True
+
     async def list_tasks(
         self,
         url: str,
@@ -397,16 +520,23 @@ class A2AClient:
         self,
         *,
         method: str,
-        prompt: str,
+        prompt: str | None,
+        parts: Sequence[Mapping[str, Any]] | None,
         cwd: str,
         context_id: str | None,
+        task_id: str | None,
+        message_id: str | None,
         model: str | None,
         iac_code_api_key: str | None,
         thinking_enabled: bool | None,
         thinking_effort: str | None,
         thinking_budget: int | None,
+        additional_iac_code_metadata: Mapping[str, Any] | None,
     ) -> dict[str, Any]:
-        iac_code_metadata: dict[str, Any] = {"cwd": cwd}
+        if (prompt is None) == (parts is None):
+            raise ValueError("Exactly one of prompt or parts is required")
+        iac_code_metadata: dict[str, Any] = dict(additional_iac_code_metadata or {})
+        iac_code_metadata["cwd"] = cwd
         if model:
             stripped_model = model.strip()
             if stripped_model:
@@ -427,13 +557,15 @@ class A2AClient:
         if thinking:
             iac_code_metadata["thinking"] = thinking
         message: dict[str, Any] = {
-            "messageId": str(uuid.uuid4()),
+            "messageId": message_id or str(uuid.uuid4()),
             "role": "ROLE_USER",
-            "parts": [{"text": prompt}],
+            "parts": [{"text": prompt}] if prompt is not None else [dict(part) for part in parts or ()],
             "metadata": {"iac_code": iac_code_metadata},
         }
         if context_id:
             message["contextId"] = context_id
+        if task_id:
+            message["taskId"] = task_id
         return self._jsonrpc_payload(
             method=method,
             params={