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

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

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

{iac_code-0.14.0 → 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.14.0 → iac_code-0.15.0}/src/iac_code/a2a/app.py

@@ -43,7 +43,11 @@ 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_backup import (
+    SESSION_BACKUP_NOT_READY_CODE,
+    SessionBackupError,
+    SessionBackupNotReadyError,
+)
 from iac_code.services.session_storage import SessionStorage
 
 logger = logging.getLogger(__name__)
@@ -430,7 +434,7 @@ def create_app(
         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:
@@ -489,21 +493,39 @@ def create_app(
             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):
+        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)
-        backup_service = components.backup_service
-        if not callable(resolve_cwd) or backup_service is 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 asyncio.to_thread(backup_service.reconcile_session, cwd, session_id)
+            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)
@@ -534,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:
@@ -556,7 +579,8 @@ 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"]),
@@ -603,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

{iac_code-0.14.0 → 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]
 
 
@@ -315,17 +320,38 @@ class A2AClient:
             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:
+    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={"cwd": cwd, "sessionId": session_id},
+            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"}:

{iac_code-0.14.0 → iac_code-0.15.0}/src/iac_code/a2a/events.py

@@ -22,7 +22,8 @@ from google.protobuf.json_format import ParseDict
 
 from iac_code.a2a.artifacts import sanitize_public_artifact_text
 from iac_code.a2a.exposure import A2AExposureType, normalize_a2a_exposure_types
-from iac_code.i18n import _
+from iac_code.a2a.runtime_overrides import get_a2a_preferred_language
+from iac_code.i18n import _, translate_message
 from iac_code.mcp.progress import mcp_progress_metadata, mcp_progress_public_name
 from iac_code.services.permissions.audit import (
     build_input_summary,
@@ -528,11 +529,17 @@ async def publish_stream_event(
         error_metadata: dict[str, Any] = {"retryable": event.is_retryable}
         if event.error_id:
             error_metadata["errorId"] = event.error_id
+        language = get_a2a_preferred_language() or "en"
         if event.is_retryable:
-            text = _("A temporary error occurred. Please retry.")
+            text = translate_message("A temporary error occurred. Please retry.", language=language)
             state = TaskState.TASK_STATE_INPUT_REQUIRED
         else:
-            raw = event.error or "Unknown error"
+            if event.i18n_message_id:
+                raw = translate_message(event.i18n_message_id, language=language).format(
+                    **(event.i18n_message_args or {})
+                )
+            else:
+                raw = event.error or translate_message("Unknown error", language=language)
             # Provider ErrorEvent is an explicitly retained compatibility
             # exception; ordinary A2A payloads are projected at the wire edge.
             text = sanitize_public_artifact_text(raw)[:_ERROR_TEXT_MAX_CHARS]
@@ -563,6 +570,9 @@ async def publish_interactive_permission_boundary(
     permission_wait_cwd: str | None,
     permission_wait_backup_service: Any | None,
     permission_wait_metrics: Any | None = None,
+    before_permission_backup: Callable[[Any], Awaitable[None]] | None = None,
+    before_permission_claim_backup: Callable[[Any, dict[str, Any]], Awaitable[None]] | None = None,
+    record_expected_backup_generation: Callable[[str, int], Awaitable[None]] | None = None,
     wait_for_response: bool,
 ) -> Any:
     """Publish one real external permission wait, optionally detaching Normal SSE."""
@@ -571,6 +581,7 @@ async def publish_interactive_permission_boundary(
         permission_event,
         task_id=task_id,
         context_id=context_id,
+        scope="normal",
     )
     try:
         if (
@@ -585,7 +596,12 @@ async def publish_interactive_permission_boundary(
                 permission_class="normal",
                 backup_service=permission_wait_backup_service,
                 metrics=permission_wait_metrics,
+                before_backup=before_permission_backup,
+                before_claim_backup=before_permission_claim_backup,
             )
+            generation = pending.expected_backup_generation
+            if generation is not None and record_expected_backup_generation is not None:
+                await record_expected_backup_generation(task_id, generation)
         await _enqueue_status(
             event_queue,
             task_id=task_id,