iac-code 0.13.1__tar.gz → 0.15.0__tar.gz

{iac_code-0.13.1 → iac_code-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.13.1
+Version: 0.15.0
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -14,6 +14,7 @@ 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

{iac_code-0.13.1 → iac_code-0.15.0}/pyproject.toml

@@ -74,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]
@@ -146,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.1 → iac_code-0.15.0}/setup.py

@@ -22,6 +22,10 @@ SELLING_IAC_ALIYUN_SKILLS = (
     "iac-aliyun-cost",
     "iac-aliyun-deploying",
 )
+SELLING_SOLUTION_FIRST_REFERENCE_SKILLS = (
+    "iac-aliyun-deploying",
+    "iac-aliyun-materialize-selected-candidate",
+)
 INSTALL_REQUIRES = [
     "anthropic>=0.40",
     "pydantic>=2.0",
@@ -270,20 +274,33 @@ def _copy_reference_tree(source: Path, target: Path) -> None:
         _copy_reference_entry(child, target / child.name)
 
 
+def _replace_with_materialized_tree(source: Path, target: Path) -> None:
+    """Replace a source link/placeholder with a real directory tree in a release artifact."""
+    if target.is_symlink() or target.is_file():
+        target.unlink()
+    elif target.exists():
+        shutil.rmtree(target)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    _copy_reference_tree(source, target)
+
+
 def _copy_selling_skill_references_to_package_root(package_root) -> None:
-    """Expand selling-skill reference symlinks into real dirs under an iac_code package root."""
+    """Materialize shared selling skills/references under an iac_code package root."""
     if not SELLING_REFERENCES_DIR.is_dir():
         raise RuntimeError("references directory not found: %s" % SELLING_REFERENCES_DIR)
 
     package_root = Path(package_root)
+    _replace_with_materialized_tree(
+        SELLING_REFERENCES_DIR,
+        package_root / "pipeline" / "selling" / "references",
+    )
     for skill_name in SELLING_IAC_ALIYUN_SKILLS:
         target = package_root / "pipeline" / "selling" / "skills" / skill_name / "references"
-        if target.is_symlink() or target.is_file():
-            target.unlink()
-        elif target.exists():
-            shutil.rmtree(target)
-        target.parent.mkdir(parents=True, exist_ok=True)
-        _copy_reference_tree(SELLING_REFERENCES_DIR, target)
+        _replace_with_materialized_tree(SELLING_REFERENCES_DIR, target)
+
+    solution_first_skills = package_root / "pipeline" / "selling_solution_first" / "skills"
+    for skill_name in SELLING_SOLUTION_FIRST_REFERENCE_SKILLS:
+        _replace_with_materialized_tree(SELLING_REFERENCES_DIR, solution_first_skills / skill_name / "references")
 
 
 def _copy_selling_skill_references(build_lib: str) -> None:

iac_code-0.15.0/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.15.0"
+__release_date__ = "2026-09-03"

{iac_code-0.13.1 → iac_code-0.15.0}/src/iac_code/a2a/app.py

@@ -39,9 +39,16 @@ 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 (
+    SESSION_BACKUP_NOT_READY_CODE,
+    SessionBackupError,
+    SessionBackupNotReadyError,
+)
+from iac_code.services.session_storage import SessionStorage
 
 logger = logging.getLogger(__name__)
 _V03_JSONRPC_METHODS = frozenset(
@@ -392,6 +399,7 @@ 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,
@@ -423,9 +431,10 @@ 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
+    from iac_code.a2a.pipeline_recovery import A2APipelineRecoveryService, client_pipeline_state
 
     idle_controller: _A2AIdleShutdownController | None = None
     if idle_shutdown_seconds > 0:
@@ -475,6 +484,60 @@ 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")
+        raw_task_id = payload.get("taskId")
+        if (
+            not isinstance(raw_cwd, str)
+            or not raw_cwd
+            or not isinstance(raw_session_id, str)
+            or (raw_task_id is not None and not isinstance(raw_task_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)
+        ensure_restored = getattr(executor, "ensure_session_restored", None)
+        if not callable(resolve_cwd) or not callable(ensure_restored):
+            return JSONResponse({"error": "Session restore is unavailable."}, status_code=503)
+        try:
+            session_id = validate_protocol_id(raw_session_id)
+            task_id = validate_protocol_id(raw_task_id) if raw_task_id is not None else None
+            cwd = resolve_cwd({"iac_code": {"cwd": raw_cwd}})
+            result = await ensure_restored(cwd=cwd, session_id=session_id, task_id=task_id)
+            exists = SessionStorage().exists(cwd, session_id)
+        except ValueError:
+            return JSONResponse({"error": "Invalid session restore request."}, status_code=400)
+        except SessionBackupNotReadyError as exc:
+            return JSONResponse(
+                {
+                    "error": {
+                        "code": SESSION_BACKUP_NOT_READY_CODE,
+                        "message": str(exc),
+                        "retryable": True,
+                    }
+                },
+                status_code=409,
+            )
+        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]]:
@@ -493,6 +556,7 @@ def create_app(
         after_sequence, parse_error = _parse_after_sequence(request.query_params.get("afterSequence"))
         if parse_error is not None:
             return JSONResponse({"error": parse_error}, status_code=400)
+        lean = _parse_lean(request.query_params.get("lean"))
 
         call_context = _call_context_from_request(request)
         try:
@@ -515,12 +579,14 @@ def create_app(
             context_id=context_id,
             task_id=task_id,
         )
-        return JSONResponse(project_a2a_data(state, public_path_roots=roots))
+        # 先裁掉不发给客户端的字段，再投影：既少发一大半字节，也少一大半要脱敏的字符串
+        return JSONResponse(project_a2a_data(client_pipeline_state(state, lean=lean), public_path_roots=roots))
 
     routes: list[BaseRoute] = [
         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()
@@ -561,6 +627,22 @@ def _agent_card_etag(card: dict[str, object]) -> str:
     return f'"sha256-{hashlib.sha256(body).hexdigest()}"'
 
 
+#: ``?lean=`` 认得的开启值：其余值一律按全量处理，只在日志里留痕。
+#: 这个开关只影响响应体积，认不出来时给全量数据（慢但完整）比报错拒绝更安全。
+_LEAN_TRUTHY_VALUES = frozenset({"1", "true"})
+
+
+def _parse_lean(value: str | None) -> bool:
+    if value is None or value == "":
+        return False
+    normalized = value.strip().lower()
+    if normalized in _LEAN_TRUTHY_VALUES:
+        return True
+    if normalized not in {"0", "false"}:
+        logger.warning("Ignoring unrecognized pipeline state lean value %r; returning the full snapshot", value)
+    return False
+
+
 def _parse_after_sequence(value: str | None) -> tuple[int | None, str | None]:
     if value is None or value == "":
         return None, None
@@ -607,6 +689,7 @@ 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:
@@ -678,6 +761,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,
     }
 
@@ -783,6 +867,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,
             idle_shutdown_seconds=idle_shutdown_seconds,
             idle_shutdown_callback=request_idle_shutdown,

{iac_code-0.13.1 → iac_code-0.15.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.1 → iac_code-0.15.0}/src/iac_code/a2a/client.py

@@ -13,12 +13,17 @@ from iac_code.a2a.signing import AgentCardSignature, agent_card_signature_jwks_u
 from iac_code.a2a.transport import A2AAuthConfig, A2ATransportBinding, UnsupportedA2ATransportError, headers_for_auth
 from iac_code.a2a.transports.base import A2ATransportClient, TransportClientOptions, binding_from_url
 from iac_code.a2a.transports.http import HttpA2AClient
+from iac_code.services.session_backup import SESSION_BACKUP_NOT_READY_CODE
 
 
 class A2ACardVerificationError(ValueError):
     """Raised when a discovered Agent Card fails configured verification."""
 
 
+class A2ASessionBackupNotReadyError(RuntimeError):
+    """The internal A2A restore endpoint has not reached the required backup generation."""
+
+
 TransportClientFactory = Callable[[TransportClientOptions], A2ATransportClient]
 
 
@@ -154,22 +159,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 +194,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 +300,64 @@ 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,
+        task_id: str | None = None,
+    ) -> 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=_without_none({"cwd": cwd, "sessionId": session_id, "taskId": task_id}),
+            headers=self._jsonrpc_headers(),
+        )
+        if response.status_code == 404:
+            return False
+        if response.status_code == 409:
+            payload = response.json()
+            error = payload.get("error") if isinstance(payload, dict) else None
+            if (
+                isinstance(error, dict)
+                and error.get("code") == SESSION_BACKUP_NOT_READY_CODE
+                and error.get("retryable") is True
+            ):
+                message = error.get("message")
+                raise A2ASessionBackupNotReadyError(
+                    message
+                    if isinstance(message, str) and message
+                    else "Session backup is still synchronizing. Retry after 3 seconds."
+                )
+        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 +546,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 +583,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={