iac-code 0.2.1__tar.gz → 0.2.3__tar.gz

{iac_code-0.2.1 → iac_code-0.2.3}/PKG-INFO

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

iac_code-0.2.3/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.2.3"
+__release_date__ = "2026-05-25"

{iac_code-0.2.1 → iac_code-0.2.3}/src/iac_code/a2a/events.py

@@ -31,6 +31,7 @@ from iac_code.types.stream_events import (
 )
 
 _METADATA_MAX_CHARS = 4000
+_ERROR_TEXT_MAX_CHARS = 1000
 _METADATA_MAX_DEPTH = 32
 logger = logging.getLogger(__name__)
 A2APermissionResolver: TypeAlias = Callable[[PermissionRequestEvent], "bool | Awaitable[bool]"]
@@ -298,18 +299,19 @@ async def publish_stream_event(
         return None
 
     if isinstance(event, ErrorEvent):
+        if event.is_retryable:
+            text = "A temporary error occurred. Please retry."
+            state = TaskState.TASK_STATE_INPUT_REQUIRED
+        else:
+            raw = event.error or "Unknown error"
+            text = raw[:_ERROR_TEXT_MAX_CHARS]
+            state = TaskState.TASK_STATE_FAILED
         await _enqueue_status(
             event_queue,
             task_id=task_id,
             context_id=context_id,
-            state=TaskState.TASK_STATE_INPUT_REQUIRED if event.is_retryable else TaskState.TASK_STATE_FAILED,
-            message=_agent_text_message(
-                task_id=task_id,
-                context_id=context_id,
-                text="A temporary error occurred. Please retry."
-                if event.is_retryable
-                else "An internal error occurred.",
-            ),
+            state=state,
+            message=_agent_text_message(task_id=task_id, context_id=context_id, text=text),
         )
         return None
 

{iac_code-0.2.1 → iac_code-0.2.3}/src/iac_code/a2a/executor.py

@@ -29,6 +29,16 @@ from iac_code.services.session_storage import SessionStorage
 
 logger = logging.getLogger(__name__)
 _CONTEXT_LOCK_ACQUIRE_TIMEOUT_SECONDS = 1
+_ERROR_TEXT_MAX_CHARS = 1000
+
+
+def _format_exception(exc: BaseException) -> str:
+    message = str(exc)
+    if not message:
+        return type(exc).__name__
+    return f"{type(exc).__name__}: {message[:_ERROR_TEXT_MAX_CHARS]}"
+
+
 A2APermissionResolver: TypeAlias = Callable[[Any], "bool | Awaitable[bool]"]
 
 
@@ -274,6 +284,17 @@ class IacCodeA2AExecutor(AgentExecutor):
                 ctx.touch()
                 task.touch()
                 self._task_store.mirror_context(ctx)
+                # Force-flush telemetry between tasks. The a2a server may run in
+                # an ephemeral sandbox that's destroyed immediately after the
+                # response is delivered, before the natural batch interval or
+                # process-exit graceful_shutdown can run. Synchronous flush is
+                # offloaded to a worker thread so the event loop is not blocked.
+                from iac_code.services.telemetry import flush_telemetry
+
+                try:
+                    await asyncio.to_thread(flush_telemetry)
+                except Exception:
+                    logger.debug("flush_telemetry after task failed", exc_info=True)
         finally:
             lock.release()
 
@@ -338,7 +359,7 @@ class IacCodeA2AExecutor(AgentExecutor):
         if status == 401:
             return "Authentication required. Please configure your API credentials."
         logger.exception("Unhandled A2A executor error")
-        return "An internal error occurred."
+        return _format_exception(exc)
 
     async def _publish_status(
         self,

{iac_code-0.2.1 → iac_code-0.2.3}/src/iac_code/acp/session.py

@@ -351,6 +351,17 @@ class ACPSession:
             duration_ms = (time.monotonic() - prompt_start) * 1000
             if self._metrics is not None:
                 self._metrics.record_prompt(duration_ms)
+            # Force-flush telemetry between prompts. The acp server may run in
+            # an ephemeral sandbox that's destroyed immediately after the
+            # response is delivered, before the natural batch interval or
+            # process-exit graceful_shutdown can run. Synchronous flush is
+            # offloaded to a worker thread so the event loop is not blocked.
+            from iac_code.services.telemetry import flush_telemetry
+
+            try:
+                await asyncio.to_thread(flush_telemetry)
+            except Exception:
+                logger.debug("flush_telemetry after prompt failed", exc_info=True)
 
         self.touch()
 

{iac_code-0.2.1 → iac_code-0.2.3}/src/iac_code/cli/main.py

@@ -311,14 +311,91 @@ def acp(
     debug: bool = typer.Option(False, "--debug", "-d", help=_("Enable debug logging")),
 ) -> None:
     """Run iac-code as an ACP server."""
-    if transport == "http":
-        from iac_code.acp import acp_main_http
+    import atexit
+    import signal as _signal_mod
+    import time
+
+    from iac_code.services.telemetry import add_metric, bootstrap_telemetry, graceful_shutdown, log_event
+    from iac_code.services.telemetry.names import Events, Metrics
+
+    telemetry_session_id = f"acp-server-{uuid.uuid4()}"
+    bootstrap_telemetry(session_id=telemetry_session_id)
+    log_event(
+        Events.SESSION_STARTED,
+        {
+            "mode": "acp-server",
+            "transport": transport,
+        },
+    )
+    add_metric(Metrics.SESSION_COUNT, 1, {})
 
-        acp_main_http(host=host, port=port, debug=debug)
-    else:
-        from iac_code.acp import acp_main
+    started = time.monotonic()
+    exit_reason = "normal"
+    _finalized = [False]
+
+    def _finalize_telemetry(reason_override: str | None = None) -> None:
+        if _finalized[0]:
+            return
+        _finalized[0] = True
+        final_reason = reason_override or exit_reason
+        try:
+            log_event(
+                Events.SESSION_EXITED,
+                {
+                    "mode": "acp-server",
+                    "reason": final_reason,
+                    "duration_s": int(time.monotonic() - started),
+                },
+            )
+        finally:
+            graceful_shutdown()
+
+    atexit.register(_finalize_telemetry, "atexit")
+
+    def _telemetry_excepthook(exc_type, exc_value, traceback_obj):
+        try:
+            log_event(
+                Events.EXCEPTION_UNCAUGHT,
+                {
+                    "error_name": exc_type.__name__,
+                    "location": "acp",
+                },
+            )
+            _finalize_telemetry(f"exception:{exc_type.__name__}")
+        finally:
+            sys.__excepthook__(exc_type, exc_value, traceback_obj)
+
+    sys.excepthook = _telemetry_excepthook
+
+    _prev_sigterm = _signal_mod.getsignal(_signal_mod.SIGTERM)
+    _prev_sigint = _signal_mod.getsignal(_signal_mod.SIGINT)
+
+    def _telemetry_signal_handler(signum, frame):
+        _finalize_telemetry(f"signal:{signum}")
+        prev = _prev_sigterm if signum == _signal_mod.SIGTERM else _prev_sigint
+        if callable(prev):
+            prev(signum, frame)  # ty: ignore[call-top-callable]
+            return
+        _signal_mod.signal(signum, _signal_mod.SIG_DFL)
+        os.kill(os.getpid(), signum)
+
+    _signal_mod.signal(_signal_mod.SIGTERM, _telemetry_signal_handler)
+    _signal_mod.signal(_signal_mod.SIGINT, _telemetry_signal_handler)
+
+    try:
+        if transport == "http":
+            from iac_code.acp import acp_main_http
 
-        acp_main(debug=debug)
+            acp_main_http(host=host, port=port, debug=debug)
+        else:
+            from iac_code.acp import acp_main
+
+            acp_main(debug=debug)
+    except Exception:
+        exit_reason = "error"
+        raise
+    finally:
+        _finalize_telemetry()
 
 
 def _load_a2a_config(path: str) -> dict[str, Any]:
@@ -506,6 +583,86 @@ def a2a(
             err=True,
         )
         raise typer.Exit(1) from exc
+
+    import atexit
+    import signal as _signal_mod
+    import time
+
+    from iac_code.services.telemetry import add_metric, bootstrap_telemetry, graceful_shutdown, log_event
+    from iac_code.services.telemetry.names import Events, Metrics
+
+    telemetry_session_id = f"a2a-server-{uuid.uuid4()}"
+    bootstrap_telemetry(session_id=telemetry_session_id)
+    log_event(
+        Events.SESSION_STARTED,
+        {
+            "mode": "a2a-server",
+            "transport": transport,
+        },
+    )
+    add_metric(Metrics.SESSION_COUNT, 1, {})
+
+    started = time.monotonic()
+    exit_reason = "normal"
+    _finalized = [False]
+
+    def _finalize_telemetry(reason_override: str | None = None) -> None:
+        if _finalized[0]:
+            return
+        _finalized[0] = True
+        final_reason = reason_override or exit_reason
+        try:
+            log_event(
+                Events.SESSION_EXITED,
+                {
+                    "mode": "a2a-server",
+                    "reason": final_reason,
+                    "duration_s": int(time.monotonic() - started),
+                },
+            )
+        finally:
+            graceful_shutdown()
+
+    # atexit fires on normal interpreter exit, including after uvicorn returns
+    # from a graceful shutdown — covers the path where the finally below also
+    # ran (idempotent via the flag).
+    atexit.register(_finalize_telemetry, "atexit")
+
+    def _telemetry_excepthook(exc_type, exc_value, traceback_obj):
+        try:
+            log_event(
+                Events.EXCEPTION_UNCAUGHT,
+                {
+                    "error_name": exc_type.__name__,
+                    "location": "a2a",
+                },
+            )
+            _finalize_telemetry(f"exception:{exc_type.__name__}")
+        finally:
+            sys.__excepthook__(exc_type, exc_value, traceback_obj)
+
+    sys.excepthook = _telemetry_excepthook
+
+    # Install our own SIGTERM/SIGINT handlers BEFORE uvicorn does its own. In
+    # the common path uvicorn replaces these and triggers graceful shutdown
+    # itself, after which the finally below runs. These handlers only fire if
+    # a signal arrives before uvicorn installs its own (or if uvicorn never
+    # got a chance to) — the ARMS sandbox SIGTERM-then-SIGKILL pattern.
+    _prev_sigterm = _signal_mod.getsignal(_signal_mod.SIGTERM)
+    _prev_sigint = _signal_mod.getsignal(_signal_mod.SIGINT)
+
+    def _telemetry_signal_handler(signum, frame):
+        _finalize_telemetry(f"signal:{signum}")
+        prev = _prev_sigterm if signum == _signal_mod.SIGTERM else _prev_sigint
+        if callable(prev):
+            prev(signum, frame)  # ty: ignore[call-top-callable]
+            return
+        _signal_mod.signal(signum, _signal_mod.SIG_DFL)
+        os.kill(os.getpid(), signum)
+
+    _signal_mod.signal(_signal_mod.SIGTERM, _telemetry_signal_handler)
+    _signal_mod.signal(_signal_mod.SIGINT, _telemetry_signal_handler)
+
     try:
         if transport == "unix" and not socket_path:
             raise RuntimeError("socket-path is required in --config for --transport unix.")
@@ -547,8 +704,11 @@ def a2a(
             auto_approve_permissions=auto_approve_permissions,
         )
     except RuntimeError as exc:
+        exit_reason = "error"
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
+    finally:
+        _finalize_telemetry()
 
 
 @a2a_client_app.command(name="call", help=_("Send a prompt to an A2A JSON-RPC endpoint."))

{iac_code-0.2.1 → iac_code-0.2.3}/src/iac_code/commands/__init__.py

@@ -22,6 +22,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Show available commands"),
             handler=help_command,
             aliases=["?"],
+            history_mode="session",
         )
     )
     registry.register(
@@ -29,6 +30,7 @@ def create_default_registry() -> CommandRegistry:
             name="clear",
             description=_("Clear conversation history"),
             handler=clear_command,
+            history_mode="session",
         )
     )
     registry.register(
@@ -37,6 +39,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Show or switch model"),
             handler=model_command,
             arg_names=["model_name"],
+            history_mode="session",
         )
     )
     registry.register(
@@ -45,6 +48,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Show or switch thinking effort"),
             handler=effort_command,
             arg_names=["level"],
+            history_mode="session",
         )
     )
     registry.register(
@@ -53,6 +57,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Compact conversation context"),
             handler=compact_command,
             progress_label=_("Compacting conversation"),
+            history_mode="session",
         )
     )
     registry.register(
@@ -61,6 +66,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Exit the application"),
             handler=exit_command,
             aliases=["quit", "q"],
+            history_mode="none",
         )
     )
     registry.register(
@@ -69,6 +75,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Authenticate with LLM provider"),
             handler=auth_command,
             aliases=["login"],
+            history_mode="session",
         )
     )
     registry.register(
@@ -77,6 +84,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Toggle debug logging"),
             handler=debug_command,
             arg_hint="[on|off]",
+            history_mode="session",
         )
     )
     registry.register(
@@ -85,6 +93,7 @@ def create_default_registry() -> CommandRegistry:
             description=_("Resume a previous session"),
             handler=resume_command,
             arg_hint=_("[conversation id or search term]"),
+            history_mode="session",
         )
     )
     return registry

{iac_code-0.2.1 → iac_code-0.2.3}/src/iac_code/commands/registry.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Awaitable, Callable
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Literal
 
 from iac_code.types.skill_source import SkillSource
 
@@ -42,6 +42,12 @@ class LocalCommand(Command):
     progress_label: str | None = None
     """When set, the REPL shows a spinner with this label while the handler runs.
     Use for commands that perform slow async work (e.g. an LLM call)."""
+    history_mode: Literal["persist", "session", "none"] = "persist"
+    """Controls how the command is recorded in input history.
+    - "persist": saved to disk (default, for normal commands).
+    - "session": kept in memory for the current session only.
+    - "none": never recorded in history.
+    """
 
 
 @dataclass

{iac_code-0.2.1 → iac_code-0.2.3}/src/iac_code/config.py

@@ -16,7 +16,7 @@ from typing import Any
 import yaml
 
 # Default LLM model used when no model is saved in settings
-DEFAULT_MODEL = "qwen3.6-plus"
+DEFAULT_MODEL = "qwen3.7-max"
 
 # Configuration directory
 _CONFIG_DIR_NAME = ".iac-code"