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

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

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

iac_code-0.9.1/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.9.1"
+__release_date__ = "2026-07-10"

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/a2a/executor.py

@@ -39,7 +39,11 @@ from iac_code.a2a.pipeline_events import PipelineA2AContext, PipelineEventTransl
 from iac_code.a2a.pipeline_executor import IacCodeA2APipelineExecutor, recoverable_task_id_from_sidecar
 from iac_code.a2a.pipeline_journal import A2APipelineJournal
 from iac_code.a2a.pipeline_paths import existing_a2a_pipeline_dir_for_session
-from iac_code.a2a.pipeline_snapshot import A2APipelineSnapshotStore, reduce_pipeline_events
+from iac_code.a2a.pipeline_snapshot import (
+    A2APipelineSnapshotStore,
+    reduce_pipeline_events,
+    snapshot_needs_backup_commit_repair,
+)
 from iac_code.a2a.pipeline_stream import BACKUP_COMMITTED_EVENT_TYPE, PipelineA2AEventPublisher
 from iac_code.a2a.runtime_overrides import (
     a2a_request_context,
@@ -89,14 +93,21 @@ from iac_code.utils.public_paths import build_public_path_roots
 
 logger = logging.getLogger(__name__)
 _CONTEXT_LOCK_ACQUIRE_TIMEOUT_SECONDS = 1
+_CANCEL_ACTIVE_TASK_DRAIN_TIMEOUT_SECONDS = 30
 _ERROR_TEXT_MAX_CHARS = 1000
 _DEFERRED_CLEANUP_PROMPTS_FILENAME = "cleanup-deferred-prompts.json"
+_A2A_SAFE_MODE_ENV = "IAC_CODE_A2A_SAFE_MODE"
+_TRUTHY_ENV_VALUES = {"1", "true", "yes", "on"}
 
 
 def _format_exception(exc: BaseException) -> str:
     return public_exception_summary(exc, max_chars=_ERROR_TEXT_MAX_CHARS)
 
 
+def _a2a_safe_mode_enabled() -> bool:
+    return os.environ.get(_A2A_SAFE_MODE_ENV, "").strip().lower() in _TRUTHY_ENV_VALUES
+
+
 A2APermissionResolver: TypeAlias = Callable[[Any], "bool | Awaitable[bool]"]
 
 
@@ -428,7 +439,12 @@ def _a2a_pipeline_state_for_session(
         (_a2a_pipeline_sequence_number(event.get("sequence")) for event in journal_events if isinstance(event, dict)),
         default=0,
     )
-    if journal_events and (not isinstance(snapshot, dict) or journal_sequence != snapshot_sequence):
+    needs_backup_commit_repair = (
+        isinstance(snapshot, dict) and snapshot_needs_backup_commit_repair(snapshot, journal_events)
+    )
+    if journal_events and (
+        not isinstance(snapshot, dict) or journal_sequence != snapshot_sequence or needs_backup_commit_repair
+    ):
         snapshot = reduce_pipeline_events(journal_events)
         if not isinstance(snapshot, dict):
             return None
@@ -1001,6 +1017,7 @@ class IacCodeA2AExecutor(AgentExecutor):
                     session_id=session_id,
                     cwd=cwd,
                     resume_messages=resume_messages,
+                    a2a_safe_mode=_a2a_safe_mode_enabled(),
                 )
             )
 
@@ -1329,7 +1346,10 @@ class IacCodeA2AExecutor(AgentExecutor):
     async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
         task_id = context.task_id
         context_id = context.context_id or "unknown"
