iac-code 0.11.2__tar.gz → 0.11.4__tar.gz

{iac_code-0.11.2 → iac_code-0.11.4}/PKG-INFO

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

iac_code-0.11.4/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.11.4"
+__release_date__ = "2026-08-07"

{iac_code-0.11.2 → iac_code-0.11.4}/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.2 → iac_code-0.11.4}/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.2 → iac_code-0.11.4}/src/iac_code/a2a/pipeline_executor.py

@@ -320,6 +320,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",
                 )
             )
 
@@ -722,6 +723,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",
                 )
             ),
         )
@@ -1753,10 +1755,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 +1787,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 +1897,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,

{iac_code-0.11.2 → iac_code-0.11.4}/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.2 → iac_code-0.11.4}/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.2 → iac_code-0.11.4}/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.2 → iac_code-0.11.4}/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.2 → iac_code-0.11.4}/src/iac_code/agent/agent_loop.py

@@ -1815,10 +1815,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.2 → iac_code-0.11.4}/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.2 → iac_code-0.11.4}/src/iac_code/cli/main.py

@@ -89,6 +89,11 @@ app.add_typer(_mcp_app, name="mcp")
 def web(
     host: str = typer.Option("127.0.0.1", help=_("HTTP server host")),
     port: int = typer.Option(8766, help=_("HTTP server port")),
+    access_token_file: str | None = typer.Option(
+        None,
+        "--access-token-file",
+        help=_("Enable encrypted public access using the token stored in this file."),
+    ),
     open_browser: bool = typer.Option(
         True,
         "--open/--no-open",
@@ -98,10 +103,18 @@ def web(
     """Run iac-code as a local Web app."""
     from iac_code.services.telemetry import bootstrap_telemetry, graceful_shutdown
     from iac_code.web.server import run_web_server
+    from iac_code.web.settings import developer_settings
 
-    bootstrap_telemetry(session_id="web-server-{}".format(uuid.uuid4()))
+    session_id = "web-server-{}".format(uuid.uuid4())
+    setup_logging(session_id=session_id, debug=bool(developer_settings().get("debug")))
+    bootstrap_telemetry(session_id=session_id)
     try:
-        run_web_server(host=host, port=port, open_browser=open_browser)
+        run_web_server(
+            host=host,
+            port=port,
+            open_browser=open_browser,
+            access_token_file=access_token_file,
+        )
     finally:
         graceful_shutdown()
 
@@ -422,6 +435,7 @@ def main(
             raise typer.Exit(1)
 
         setup_logging(session_id=repl.session_id, debug=debug)
+        repl.log_session_started()
 
         from iac_code.services.telemetry import add_metric, bootstrap_telemetry, graceful_shutdown, log_event
         from iac_code.services.telemetry.names import Events, Metrics

{iac_code-0.11.2 → iac_code-0.11.4}/src/iac_code/cli/process_mode.py

@@ -194,6 +194,7 @@ class ProcessRuntimeController:
                     cli_allowed_tools=self._options.cli_allowed_tools,
                     cli_disallowed_tools=self._options.cli_disallowed_tools,
                     cli_permission_mode=self._options.cli_permission_mode,
+                    source="process-mode",
                 )
             )
             self.session_id = runtime.session_id
@@ -780,6 +781,7 @@ class PipelineProcessRuntimeController:
                 cli_allowed_tools=self._options.cli_allowed_tools,
                 cli_disallowed_tools=self._options.cli_disallowed_tools,
                 cli_permission_mode=self._options.cli_permission_mode,
+                source="process-pipeline",
             )
         )
 

{iac_code-0.11.2 → iac_code-0.11.4}/src/iac_code/config.py

@@ -141,11 +141,6 @@ _MODEL_PREFIX_TO_PROVIDER: tuple[tuple[str, str], ...] = (
     ("doubao-", "volcengine_cn"),
 )
 
-# Module-level flag — warn once per process when IAC_CODE_BASE_URL is set
-# but the active provider is not OpenAICompatible. Reset by tests.
-_warned_base_url_ignored: bool = False
-
-
 # ---------------------------------------------------------------------------
 # Environment variable overrides
 # ---------------------------------------------------------------------------
