iac-code 0.11.3__tar.gz → 0.12.0__tar.gz

{iac_code-0.11.3 → iac_code-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.11.3
+Version: 0.12.0
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -86,6 +86,18 @@ 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.
 
+### Desktop App
+
+For an installed native experience, download the package for your platform from [GitHub Releases](https://github.com/aliyun/iac-code/releases):
+
+- macOS Apple Silicon: `.dmg`
+- Windows x64: setup `.exe`
+- Linux x64: `.AppImage` or `.deb`
+
+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.
+
+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. Release installers do not yet carry commercial publisher signatures, so macOS or Windows may display an unknown-developer warning; verify the accompanying `SHA256SUMS` before installation. See the [Desktop App guide](https://aliyun.github.io/iac-code/docs/desktop-app) for installation and troubleshooting details.
+
 ## Contributing
 
 Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then:

{iac_code-0.11.3 → iac_code-0.12.0}/README.md

@@ -66,6 +66,18 @@ 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.
 
+### Desktop App
+
+For an installed native experience, download the package for your platform from [GitHub Releases](https://github.com/aliyun/iac-code/releases):
+
+- macOS Apple Silicon: `.dmg`
+- Windows x64: setup `.exe`
+- Linux x64: `.AppImage` or `.deb`
+
+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.
+
+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. Release installers do not yet carry commercial publisher signatures, so macOS or Windows may display an unknown-developer warning; verify the accompanying `SHA256SUMS` before installation. See the [Desktop App guide](https://aliyun.github.io/iac-code/docs/desktop-app) for installation and troubleshooting details.
+
 ## Contributing
 
 Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then:

{iac_code-0.11.3 → iac_code-0.12.0}/pyproject.toml

@@ -30,7 +30,11 @@ dependencies = [
     "alibabacloud-oss-v2>=1.2,<2",
     "aiohttp>=3.10,<4",
     "defusedxml>=0.7,<1",
-    "alibabacloud-credentials>=0.3.0",
+    # >=1.0.8 for EcsRamRoleCredentialsProvider(async_update_enabled=...) and
+    # refreshable Credentials.get_expiration(), both required by the ECS RAM Role runtime.
+    "alibabacloud-credentials>=1.0.8",
+    # ICredentialsProvider is implemented directly by EcsRamRoleProviderAdapter.
+    "alibabacloud-credentials-api>=1.0.0",
     "loguru>=0.7.0",
     "opentelemetry-distro>=0.48b0",
     "opentelemetry-exporter-otlp>=1.27.0",
@@ -89,6 +93,12 @@ dev = [
     "tomli>=2.0; python_version<\"3.11\"",
     "pexpect>=4.9.0",
 ]
+desktop = [
+    "a2a-sdk[http-server,signing]>=1.0.2,<2",
+    "pyinstaller==6.21.0",
+    "termaid>=0.1; python_version >= '3.11'",
+    "uvicorn[standard]>=0.30.0",
+]
 
 [build-system]
 requires = ["setuptools>=68.0"]
@@ -109,6 +119,7 @@ version = {attr = "iac_code.__version__"}
     "**/*.html",
     "**/*.css",
     "**/*.js",
+    "**/*.png",
     "**/*.svg",
     "**/*.LICENSE",
     "**/*.rego",

iac_code-0.12.0/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.12.0"
+__release_date__ = "2026-08-09"

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/a2a/executor.py

@@ -1179,6 +1179,7 @@ class IacCodeA2AExecutor(AgentExecutor):
                     cwd=cwd,
                     resume_messages=resume_messages,
                     a2a_safe_mode=_a2a_safe_mode_enabled(),
+                    source="a2a",
                 )
             )
 

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/a2a/pipeline_events.py

@@ -14,6 +14,7 @@ from iac_code.a2a.pipeline_journal import to_json_safe
 from iac_code.mcp.progress import mcp_progress_metadata
 from iac_code.pipeline.engine.events import PipelineEvent, PipelineEventType
 from iac_code.services.permissions.audit import build_input_summary, build_redacted_tool_input, fingerprint_text
+from iac_code.tools.cloud.base_stack import stack_result_from_metadata
 from iac_code.types.stream_events import (
     AskUserQuestionEvent,
     CandidateDetailEvent,
@@ -900,7 +901,7 @@ class PipelineEventTranslator:
         action = operation["action"]
         params = operation["params"]
 
-        result = _json_object_from_string(event.result)
+        result = stack_result_from_metadata(event.metadata) or _json_object_from_string(event.result)
         if result is None:
             return None
         is_success = _bool_or_none(result.get("is_success"))
@@ -1480,12 +1481,15 @@ def _safe_permission_field_name(key: Any) -> str:
 
 
 def _tool_result_data(event: ToolResultEvent) -> dict[str, Any]:
-    return {
+    data = {
         "toolName": event.tool_name,
         "toolUseId": event.tool_use_id,
         "isError": event.is_error,
         "result": to_json_safe(event.result),
     }
+    if stack_result := stack_result_from_metadata(event.metadata):
+        data["stackResult"] = to_json_safe(stack_result)
+    return data
 
 
 def _sanitize_tool_input(tool_input: dict[str, Any]) -> dict[str, Any]:

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/a2a/pipeline_executor.py

@@ -87,6 +87,7 @@ _COMMITTED_BACKUP_VISIBILITY = "committed"
 _WAITING_INPUT_CANCEL_LOCKS = PathLockRegistry()
 _TERMINAL_PUBLICATION_UNAVAILABLE_KIND = "terminal_publication_unavailable"
 _HANDOFF_PUBLICATION_UNAVAILABLE_ACTION = "switch_to_normal_unavailable"
+_PREREQUISITE_METADATA_UNSET = object()
 _TERMINAL_EVENT_BY_SIDECAR_STATUS = {
     "completed": ("pipeline_completed", "completed"),
     "failed": ("pipeline_failed", "failed"),
@@ -320,6 +321,7 @@ class IacCodeA2APipelineExecutor:
                     provider_config_frozen=self._provider_config_frozen,
                     provider_config_override=self._provider_config_override,
                     effort_override=self._effort_override,
+                    source="a2a-pipeline",
                 )
             )
 
@@ -419,12 +421,29 @@ class IacCodeA2APipelineExecutor:
                         iac_code_session_id=ctx.session_id,
                     )
                     self._configure_agent_runtime_for_request(agent_runtime)
-                    pipeline = self._create_pipeline(
-                        session_id=ctx.session_id,
-                        cwd=cwd,
-                        runtime=agent_runtime,
-                        session_storage=session_storage,
-                    )
+                    if os.environ.get("IAC_CODE_DESKTOP_RUNTIME") == "1":
+                        prerequisite_metadata = await asyncio.to_thread(
+                            self._inspect_pipeline_prerequisite_metadata,
+                            pipeline_name=get_pipeline_name(),
+                            cwd=cwd,
+                            session_id=ctx.session_id,
+                            session_storage=session_storage,
+                            resume_from_sidecar=True,
+                        )
+                        pipeline = self._create_pipeline(
+                            session_id=ctx.session_id,
+                            cwd=cwd,
+                            runtime=agent_runtime,
+                            session_storage=session_storage,
+                            prerequisite_metadata=prerequisite_metadata,
+                        )
+                    else:
+                        pipeline = self._create_pipeline(
+                            session_id=ctx.session_id,
+                            cwd=cwd,
+                            runtime=agent_runtime,
+                            session_storage=session_storage,
+                        )
                     self._set_pipeline_telemetry_correlation(pipeline, task_id=task_id, context_id=context_id)
                     publisher = self._publisher(
                         event_queue=event_queue,
@@ -450,13 +469,14 @@ class IacCodeA2APipelineExecutor:
                     ctx.runtime = pipeline_runtime
                     self._task_store.mirror_context(ctx)
 
-                    def fresh_pipeline_factory() -> Any:
+                    def create_fresh_pipeline(prerequisite_metadata: object = _PREREQUISITE_METADATA_UNSET) -> Any:
                         fresh_pipeline = self._create_pipeline(
                             session_id=ctx.session_id,
                             cwd=cwd,
                             runtime=agent_runtime,
                             session_storage=session_storage,
                             resume_from_sidecar=False,
+                            prerequisite_metadata=prerequisite_metadata,
                         )
                         self._set_pipeline_telemetry_correlation(
                             fresh_pipeline,
@@ -465,6 +485,22 @@ class IacCodeA2APipelineExecutor:
                         )
                         return fresh_pipeline
 
+                    if os.environ.get("IAC_CODE_DESKTOP_RUNTIME") == "1":
+
+                        async def fresh_pipeline_factory() -> Any:
+                            prerequisite_metadata = await asyncio.to_thread(
+                                self._inspect_pipeline_prerequisite_metadata,
+                                pipeline_name=get_pipeline_name(),
+                                cwd=cwd,
+                                session_id=ctx.session_id,
+                                session_storage=session_storage,
+                                resume_from_sidecar=False,
+                            )
+                            return create_fresh_pipeline(prerequisite_metadata)
+
+                    else:
+                        fresh_pipeline_factory = create_fresh_pipeline
+
                     selected = await self._select_stream(
                         pipeline,
                         prompt,
@@ -722,6 +758,7 @@ class IacCodeA2APipelineExecutor:
                     provider_config_frozen=self._provider_config_frozen,
                     provider_config_override=self._provider_config_override,
                     effort_override=self._effort_override,
+                    source="a2a-pipeline",
                 )
             ),
         )
@@ -1154,17 +1191,20 @@ class IacCodeA2APipelineExecutor:
         runtime: Any,
         session_storage: SessionStorage,
         resume_from_sidecar: bool = True,
+        prerequisite_metadata: object = _PREREQUISITE_METADATA_UNSET,
     ) -> Any:
         pipeline_name = get_pipeline_name()
-        prerequisite_resolution = self._inspect_pipeline_prerequisite_metadata(
-            pipeline_name=pipeline_name,
-            cwd=cwd,
-            session_id=session_id,
-            session_storage=session_storage,
-            resume_from_sidecar=resume_from_sidecar,
-        )
+        prerequisite_resolution = prerequisite_metadata
+        if prerequisite_resolution is _PREREQUISITE_METADATA_UNSET:
+            prerequisite_resolution = self._inspect_pipeline_prerequisite_metadata(
+                pipeline_name=pipeline_name,
+                cwd=cwd,
+                session_id=session_id,
+                session_storage=session_storage,
+                resume_from_sidecar=resume_from_sidecar,
+            )
         create_kwargs: dict[str, Any] = {}
-        if prerequisite_resolution is not None:
+        if isinstance(prerequisite_resolution, dict):
             create_kwargs["prerequisite_resolution"] = prerequisite_resolution
         delegated_factory = self._aliyun_delegated_executor_factory
         if delegated_factory is None:
@@ -1753,10 +1793,22 @@ class IacCodeA2APipelineExecutor:
                 ctx=ctx,
             )
 
+        async def after_enqueue(envelope: dict[str, Any]) -> None:
+            await self._backup_after_pipeline_publication(
+                envelope,
+                publisher=publisher,
+                pipeline=pipeline,
+                cwd=cwd,
+                session_id=session_id,
+                task=task,
+                ctx=ctx,
+            )
+
         async def after_backup_commit(envelope: dict[str, Any]) -> None:
             self._mirror_a2a_snapshots_for_pipeline_publication(envelope, task=task, ctx=ctx)
 
         publisher.before_enqueue = before_enqueue
+        publisher.after_enqueue = after_enqueue
         publisher.after_backup_commit = after_backup_commit
 
     async def _backup_before_pipeline_publication(
@@ -1773,11 +1825,63 @@ class IacCodeA2APipelineExecutor:
         reason = _backup_reason_for_pipeline_envelope(envelope)
         if reason is None:
             return True
+        if reason in {BackupReason.INPUT_REQUIRED, BackupReason.WAITING_INPUT}:
+            return True
         if reason in {BackupReason.TERMINAL, BackupReason.HANDOFF_READY}:
             if _is_pending_backup_publication_event(envelope):
                 return True
         else:
             self._mirror_a2a_snapshots_for_pipeline_publication(envelope, task=task, ctx=ctx)
+        await self._backup_pipeline_publication(
+            envelope,
+            publisher=publisher,
+            pipeline=pipeline,
+            cwd=cwd,
+            session_id=session_id,
+            task=task,
+            ctx=ctx,
+            reason=reason,
+        )
+        return True
+
+    async def _backup_after_pipeline_publication(
+        self,
+        envelope: dict[str, Any],
+        *,
+        publisher: PipelineA2AEventPublisher,
+        pipeline: Any,
+        cwd: str,
+        session_id: str,
+        task: Any,
+        ctx: Any,
+    ) -> None:
+        reason = _backup_reason_for_pipeline_envelope(envelope)
+        if reason not in {BackupReason.INPUT_REQUIRED, BackupReason.WAITING_INPUT}:
+            return
+        self._mirror_a2a_snapshots_for_pipeline_publication(envelope, task=task, ctx=ctx)
+        await self._backup_pipeline_publication(
+            envelope,
+            publisher=publisher,
+            pipeline=pipeline,
+            cwd=cwd,
+            session_id=session_id,
+            task=task,
+            ctx=ctx,
+            reason=reason,
+        )
+
+    async def _backup_pipeline_publication(
+        self,
+        envelope: dict[str, Any],
+        *,
+        publisher: PipelineA2AEventPublisher,
+        pipeline: Any,
+        cwd: str,
+        session_id: str,
+        task: Any,
+        ctx: Any,
+        reason: BackupReason,
+    ) -> None:
         publication_proofs = None
         if reason == BackupReason.HANDOFF_READY and envelope.get("visibility") == "committed":
             publication_proofs = {
@@ -1831,7 +1935,6 @@ class IacCodeA2APipelineExecutor:
             self._task_store.mirror_task(task)
             self._task_store.mirror_context(ctx)
             raise _PipelineBackupBlockedTransitionError from exc
-        return True
 
     def _mirror_a2a_snapshots_for_pipeline_publication(
         self,
@@ -2035,7 +2138,7 @@ class IacCodeA2APipelineExecutor:
         if status in _TERMINAL_SIDECAR_STATUSES:
             if _terminal_sidecar_matches_task(publisher, status, task_id=task_id, context_id=context_id):
                 return _SelectedPipelineStream(pipeline=pipeline, stream=_empty_stream())
-            pipeline = self._fresh_pipeline_after_sidecar_mismatch(pipeline, fresh_pipeline_factory)
+            pipeline = await self._fresh_pipeline_after_sidecar_mismatch(pipeline, fresh_pipeline_factory)
             return _SelectedPipelineStream(
                 pipeline=pipeline,
                 stream=pipeline.run(_pipeline_runner_input(pipeline_input)),
@@ -2045,13 +2148,16 @@ class IacCodeA2APipelineExecutor:
             stream=pipeline.run(_pipeline_runner_input(pipeline_input)),
         )
 
-    def _fresh_pipeline_after_sidecar_mismatch(
+    async def _fresh_pipeline_after_sidecar_mismatch(
         self,
         pipeline: Any,
         fresh_pipeline_factory: Callable[[], Any],
     ) -> Any:
         self._clear_terminal_sidecar(pipeline)
-        return fresh_pipeline_factory()
+        fresh_pipeline = fresh_pipeline_factory()
+        if inspect.isawaitable(fresh_pipeline):
+            return await fresh_pipeline
+        return fresh_pipeline
 
     def _clear_terminal_sidecar(self, pipeline: Any) -> None:
         clear_sidecar = getattr(pipeline, "clear_sidecar", None)

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/a2a/pipeline_stream.py

@@ -50,6 +50,7 @@ from iac_code.utils.public_errors import sanitize_strict_text
 
 PipelinePermissionResolver = Callable[[PermissionRequestEvent], bool | Awaitable[bool]]
 PipelineBeforeEnqueueHook = Callable[[dict[str, Any]], bool | Awaitable[bool]]
+PipelineAfterEnqueueHook = Callable[[dict[str, Any]], None | Awaitable[None]]
 PipelineAfterBackupCommitHook = Callable[[dict[str, Any]], None | Awaitable[None]]
 PipelineBackupCommitGate = Callable[[dict[str, Any]], bool]
 logger = logging.getLogger(__name__)
@@ -147,6 +148,7 @@ class PipelineA2AEventPublisher:
         delivery_task_id: str | None = None,
         delivery_context_id: str | None = None,
         before_enqueue: PipelineBeforeEnqueueHook | None = None,
+        after_enqueue: PipelineAfterEnqueueHook | None = None,
         after_backup_commit: PipelineAfterBackupCommitHook | None = None,
         backup_commit_gate: PipelineBackupCommitGate | None = None,
         extreme_performance: bool | None = None,
@@ -161,6 +163,7 @@ class PipelineA2AEventPublisher:
         self.delivery_task_id = delivery_task_id
         self.delivery_context_id = delivery_context_id
         self.before_enqueue = before_enqueue
+        self.after_enqueue = after_enqueue
         self.after_backup_commit = after_backup_commit
         self.backup_commit_gate = backup_commit_gate
         self.flow_monitor = flow_monitor
@@ -715,6 +718,7 @@ class PipelineA2AEventPublisher:
                 await self._forward_local_pipeline_envelope(local_envelope)
             await self._enqueue_status(envelope, wait_for_transport=wait_for_transport)
             self.last_envelope = envelope
+            await self._run_after_enqueue_hook(envelope)
         return True
 
     async def _forward_local_pipeline_envelope(self, local_envelope: dict[str, Any]) -> None:
@@ -761,6 +765,8 @@ class PipelineA2AEventPublisher:
                 pending,
                 wait_for_transport=wait_for_transport,
             )
+            for envelope in deliverable:
+                await self._run_after_enqueue_hook(envelope)
         return frame_count
 
     async def _enqueue_persisted_batches(
@@ -899,6 +905,13 @@ class PipelineA2AEventPublisher:
             should_enqueue = await should_enqueue
         return should_enqueue is not False
 
+    async def _run_after_enqueue_hook(self, envelope: dict[str, Any]) -> None:
+        if self.after_enqueue is None:
+            return
+        result = self.after_enqueue(envelope)
+        if inspect.isawaitable(result):
+            await result
+
     async def _run_after_backup_commit_hook(self, envelope: dict[str, Any]) -> None:
         if self.after_backup_commit is None:
             return

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/a2a/task_store.py

@@ -57,6 +57,7 @@ class A2ATaskStore(TaskStore):
         self._sdk_tasks: dict[str, dict[str, Task]] = {}
         self._sdk_tasks_by_context: dict[str, dict[str, set[str]]] = {}
         self._tasks: dict[str, A2ATaskRecord] = {}
+        self._task_persistence_dirty: set[str] = set()
         self._contexts: dict[str, A2AContextRecord] = {}
         self._expired_task_tombstones: dict[str, float] = {}
         self._metrics = metrics or NoOpA2AMetrics()
@@ -99,22 +100,32 @@ class A2ATaskStore(TaskStore):
             owner_tasks[task_id] = _copy_task(task)
             self._sdk_tasks_by_context.setdefault(owner, {}).setdefault(task.context_id, set()).add(task_id)
             record = self._tasks.get(task_id)
+            next_state = _task_state_from_sdk_task(task)
+            # The SDK saves the full Task before yielding every streaming frame. Executors already
+            # mirror task records explicitly at output/state durability boundaries, so repeated SDK
+            # saves with the same projected state only need the session-local mirror below.
+            persist_shared_snapshot = (
+                record is None
+                or task_id in self._task_persistence_dirty
+                or record.state != next_state
+                or record.owner != owner
+            )
             if record is None:
                 record = A2ATaskRecord(
                     task_id=task_id,
                     context_id=task.context_id,
-                    state=_task_state_from_sdk_task(task),
+                    state=next_state,
                     owner=owner,
                     updated_at=_task_updated_at_from_sdk_task(task),
                 )
                 self._tasks[task_id] = record
                 self._metrics.record_task_created()
             else:
-                record.state = _task_state_from_sdk_task(task)
+                record.state = next_state
                 record.owner = owner
                 record.updated_at = _task_updated_at_from_sdk_task(task)
                 record.touch()
-            self._mirror_task(record)
+            self._mirror_task(record, persist_shared_snapshot=persist_shared_snapshot)
 
     def _attach_context_metadata(self, task: Task) -> None:
         context = self._contexts.get(task.context_id)
@@ -135,6 +146,7 @@ class A2ATaskStore(TaskStore):
                 self._remove_sdk_task_from_index(owner, task_id, existing.context_id)
             owner_tasks.pop(task_id, None)
             self._tasks.pop(task_id, None)
+            self._task_persistence_dirty.discard(task_id)
             self._expired_task_tombstones.pop(task_id, None)
 
     async def list(self, params: ListTasksRequest, context: ServerCallContext | None = None) -> ListTasksResponse:
@@ -798,6 +810,7 @@ class A2ATaskStore(TaskStore):
                 if now - expired_at > self._cleanup_interval_seconds:
                     self._expired_task_tombstones.pop(task_id, None)
                     self._tasks.pop(task_id, None)
+                    self._task_persistence_dirty.discard(task_id)
                     for owner, owner_tasks in list(self._sdk_tasks.items()):
                         existing = owner_tasks.pop(task_id, None)
                         if existing is not None:
@@ -846,7 +859,7 @@ class A2ATaskStore(TaskStore):
             except Exception:
                 logger.exception("A2A cleanup loop failed")
 
-    def _mirror_task(self, record: A2ATaskRecord) -> None:
+    def _mirror_task(self, record: A2ATaskRecord, *, persist_shared_snapshot: bool = True) -> None:
         snapshot = A2ATaskSnapshot(
             task_id=record.task_id,
             context_id=record.context_id,
@@ -855,10 +868,12 @@ class A2ATaskStore(TaskStore):
             output_text=list(record.output_text),
             updated_at=record.updated_at,
         )
-        if self._persistence is not None:
+        if self._persistence is not None and persist_shared_snapshot:
             try:
                 self._persistence.save_task(snapshot)
+                self._task_persistence_dirty.discard(record.task_id)
             except Exception:
+                self._task_persistence_dirty.add(record.task_id)
                 logger.exception("Failed to persist A2A task %s", record.task_id)
         self._mirror_session_task(snapshot)
 

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/a2a/transports/dispatcher.py

@@ -472,7 +472,11 @@ class IacCodeRequestHandler(DefaultRequestHandler):
         if task_id and isinstance(self.task_store, A2ATaskStore) and await self.task_store.is_task_active(task_id):
             task = await self.task_store.get(task_id, context)
             active_task = await self._active_task_registry.get(task_id)
-            if task is not None and active_task is not None and task.status.state not in TERMINAL_TASK_STATES:
+            if (
+                task is not None
+                and active_task is not None
+                and task.status.state not in TERMINAL_TASK_STATES | INTERRUPTED_TASK_STATES
+            ):
                 active_stream = self._on_active_message_send_stream(
                     params,
                     context,

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/acp/server.py

@@ -803,7 +803,7 @@ class ACPServer:
         """Create an agent runtime, converting auth errors to ACP RequestError."""
         try:
             return create_agent_runtime(
-                AgentFactoryOptions(model=model, session_id=session_id, cwd=cwd, mcp_configs=mcp_configs)
+                AgentFactoryOptions(model=model, session_id=session_id, cwd=cwd, mcp_configs=mcp_configs, source="acp")
             )
         except Exception as exc:
             if _is_auth_error(exc):

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/agent/agent_loop.py

@@ -1602,7 +1602,11 @@ class AgentLoop:
                     for request, result in denied_results
                 ]
                 for req, result in zip(requests, results):
-                    if result.metadata and result.metadata.get("step_result") is not None:
+                    if (
+                        result.metadata
+                        and result.metadata.get("step_result") is not None
+                        and result.metadata.get("complete_step_terminal", True)
+                    ):
                         terminal_step_result = True
                     processed = self._result_storage.process(req.id, result.content)
                     self._mark_read_memory_tool_result(req, result)
@@ -1815,10 +1819,12 @@ class AgentLoop:
                 ALIYUN_HTTP_METADATA_KEY,
                 sanitize_aliyun_http_metadata,
             )
+            from iac_code.tools.cloud.base_stack import persisted_stack_metadata
 
             aliyun_http = sanitize_aliyun_http_metadata(result_metadata.get(ALIYUN_HTTP_METADATA_KEY))
             if aliyun_http is not None:
                 metadata[ALIYUN_HTTP_METADATA_KEY] = aliyun_http
+            metadata.update(persisted_stack_metadata(result_metadata))
             render_metadata = result_metadata.get(TOOL_RENDER_METADATA_KEY)
             if isinstance(render_metadata, dict):
                 safe_render_metadata: dict[str, Any] = {}

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/cli/headless.py

@@ -187,6 +187,7 @@ class HeadlessRunner:
                 cli_permission_mode=self._cli_permission_mode,
                 resume_messages=resume_messages,
                 mcp_elicitation_handler=_headless_mcp_elicitation_handler,
+                source="headless",
             )
         )
         self._runtime = runtime

{iac_code-0.11.3 → iac_code-0.12.0}/src/iac_code/cli/install_git_bash.py

@@ -12,12 +12,9 @@ import subprocess
 import typer
 
 from iac_code.i18n import _
-from iac_code.utils.platform import (
-    _NPMMIRROR_CMD,
-    GitBashNotFoundError,
-    _clear_cache,
-    _find_git_bash_path,
-)
+from iac_code.services.git_bash import GitBashInstallError
+from iac_code.services.git_bash import install_git_bash as _install_git_bash
+from iac_code.utils.platform import GitBashNotFoundError, _clear_cache, _find_git_bash_path
 
 
 def install_git_bash() -> None:
@@ -43,42 +40,32 @@ def install_git_bash() -> None:
     typer.echo(_("Installing Git for Windows via npmmirror..."))
 
     try:
-        result = subprocess.run(
-            [
-                "powershell",
-                "-NoProfile",
-                "-ExecutionPolicy",
-                "Bypass",
-                "-Command",
-                _NPMMIRROR_CMD,
-            ],
-            check=False,
-        )
-    except FileNotFoundError:
-        typer.echo(
-            _("powershell.exe was not found on PATH; cannot run installer."),
-            err=True,
-        )
-        raise typer.Exit(1)
-
-    if result.returncode != 0:
-        typer.echo(
-            _("Installation failed (PowerShell exited with code {})").format(result.returncode),
-            err=True,
-        )
-        raise typer.Exit(1)
-
-    _clear_cache()
-    try:
-        path = _find_git_bash_path()
-    except GitBashNotFoundError:
-        typer.echo(
-            _(
-                "Installer exited but bash.exe was not found in common locations; "
-                "UAC may have been cancelled or the installer used a non-standard path."
-            ),
-            err=True,
+        path = _install_git_bash(
+            run=subprocess.run,
+            find=_find_git_bash_path,
+            clear_cache=_clear_cache,
+            check_existing=False,
         )
+    except GitBashInstallError as exc:
+        reason = str(exc)
+        if reason == "powershell-not-found":
+            typer.echo(
+                _("powershell.exe was not found on PATH; cannot run installer."),
+                err=True,
+            )
+        elif reason.startswith("installer-exit:"):
+            typer.echo(
+                _("Installation failed (PowerShell exited with code {})").format(reason.partition(":")[2]),
+                err=True,
+            )
+        else:
+            typer.echo(
+                _(
+                    "Installer exited but bash.exe was not found in common locations; "
+                    "UAC may have been cancelled or the installer used a non-standard path."
+                ),
+                err=True,
+            )
         raise typer.Exit(1)
 
     typer.echo("✓ " + _("Git for Windows installed at {}").format(path))