-        if task_id and await self._task_store.cancel_task(task_id):
+        if task_id and await self._task_store.cancel_task_and_wait(
+            task_id,
+            timeout=_CANCEL_ACTIVE_TASK_DRAIN_TIMEOUT_SECONDS,
+        ):
             await self._publish_status(
                 event_queue,
                 task_id=task_id,

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/a2a/pipeline_executor.py

@@ -90,6 +90,13 @@ _TERMINAL_EVENT_BY_SIDECAR_STATUS = {
 _PENDING_QUESTION_NOT_ROUTED = "not_routed"
 _PENDING_QUESTION_ANSWERED = "answered"
 _PENDING_QUESTION_STALE_FINISHED = "stale_finished"
+_ACTIVE_INTERRUPT_TERMINAL_WAIT_TIMEOUT_SECONDS = 30.0
+
+
+def _new_set_asyncio_event() -> asyncio.Event:
+    event = asyncio.Event()
+    event.set()
+    return event
 
 
 class WaitingInputCancelResult(str, Enum):
@@ -143,6 +150,7 @@ class A2APipelineRuntime:
     restart_after_interrupt: bool = False
     pause_after_interrupt: bool = False
     restart_requested: asyncio.Event = field(default_factory=asyncio.Event)
+    interrupt_settled: asyncio.Event = field(default_factory=_new_set_asyncio_event)
 
 
 @dataclass(frozen=True)
@@ -574,7 +582,7 @@ class IacCodeA2APipelineExecutor:
                     ctx.active_task_id = task.task_id
                 elif task.active_task is owner_task:
                     task.active_task = None
-                    if ctx.active_task_id == task.task_id and getattr(pipeline, "sidecar_status", None) != "running":
+                    if ctx.active_task_id == task.task_id:
                         ctx.active_task_id = None
                     if replacement_owner is owner_task and hasattr(ctx.runtime, "active_owner_task"):
                         ctx.runtime.active_owner_task = None
@@ -725,6 +733,8 @@ class IacCodeA2APipelineExecutor:
         paused = False
         verdict: Any | None = None
         interrupt_received_published = False
+        interrupt_settled = _interrupt_settled_event(runtime)
+        interrupt_settled.clear()
         try:
             publish_interrupt_received = getattr(publisher, "publish_interrupt_received", None)
             if callable(publish_interrupt_received):
@@ -743,9 +753,8 @@ class IacCodeA2APipelineExecutor:
                 apply_hard_interrupt = getattr(pipeline, "apply_hard_interrupt", None)
                 if callable(apply_hard_interrupt):
                     parameters = inspect.signature(apply_hard_interrupt).parameters
-                    if pipeline_input.has_images and (
-                        "source_input" in parameters
-                        or any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters.values())
+                    if "source_input" in parameters or any(
+                        parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters.values()
                     ):
                         applied = apply_hard_interrupt(verdict, source_input=runner_input)
                     else:
@@ -818,6 +827,7 @@ class IacCodeA2APipelineExecutor:
                 await self._complete_backup_blocked_transition(task=task, ctx=ctx)
             return True
         finally:
+            interrupt_settled.set()
             if paused and not bool(getattr(verdict, "paused", False)):
                 resume_agent_loops = getattr(pipeline, "resume_agent_loops", None)
                 if callable(resume_agent_loops):
@@ -1148,6 +1158,22 @@ class IacCodeA2APipelineExecutor:
                 finally:
                     next_task = None
 
+                interrupt_action = await _consume_active_interrupt_action_before_terminal(runtime, event)
+                if interrupt_action == "restart":
+                    close_stream_on_exit = True
+                    return _StreamConsumeResult(
+                        had_events=had_events,
+                        restart_requested=True,
+                        terminal_handoff_unavailable=terminal_handoff_unavailable,
+                    )
+                if interrupt_action == "pause":
+                    close_stream_on_exit = True
+                    return _StreamConsumeResult(
+                        had_events=had_events,
+                        restart_requested=False,
+                        terminal_handoff_unavailable=terminal_handoff_unavailable,
+                    )
+
                 had_events = True
                 await publish_mcp_warnings(
                     publisher.event_queue,
@@ -3410,6 +3436,72 @@ def _restart_requested_event(runtime: Any) -> asyncio.Event:
     return restart_requested
 
 
+def _interrupt_settled_event(runtime: Any) -> asyncio.Event:
+    interrupt_settled = getattr(runtime, "interrupt_settled", None)
+    if isinstance(interrupt_settled, asyncio.Event):
+        return interrupt_settled
+    interrupt_settled = _new_set_asyncio_event()
+    runtime.interrupt_settled = interrupt_settled
+    return interrupt_settled
+
+
+async def _consume_active_interrupt_action_before_terminal(runtime: Any, event: Any) -> str | None:
+    if not _is_pipeline_terminal_stream_event(event):
+        return None
+
+    action = _consume_requested_interrupt_action(runtime)
+    if action is not None:
+        return action
+
+    interrupt_settled = _interrupt_settled_event(runtime)
+    if interrupt_settled.is_set():
+        return None
+
+    restart_event = _restart_requested_event(runtime)
+    settled_task = asyncio.create_task(interrupt_settled.wait())
+    restart_task = asyncio.create_task(restart_event.wait())
+    try:
+        done, _pending = await asyncio.wait(
+            {settled_task, restart_task},
+            timeout=_ACTIVE_INTERRUPT_TERMINAL_WAIT_TIMEOUT_SECONDS,
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+    finally:
+        await _cancel_task_safely(settled_task)
+        await _cancel_task_safely(restart_task)
+
+    action = _consume_requested_interrupt_action(runtime)
+    if action is not None:
+        return action
+
+    if not done and not interrupt_settled.is_set():
+        logger.warning(
+            "Timed out waiting for active A2A pipeline interrupt before publishing terminal pipeline event"
+        )
+    return None
+
+
+def _consume_requested_interrupt_action(runtime: Any) -> str | None:
+    restart_event = _restart_requested_event(runtime)
+    if bool(getattr(runtime, "restart_after_interrupt", False)) and restart_event.is_set():
+        restart_event.clear()
+        runtime.restart_after_interrupt = False
+        return "restart"
+    if bool(getattr(runtime, "pause_after_interrupt", False)) and restart_event.is_set():
+        restart_event.clear()
+        runtime.pause_after_interrupt = False
+        return "pause"
+    return None
+
+
+def _is_pipeline_terminal_stream_event(event: Any) -> bool:
+    return isinstance(event, PipelineEvent) and event.type in {
+        PipelineEventType.PIPELINE_COMPLETED,
+        PipelineEventType.PIPELINE_ERROR,
+        PipelineEventType.BACKUP_BLOCKED,
+    }
+
+
 def _is_active_task_record(task: Any, active_task_id: str | None) -> bool:
     return active_task_id is not None and getattr(task, "task_id", None) == active_task_id
 

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/a2a/pipeline_recovery.py

@@ -13,6 +13,7 @@ from iac_code.a2a.pipeline_snapshot import (
     reduce_pipeline_events,
     sanitize_pipeline_artifact_uris,
     sanitize_pipeline_cleanup_private_fields,
+    snapshot_needs_backup_commit_repair,
 )
 from iac_code.i18n import _
 
@@ -71,6 +72,11 @@ class A2APipelineRecoveryService:
         else:
             replay_events = _events_for_task(events, task_id=recovery_task_id, context_id=context_id)
 
+        if snapshot_needs_backup_commit_repair(snapshot, replay_events):
+            snapshot = reduce_pipeline_events(replay_events)
+            snapshot_store.save(snapshot)
+            snapshot = snapshot_store.load() or snapshot
+
         if (
             snapshot is not None
             and _snapshot_schema_is_stale(snapshot)

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/a2a/pipeline_snapshot.py

@@ -1122,6 +1122,78 @@ def _backup_ack_authoritative_events(events: list[dict[str, Any]]) -> list[dict[
     return authoritative
 
 
+def snapshot_needs_backup_commit_repair(snapshot: dict[str, Any] | None, events: list[dict[str, Any]]) -> bool:
+    if not isinstance(snapshot, dict):
+        return False
+    pending_publications = _pending_backup_publications_from_snapshot(snapshot)
+    if not pending_publications:
+        return False
+
+    matching_events = [
+        event
+        for event in events
+        if isinstance(event, dict) and _event_matches_snapshot_task_context(event, snapshot)
+    ]
+    committed_by_id: dict[str, dict[str, Any]] = {}
+    committed_by_sequence_type: dict[tuple[int, str], dict[str, Any]] = {}
+    for event in matching_events:
+        if not _is_committed_backup_publication(event):
+            continue
+        event_id = _string_or_none(event.get("eventId"))
+        event_type = _string_or_none(event.get("eventType")) or ""
+        sequence = _sequence_value(event)
+        if event_id:
+            committed_by_id[event_id] = event
+        committed_by_sequence_type[(sequence, event_type)] = event
+
+    if not committed_by_id and not committed_by_sequence_type:
+        return False
+
+    for event in matching_events:
+        if event.get("eventType") != _BACKUP_COMMITTED_EVENT_TYPE:
+            continue
+        data = _dict_or_empty(event.get("data"))
+        committed_event = None
+        committed_event_id = _string_or_none(data.get("committedEventId"))
+        if committed_event_id:
+            committed_event = committed_by_id.get(committed_event_id)
+        if committed_event is None:
+            committed_event_type = _string_or_none(data.get("committedEventType")) or ""
+            committed_event = committed_by_sequence_type.get(
+                (_sequence_number(data.get("committedSequence")), committed_event_type),
+            )
+        if committed_event is None:
+            continue
+        committed_event_type = _string_or_none(committed_event.get("eventType"))
+        committed_sequence = _sequence_value(committed_event)
+        for pending in pending_publications:
+            if (
+                committed_event_type == _string_or_none(pending.get("eventType"))
+                and committed_sequence >= _sequence_value(pending)
+            ):
+                return True
+    return False
+
+
+def _pending_backup_publications_from_snapshot(snapshot: dict[str, Any]) -> list[dict[str, Any]]:
+    publications: list[dict[str, Any]] = []
+    for key in ("pendingTerminal", "pendingNormalHandoff"):
+        publication = snapshot.get(key)
+        if isinstance(publication, dict) and _publication_visibility(publication) == _PENDING_BACKUP_VISIBILITY:
+            publications.append(publication)
+    return publications
+
+
+def _event_matches_snapshot_task_context(event: dict[str, Any], snapshot: dict[str, Any]) -> bool:
+    context_id = _string_or_none(snapshot.get("contextId"))
+    if context_id is not None and event.get("contextId") != context_id:
+        return False
+    task_id = _string_or_none(snapshot.get("taskId"))
+    if task_id is None:
+        return True
+    return event.get("taskId") == task_id or event.get("deliveryTaskId") == task_id
+
+
 def _publication_visibility(event: dict[str, Any]) -> str | None:
     value = _string_or_none(event.get("visibility"))
     if value is not None:
@@ -1685,4 +1757,5 @@ __all__ = [
     "SNAPSHOT_SCHEMA_VERSION",
     "reduce_pipeline_events",
     "sanitize_pipeline_cleanup_private_fields",
+    "snapshot_needs_backup_commit_repair",
 ]

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/a2a/task_store.py

@@ -431,6 +431,28 @@ class A2ATaskStore(TaskStore):
             record.active_task.cancel()
             return True
 
+    async def cancel_task_and_wait(self, task_id: str, *, timeout: float | None = None) -> bool:
+        async with self._mutation_lock:
+            record = self._tasks.get(validate_protocol_id(task_id))
+            if record is None or record.active_task is None or record.active_task.done():
+                return False
+            active_task = record.active_task
+            active_task.cancel()
+
+        if active_task is asyncio.current_task():
+            return True
+        try:
+            if timeout is None:
+                await asyncio.shield(active_task)
+            else:
+                await asyncio.wait_for(asyncio.shield(active_task), timeout=timeout)
+        except asyncio.CancelledError:
+            if not active_task.done():
+                raise
+        except TimeoutError:
+            logger.warning("Timed out waiting for canceled A2A task %s to finish", task_id)
+        return True
+
     async def is_task_active(self, task_id: str) -> bool:
         async with self._mutation_lock:
             record = self._tasks.get(validate_protocol_id(task_id))

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/agent/agent_loop.py

@@ -1067,6 +1067,16 @@ class AgentLoop:
                             context.relative_read_directories,
                             list(effective_perm_ctx.relative_read_directories),
                         )
+                        _extend_unique(
+                            context.strict_read_directories,
+                            list(getattr(effective_perm_ctx, "strict_read_directories", [])),
+                        )
+                        context.read_path_violation_behavior = getattr(
+                            effective_perm_ctx,
+                            "read_path_violation_behavior",
+                            context.read_path_violation_behavior,
+                        )
+                        context.permission_context = effective_perm_ctx
                         permission = await check_tool_permission(tool, request.input, effective_perm_ctx)
                     else:
                         permission = await tool.check_permissions(request.input, {"cwd": context.cwd})
@@ -1266,7 +1276,7 @@ class AgentLoop:
                             tool_use_id=req.id,
                             content=processed.content,
                             is_error=result.is_error,
-                            metadata=self._tool_result_block_metadata(processed),
+                            metadata=self._tool_result_block_metadata(processed, result_metadata),
                         )
                     )
 
@@ -1396,10 +1406,30 @@ class AgentLoop:
         return cls._merge_tool_render_metadata(metadata, render_metadata)
 
     @staticmethod
-    def _tool_result_block_metadata(processed: Any) -> dict[str, Any]:
-        if not getattr(processed, "is_externalized", False) or not getattr(processed, "file_path", None):
-            return {}
-        return {EXTERNALIZED_RESULT_PATH_METADATA_KEY: str(processed.file_path)}
+    def _tool_result_block_metadata(processed: Any, result_metadata: dict[str, Any] | None = None) -> dict[str, Any]:
+        metadata: dict[str, Any] = {}
+        if getattr(processed, "is_externalized", False) and getattr(processed, "file_path", None):
+            metadata[EXTERNALIZED_RESULT_PATH_METADATA_KEY] = str(processed.file_path)
+
+        if isinstance(result_metadata, dict):
+            render_metadata = result_metadata.get(TOOL_RENDER_METADATA_KEY)
+            if isinstance(render_metadata, dict):
+                safe_render_metadata: dict[str, Any] = {}
+                for key in (
+                    TOOL_RENDER_DISPLAY_NAME_KEY,
+                    TOOL_RENDER_RESULT_COMPACT_KEY,
+                    TOOL_RENDER_RESULT_VERBOSE_KEY,
+                ):
+                    value = render_metadata.get(key)
+                    if isinstance(value, str):
+                        safe_render_metadata[key] = value
+                value = render_metadata.get(TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY)
+                if isinstance(value, bool):
+                    safe_render_metadata[TOOL_RENDER_VERBOSE_RESULT_IN_TRANSCRIPT_KEY] = value
+                if safe_render_metadata:
+                    metadata[TOOL_RENDER_METADATA_KEY] = safe_render_metadata
+
+        return metadata
 
     def _mark_read_memory_tool_result(self, request: ToolCallRequest, result: ToolResult) -> None:
         if request.name != "read_memory" or result.is_error or self._memory_recall_service is None:

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/agent/agent_tool.py

@@ -65,6 +65,7 @@ async def run_sub_agent(
         system_prompt=system_prompt,
         tool_registry=sub_registry or parent_tool_registry,
         max_turns=defn.max_turns,
+        cwd=cwd,
         permission_context=permission_context,
     )
 

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/cli/main.py

@@ -103,6 +103,7 @@ def main(
     model: str = typer.Option("", "--model", "-m", help=_("LLM model to use")),
     prompt: str = typer.Option("", "--prompt", "-p", help=_("Non-interactive mode: run a single prompt and exit")),
     output_format: str = typer.Option("text", "--output-format", help=_("Output format: text, json, stream-json")),
+    input_format: str = typer.Option("text", "--input-format", help=_("Input format: text, stream-json")),
     max_turns: int = typer.Option(100, "--max-turns", help=_("Maximum agent turns in headless mode")),
     debug: bool = typer.Option(False, "--debug", "-d", help=_("Enable debug logging")),
     verbose: bool = typer.Option(False, "--verbose", help=_("Show headless progress on stderr")),
@@ -177,6 +178,59 @@ def main(
         typer.echo(_("Error: --resume and --continue cannot be used together."), err=True)
         raise typer.Exit(1)
 
+    normalized_input_format = (input_format or "text").strip().lower()
+    if normalized_input_format not in {"text", "stream-json"}:
+        typer.echo(_("Invalid --input-format '{}'. Valid values: text, stream-json").format(input_format), err=True)
+        raise typer.Exit(1)
+
+    if normalized_input_format == "stream-json":
+        normalized_output_format = (output_format or "text").strip().lower()
+        if prompt:
+            typer.echo(_("--prompt cannot be used with --input-format stream-json."), err=True)
+            raise typer.Exit(1)
+        if normalized_output_format != "stream-json":
+            typer.echo(_("--input-format stream-json requires --output-format stream-json."), err=True)
+            raise typer.Exit(1)
+
+        from iac_code.pipeline.config import get_run_mode
+
+        run_mode = get_run_mode()
+
+        if not model:
+            try:
+                model = load_saved_model() or DEFAULT_MODEL
+            except ValueError as exc:
+                typer.echo(str(exc), err=True)
+                raise typer.Exit(1)
+
+        if permission_mode:
+            from iac_code.services.permissions.loader import parse_cli_permission_mode
+
+            try:
+                parse_cli_permission_mode(permission_mode)
+            except ValueError as exc:
+                typer.echo(str(exc), err=True)
+                raise typer.Exit(1) from exc
+
+        setup_logging(session_id="process-mode", debug=debug)
+
+        from iac_code.cli.process_mode import ProcessModeOptions, ProcessModeRunner
+
+        cli_allowed = [s.strip() for s in allowed_tools.split(",") if s.strip()] if allowed_tools else None
+        cli_disallowed = [s.strip() for s in disallowed_tools.split(",") if s.strip()] if disallowed_tools else None
+        runner = ProcessModeRunner(
+            ProcessModeOptions(
+                model=model,
+                cwd=os.getcwd(),
+                run_mode=run_mode.value,
+                max_turns=max_turns,
+                cli_allowed_tools=cli_allowed,
+                cli_disallowed_tools=cli_disallowed,
+                cli_permission_mode=permission_mode or None,
+            )
+        )
+        raise SystemExit(asyncio.run(runner.run()))
+
     fmt = None
     if prompt:
         from iac_code.cli.output_formats import OutputFormat

{iac_code-0.9.0 → iac_code-0.9.1}/src/iac_code/cli/output_formats.py

@@ -81,7 +81,8 @@ def _sanitize_public_value(value: Any, *, public_path_roots: list[dict[str, str]
     return value
 
 
-def _stream_json_event_data(event: StreamEvent) -> dict[str, Any]:
+def stream_json_event_data(event: StreamEvent) -> dict[str, Any]:
+    """Return the public stream-json representation for a stream event."""
     if isinstance(event, ToolUseStartEvent):
         return {
             "tool_use_id": event.tool_use_id,
@@ -120,7 +121,7 @@ def _stream_json_event_data(event: StreamEvent) -> dict[str, Any]:
     if isinstance(event, SubPipelineStreamEvent):
         return {
             "candidate_index": event.candidate_index,
-            "inner": _stream_json_event_data(event.inner),
+            "inner": stream_json_event_data(event.inner),
             "sub_pipeline_id": event.sub_pipeline_id,
             "type": event.type,
         }
@@ -140,6 +141,10 @@ def _stream_json_event_data(event: StreamEvent) -> dict[str, Any]:
     return data
 
 
+def _stream_json_event_data(event: StreamEvent) -> dict[str, Any]:
+    return stream_json_event_data(event)
+
+
 class TextWriter:
     """Writes only assistant text content to the output stream.
 
@@ -231,7 +236,7 @@ class StreamJsonWriter:
         self._stream = stream or sys.stdout
 
     def handle(self, event: StreamEvent) -> None:
-        data = _stream_json_event_data(event)
+        data = stream_json_event_data(event)
         self._stream.write(json.dumps(data, ensure_ascii=False, default=str))
         self._stream.write("\n")
         self._stream.flush()

iac_code-0.9.1/src/iac_code/cli/process_events.py

@@ -0,0 +1,56 @@
+"""Event and error mapping for CLI process mode."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any
+
+from iac_code.cli.output_formats import stream_json_event_data
+from iac_code.cli.process_protocol import ProcessFrameValidationError, SDKErrorPayload, SDKProcessRuntimeError
+from iac_code.providers.manager import ProviderNotConfiguredError
+from iac_code.types.stream_events import ErrorEvent
+from iac_code.utils.public_errors import sanitize_public_text
+
+
+@dataclass(frozen=True)
+class ProcessSerializedEvent:
+    """Already-public event payload to embed in a process-mode stream_event frame."""
+
+    payload: dict[str, Any]
+
+
+class ProcessEventSerializer:
+    """Serialize internal stream events to the public stream-json event shape."""
+
+    def serialize(self, event: Any) -> dict:
+        if isinstance(event, ProcessSerializedEvent):
+            return event.payload
+        return stream_json_event_data(event)
+
+
+class ProcessErrorMapper:
+    """Map runtime exceptions and error events to stable process-mode error payloads."""
+
+    def from_event(self, event: ErrorEvent) -> SDKErrorPayload:
+        return SDKErrorPayload(
+            code="stream_error",
+            message=sanitize_public_text(event.error),
+            retryable=event.is_retryable,
+            error_id=event.error_id,
+        )
+
+    def from_exception(self, exc: BaseException) -> SDKErrorPayload:
+        if isinstance(exc, SDKProcessRuntimeError):
+            return exc.payload
+        if isinstance(exc, ProcessFrameValidationError):
+            return SDKErrorPayload(code=exc.code, message=exc.message, retryable=exc.retryable)
+        if isinstance(exc, ProviderNotConfiguredError):
+            return SDKErrorPayload(
+                code="provider_not_configured",
+                message=sanitize_public_text(str(exc)),
+                retryable=False,
+            )
+        if isinstance(exc, asyncio.CancelledError):
+            return SDKErrorPayload(code="turn_canceled", message="Turn canceled.", retryable=False)
+        return SDKErrorPayload(code="internal_error", message=sanitize_public_text(str(exc)), retryable=False)