@@ -328,12 +323,8 @@ def get_provider_config(key_name: str) -> dict[str, Any]:
     """Return the persisted per-provider config dict (empty when unset).
 
     When ``key_name`` is the active provider, IAC_CODE_MODEL and
-    IAC_CODE_BASE_URL env values are overlaid. IAC_CODE_BASE_URL only
-    applies when the active provider is ``openai_compatible``; setting
-    it for other providers logs a one-time warning and is ignored.
+    IAC_CODE_BASE_URL env values are overlaid.
     """
-    global _warned_base_url_ignored
-
     key_name = _LEGACY_KEY_NAME_ALIASES.get(key_name, key_name)
     settings = _load_yaml(get_settings_path())
     providers = settings.get("providers")
@@ -361,17 +352,7 @@ def get_provider_config(key_name: str) -> dict[str, Any]:
         if env["model"]:
             entry["model"] = env["model"]
         if env["api_base"]:
-            if active_key == "openai_compatible":
-                entry["apiBase"] = env["api_base"]
-            elif not _warned_base_url_ignored:
-                from loguru import logger
-
-                logger.warning(
-                    "IAC_CODE_BASE_URL is set but active provider is "
-                    f"{active_key!r}; the value is ignored. "
-                    "IAC_CODE_BASE_URL only applies to OpenAICompatible."
-                )
-                _warned_base_url_ignored = True
+            entry["apiBase"] = env["api_base"]
 
     return entry
 

{iac_code-0.11.2 → iac_code-0.11.4}/src/iac_code/i18n/locales/de/LC_MESSAGES/messages.po

@@ -4,7 +4,7 @@
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: iac-code 0.11.2\n"
+"Project-Id-Version: iac-code 0.11.4\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2026-06-04 15:58+0800\n"
 "PO-Revision-Date: 2026-05-13 00:00+0000\n"
@@ -727,6 +727,12 @@ msgstr "HTTP-Server-Host"
 msgid "HTTP server port"
 msgstr "HTTP-Server-Port"
 
+#: src/iac_code/cli/main.py
+msgid "Enable encrypted public access using the token stored in this file."
+msgstr ""
+"Verschlüsselten öffentlichen Zugriff mit dem Token aus dieser Datei "
+"aktivieren."
+
 #: src/iac_code/cli/main.py
 msgid ""
 "Open the Web app in the default browser on startup (use --no-open to "
@@ -4710,7 +4716,7 @@ msgstr "Alibaba Cloud Bailian Token Plan"
 
 #: src/iac_code/providers/registry.py
 msgid "OpenAI Compatible"
-msgstr "OpenAPI-kompatibel"
+msgstr "OpenAI-kompatibel"
 
 #: src/iac_code/providers/registry.py
 msgid "Kimi (China)"
@@ -11965,6 +11971,10 @@ msgstr "Lokal:  {}"
 msgid "Press Ctrl+C to stop"
 msgstr "Zum Beenden Strg+C drücken"
 
+#: src/iac_code/web/server.py
+msgid "Token mode requires an IP address as the HTTP server host."
+msgstr "Der Token-Modus erfordert eine IP-Adresse als Host des HTTP-Servers."
+
 #: src/iac_code/web/server.py
 msgid ""
 "Web server dependencies are missing. Install with: pip install 'iac-"
@@ -12039,6 +12049,22 @@ msgstr "unbekannte Partnerquelle"
 msgid "unknown aliyun credential mode"
 msgstr "unbekannter Aliyun-Anmeldeinformationsmodus"
 
+#: src/iac_code/web/settings.py
+msgid "OAuth authorization flow is invalid or expired."
+msgstr "Der OAuth-Autorisierungsablauf ist ungültig oder abgelaufen."
+
+#: src/iac_code/web/settings.py
+msgid "Authorization code is required."
+msgstr "Der Autorisierungscode ist erforderlich."
+
+#: src/iac_code/web/settings.py
+msgid "OAuth callback URL does not match the authorization flow."
+msgstr "Die OAuth-Callback-URL stimmt nicht mit dem Autorisierungsablauf überein."
+
+#: src/iac_code/web/settings.py
+msgid "OAuth callback state is invalid."
+msgstr "Der OAuth-Callback-Status ist ungültig."
+
 #: src/iac_code/web/settings.py
 msgid "stored aliyun credentials are invalid"
 msgstr "gespeicherte Aliyun-Anmeldeinformationen sind ungültig"
@@ -12726,3 +12752,4 @@ msgstr "Bash zulassen?"
 #~ msgstr ""
 #~ "Tool-Aufruf genehmigen: {tool}\n"
 #~ "Eingabezusammenfassung: {summary}"
+