iac-code 0.9.0__tar.gz → 0.10.0__tar.gz

{iac_code-0.9.0 → iac_code-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.9.0
+Version: 0.10.0
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10

{iac_code-0.9.0 → iac_code-0.10.0}/pyproject.toml

@@ -25,17 +25,27 @@ dependencies = [
     "tiktoken>=0.7.0",
     "jsonschema>=4.20",
     "alibabacloud-ros20190910>=3.0.0",
+    "alibabacloud-tea-openapi>=0.4.4,<0.5",
+    "alibabacloud-openapi-util>=0.2.4,<0.3",
+    "alibabacloud-oss-v2>=1.2,<2",
+    "aiohttp>=3.10,<4",
+    "defusedxml>=0.7,<1",
     "alibabacloud-credentials>=0.3.0",
     "loguru>=0.7.0",
     "opentelemetry-distro>=0.48b0",
     "opentelemetry-exporter-otlp>=1.27.0",
     "agent-client-protocol>=0.9.0",
-    "pillow==12.2.0",
+    "pillow==12.3.0",
     "cryptography>=42.0",
     "keyring>=25.0",
     "tree-sitter>=0.25,<0.26",
     "tree-sitter-bash>=0.25,<0.26",
     "mcp>=1.28.0",
+    "alibabacloud-gateway-sls>=0.4.2,<0.5",
+    "alibabacloud-gateway-mns>=0.0.2,<0.1",
+    "alibabacloud-gateway-oss>=0.0.25,<1",
+    "alibabacloud-gateway-pop>=0.1.3,<1",
+    "aliyun-python-sdk-core>=2.16,<3",
 ]
 
 [project.optional-dependencies]

iac_code-0.10.0/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.10.0"
+__release_date__ = "2026-07-22"

{iac_code-0.9.0 → iac_code-0.10.0}/src/iac_code/a2a/agent_card.py

@@ -21,6 +21,11 @@ from iac_code import __version__
 from iac_code.a2a.exposure import format_a2a_exposure_types
 from iac_code.a2a.parts import supported_input_mime_types
 from iac_code.a2a.pipeline_events import PIPELINE_EVENTS_EXTENSION_URI
+from iac_code.a2a.pipeline_outbound import (
+    OUTBOUND_HARD_MAX_BATCH_BYTES,
+    OUTBOUND_HARD_MAX_BATCH_EVENTS,
+    OUTBOUND_MAX_BATCH_DELAY_SECONDS,
+)
 from iac_code.a2a.signing import sign_agent_card_dict
 from iac_code.i18n import _
 from iac_code.pipeline.config import RunMode, get_run_mode
@@ -191,6 +196,11 @@ def build_agent_card(
             "schemaVersion": "1.0",
             "enabled": run_mode == RunMode.PIPELINE,
             "mode": run_mode.value,
+            "supportsEventBatching": True,
+            "eventBatchMetadataPath": "metadata.iac_code.pipelineBatch.events",
+            "maxBatchEvents": OUTBOUND_HARD_MAX_BATCH_EVENTS,
+            "maxBatchBytes": OUTBOUND_HARD_MAX_BATCH_BYTES,
+            "maxBatchDelayMs": round(OUTBOUND_MAX_BATCH_DELAY_SECONDS * 1000),
             "supportsSnapshot": True,
             "supportsReplay": True,
             "supportsInterrupts": True,

{iac_code-0.9.0 → iac_code-0.10.0}/src/iac_code/a2a/backup.py

@@ -1,15 +1,37 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
+from collections.abc import Callable
 from typing import Any
 
 from iac_code.i18n import _
 from iac_code.services.session_backup import BackupReason, SessionBackupBlocked
+from iac_code.services.session_backup_state import BackupPublicationProof
 
 logger = logging.getLogger(__name__)
 
 
+async def run_sync_fenced(function: Callable[..., Any], /, *args: Any, **kwargs: Any) -> Any:
+    """Delay coroutine cancellation until the synchronous mutation has actually stopped."""
+    thread_task = asyncio.create_task(asyncio.to_thread(function, *args, **kwargs))
+    try:
+        return await asyncio.shield(thread_task)
+    except asyncio.CancelledError:
+        while not thread_task.done():
+            try:
+                await asyncio.shield(thread_task)
+            except asyncio.CancelledError:
+                continue
+            except Exception:
+                break
+        if thread_task.done() and not thread_task.cancelled():
+            with contextlib.suppress(Exception):
+                thread_task.result()
+        raise
+
+
 async def backup_session_async(
     backup_service: Any,
     cwd: str,
@@ -18,16 +40,14 @@ async def backup_session_async(
     reason: BackupReason,
     critical: bool,
     metrics: Any | None = None,
+    publication_proofs: dict[str, BackupPublicationProof] | None = None,
 ) -> Any | None:
     failed_recorded = False
     try:
-        result = await asyncio.to_thread(
-            backup_service.backup_session,
-            cwd,
-            session_id,
-            reason=reason,
-            critical=critical,
-        )
+        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)
         retry_count = _retry_count(result)
         if getattr(result, "enabled", False) and not getattr(result, "succeeded", True):
             message = str(

{iac_code-0.9.0 → iac_code-0.10.0}/src/iac_code/a2a/client.py

@@ -39,6 +39,9 @@ class A2AClientResponse:
             extracted = _extract_parts_text(status.get("message"))
             if extracted:
                 return extracted
+        extracted = _extract_parts_text(result.get("message"))
+        if extracted:
+            return extracted
         task = result.get("task")
         if isinstance(task, dict):
             task_status = task.get("status")
@@ -48,20 +51,40 @@ class A2AClientResponse:
                     return extracted
             history = task.get("history")
             if isinstance(history, list):
-                for entry in reversed(history):
-                    extracted = _extract_agent_entry_text(entry)
-                    if extracted:
-                        return extracted
+                extracted = _extract_trailing_agent_history_text(history)
+                if extracted:
+                    return extracted
         return ""
 
 
 _AGENT_ROLE_NAME = Role.Name(Role.ROLE_AGENT)
-
-
-def _extract_agent_entry_text(entry: Any) -> str:
-    if not isinstance(entry, dict) or entry.get("role") != _AGENT_ROLE_NAME:
-        return ""
-    return _extract_parts_text(entry)
+_TASK_SUBSCRIPTION_STOP_STATES = {
+    "auth-required",
+    "canceled",
+    "completed",
+    "failed",
+    "input-required",
+    "rejected",
+    "task_state_auth_required",
+    "task_state_canceled",
+    "task_state_completed",
+    "task_state_failed",
+    "task_state_input_required",
+    "task_state_rejected",
+}
+
+
+def _extract_trailing_agent_history_text(history: list[Any]) -> str:
+    pieces: list[str] = []
+    for entry in reversed(history):
+        if not isinstance(entry, dict) or entry.get("role") != _AGENT_ROLE_NAME:
+            break
+        extracted = _extract_parts_text(entry)
+        if not extracted:
+            break
+        pieces.append(extracted)
+    pieces.reverse()
+    return "".join(pieces)
 
 
 def _extract_parts_text(message: Any) -> str:
@@ -213,8 +236,16 @@ class A2AClient:
     async def subscribe_task(self, url: str, task_id: str) -> AsyncIterator[dict[str, Any]]:
         payload = self._jsonrpc_payload(method="SubscribeToTask", params={"id": task_id})
         transport = self._make_transport_client(url)
-        async for event in transport.stream(payload):
-            yield event
+        stream = transport.stream(payload)
+        try:
+            async for event in stream:
+                yield event
+                if _is_task_subscription_stop_event(event):
+                    break
+        finally:
+            close = getattr(stream, "aclose", None)
+            if close is not None:
+                await close()
 
     async def create_push_notification_config(
         self,
@@ -430,6 +461,32 @@ def _without_none(values: Mapping[str, Any]) -> dict[str, Any]:
     return {key: value for key, value in values.items() if value is not None}
 
 
+def _is_task_subscription_stop_event(event: Any) -> bool:
+    if not isinstance(event, dict):
+        return False
+    state = _task_subscription_state(event.get("result"))
+    if not state:
+        return False
+    normalized = state.strip().lower().replace("_", "-")
+    return (
+        normalized in _TASK_SUBSCRIPTION_STOP_STATES or normalized.replace("-", "_") in _TASK_SUBSCRIPTION_STOP_STATES
+    )
+
+
+def _task_subscription_state(result: Any) -> str:
+    if not isinstance(result, dict):
+        return ""
+    status = result.get("status")
+    if isinstance(status, dict) and isinstance(status.get("state"), str):
+        return status["state"]
+    task = result.get("task")
+    if isinstance(task, dict):
+        task_status = task.get("status")
+        if isinstance(task_status, dict) and isinstance(task_status.get("state"), str):
+            return task_status["state"]
+    return ""
+
+
 def _merge_jwks(*jwks_values: Mapping[str, Any] | None) -> dict[str, Any] | None:
     keys: list[Any] = []
     for jwks in jwks_values:
@@ -450,8 +507,14 @@ class _BoundHttpA2AClient:
         return await self._client.send(self._url, payload)
 
     async def stream(self, payload: dict[str, Any]) -> AsyncIterator[dict[str, Any]]:
-        async for event in self._client.stream(self._url, payload):
-            yield event
+        stream = self._client.stream(self._url, payload)
+        try:
+            async for event in stream:
+                yield event
+        finally:
+            close = getattr(stream, "aclose", None)
+            if close is not None:
+                await close()
 
     async def aclose(self) -> None:
         return None

{iac_code-0.9.0 → iac_code-0.10.0}/src/iac_code/a2a/events.py

@@ -25,6 +25,8 @@ from iac_code.a2a.artifacts import (
 from iac_code.a2a.exposure import A2AExposureType, normalize_a2a_exposure_types
 from iac_code.a2a.metadata_redaction import A2AMetadataEchoRedactor
 from iac_code.i18n import _
+from iac_code.mcp.progress import mcp_progress_metadata, mcp_progress_public_name
+from iac_code.mcp.redaction import sanitize_mcp_public_data
 from iac_code.services.permissions.audit import (
     build_input_summary,
     build_redacted_tool_input,
@@ -118,8 +120,11 @@ async def publish_mcp_warnings(
     pushed_count = getattr(runtime, "_a2a_mcp_warnings_pushed_count", 0)
     if pushed_count >= len(warnings):
         return
+    from iac_code.mcp.manager import mcp_warning_metadata
+
     for warning in warnings[pushed_count:]:
-        message = str(getattr(warning, "message", None) or warning)
+        warning_metadata = mcp_warning_metadata(warning)
+        message = warning_metadata["message"]
         await _enqueue_status(
             event_queue,
             task_id=task_id,
@@ -132,11 +137,7 @@ async def publish_mcp_warnings(
             ),
             metadata={
                 "iac_code": {
-                    "mcpWarning": {
-                        "serverName": str(getattr(warning, "server_name", "")),
-                        "code": str(getattr(warning, "code", "")),
-                        "message": message,
-                    }
+                    "mcpWarning": warning_metadata,
                 }
             },
             iac_code_session_id=iac_code_session_id,
@@ -276,6 +277,8 @@ async def publish_stream_event(
         return event.text
 
     if isinstance(event, ThinkingDeltaEvent):
+        if event.is_metadata_only:
+            return None
         if A2AExposureType.RAW_THINKING not in enabled_exposure_types:
             return None
         await _enqueue_status(
@@ -352,15 +355,18 @@ async def publish_stream_event(
                     _artifact_update_event(task_id=task_id, context_id=context_id, metadata=artifact_metadata)
                 )
             return None
+        result_metadata = _tool_result_metadata(
+            event.result,
+            is_error=event.is_error,
+            public_path_roots=event.public_path_roots,
+        )
+        if event.tool_name.startswith("mcp__"):
+            result_metadata = sanitize_mcp_public_data(result_metadata, fallback_summary="")
         tool_metadata = {
             "status": "failed" if event.is_error else "completed",
             "toolUseId": event.tool_use_id,
             "name": event.tool_name,
-            "result": _tool_result_metadata(
-                event.result,
-                is_error=event.is_error,
-                public_path_roots=event.public_path_roots,
-            ),
+            "result": result_metadata,
         }
         if artifact_metadata is not None:
             tool_metadata["artifact"] = artifact_metadata
@@ -380,17 +386,19 @@ async def publish_stream_event(
     if isinstance(event, MCPProgressEvent):
         if A2AExposureType.TOOL_TRACE not in enabled_exposure_types:
             return None
+        canonical_progress = mcp_progress_metadata(event)
         progress_metadata = {
             "status": "progress",
-            "toolUseId": event.tool_use_id or "",
-            "name": "mcp__{}__{}".format(event.server_name, event.tool_name),
+            "toolUseId": canonical_progress["toolUseId"],
+            "name": mcp_progress_public_name(event),
             "mcp": {
-                "serverName": event.server_name,
-                "toolName": event.tool_name,
-                "progress": event.progress,
-                "total": event.total,
-                "message": _truncate(event.message) if event.message else None,
+                "serverName": canonical_progress["originalServerName"],
+                "toolName": canonical_progress["originalToolName"],
+                "progress": canonical_progress.get("progress"),
+                "total": canonical_progress.get("total"),
+                "message": canonical_progress.get("message"),
             },
+            "mcpProgress": canonical_progress,
         }
         await _enqueue_status(
             event_queue,