nooa-cli 0.0.10__tar.gz → 0.0.12__tar.gz

{nooa_cli-0.0.10 → nooa_cli-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nooa-cli
-Version: 0.0.10
+Version: 0.0.12
 Summary: CLI for nemo-oo-agents (`nooa` command: eval runner, trace viewer, config)
 Project-URL: Homepage, https://github.com/NVIDIA-NeMo/labs-OO-Agents
 Project-URL: Repository, https://github.com/NVIDIA-NeMo/labs-OO-Agents
@@ -9,6 +9,7 @@ License: Apache-2.0
 Requires-Python: <3.14,>=3.12
 Requires-Dist: click>=8.1.0
 Requires-Dist: nooa
+Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: ast
 Requires-Dist: tree-sitter-go>=0.23.0; extra == 'ast'
@@ -40,6 +41,8 @@ uv add "nooa-cli[datascience]"
 
 `nooa-cli` automatically pulls in matching `nemo-oo-agents` (the core framework). The `[datascience]` extra adds libraries the LLM can use in REPL-generated code.
 
+> **Windows:** use [WSL 2](https://learn.microsoft.com/windows/wsl/install). Native Windows is not supported; see the [main README](https://github.com/NVIDIA-NeMo/labs-OO-Agents#installation).
+
 ## Usage
 
 ```bash

{nooa_cli-0.0.10 → nooa_cli-0.0.12}/README.md

@@ -13,6 +13,8 @@ uv add "nooa-cli[datascience]"
 
 `nooa-cli` automatically pulls in matching `nemo-oo-agents` (the core framework). The `[datascience]` extra adds libraries the LLM can use in REPL-generated code.
 
+> **Windows:** use [WSL 2](https://learn.microsoft.com/windows/wsl/install). Native Windows is not supported; see the [main README](https://github.com/NVIDIA-NeMo/labs-OO-Agents#installation).
+
 ## Usage
 
 ```bash

{nooa_cli-0.0.10 → nooa_cli-0.0.12}/pyproject.toml

@@ -14,6 +14,7 @@ dependencies = [
     "click>=8.1.0",
     # CLI config files
     "pyyaml>=6.0",
+    "prompt-toolkit>=3.0.52",
 ]
 
 [project.urls]

{nooa_cli-0.0.10 → nooa_cli-0.0.12}/src/nooa_cli/AGENTS.md

@@ -127,6 +127,11 @@ same contract as an in-repo command module.
 - The **Performance Rule** below applies with extra force: every registered
   entry point is loaded on *every* `nooa` invocation, including `nooa --help`.
   Keep heavy imports inside the handler.
+- **Importing `nooa_cli` must not import `nooa`** (`test_connect_entrypoint.py`
+  checks this). `main()` checks the native-Windows policy itself
+  (`_refuse_unsupported_platform`, kept equal to `nooa._platform` by
+  `packages/nooa-cli/tests/test_cli_platform_check.py`) and switches redirected output to UTF-8
+  on Windows. New console entry points should go through `main()`.
 
 This mirrors the existing `nooa.skills` and `nooa.bundled_configs` groups.
 
@@ -186,6 +191,6 @@ New commands get tab-completion automatically. To enable it:
 nooa completion install   # auto-detects your shell
 
 # Or manually:
-eval "$(_NEMO_COMPLETE=zsh_source nemo)"   # zsh
-eval "$(_NEMO_COMPLETE=bash_source nemo)"  # bash
+eval "$(_NOOA_COMPLETE=zsh_source nooa)"   # zsh
+eval "$(_NOOA_COMPLETE=bash_source nooa)"  # bash
 ```

{nooa_cli-0.0.10 → nooa_cli-0.0.12}/src/nooa_cli/__init__.py

@@ -19,6 +19,9 @@ Shell completion:
     eval "$(_NOOA_COMPLETE=zsh_source nooa)"     # zsh
 """
 
+import os
+import sys
+
 import click
 
 from .commands import discover_commands
@@ -72,6 +75,56 @@ for _name, _cmd in discover_commands():
 oo.add_command(completion)
 
 
+# Same policy and wording as nooa._platform, checked here without importing
+# nooa so the CLI stays lazy (packages/nooa-cli/tests/test_cli_platform_check.py keeps them equal).
+_SKIP_PLATFORM_CHECK_ENV = "NOOA_SKIP_PLATFORM_CHECK"
+_UNSUPPORTED_PLATFORM_MESSAGE = (
+    "nooa does not support native Windows; use WSL 2 "
+    "(https://learn.microsoft.com/windows/wsl/install). "
+    f"Setting the {_SKIP_PLATFORM_CHECK_ENV} environment variable to 1 skips this check: "
+    "the pure-Python core and `nooa connect` are tested on native Windows; "
+    "other features may work but are unsupported."
+)
+
+
+def _refuse_unsupported_platform() -> None:
+    """Exit with one clean line on native Windows unless the user opted in."""
+    if sys.platform != "win32":
+        return
+    if os.environ.get(_SKIP_PLATFORM_CHECK_ENV, "").strip().lower() in {"1", "true", "yes"}:
+        return
+    raise SystemExit(f"Error: {_UNSUPPORTED_PLATFORM_MESSAGE}")
+
+
+def _is_utf8(stream) -> bool:
+    encoding = getattr(stream, "encoding", None) or ""
+    return encoding.lower().replace("-", "").replace("_", "") == "utf8"
+
+
+def _use_utf8_output() -> None:
+    """Use UTF-8 for redirected output and piped input on native Windows.
+
+    Redirected stdout/stderr and piped stdin use the ANSI code page there (for
+    example cp1252), which cannot encode the CLI's check marks and arrows and
+    would crash the command midway. Consoles already use UTF-8, so this changes
+    nothing there.
+    """
+    if sys.platform != "win32":
+        return
+    for stream in (sys.stdout, sys.stderr):
+        if stream is not None and not _is_utf8(stream) and hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+    stdin = sys.stdin
+    try:
+        piped = stdin is not None and not stdin.isatty()
+    except (OSError, ValueError):
+        piped = False
+    if piped and not _is_utf8(stdin) and hasattr(stdin, "reconfigure"):
+        stdin.reconfigure(encoding="utf-8", errors="replace")
+
+
 def main():
     """Entry point for console_scripts: nooa <subcommand>."""
+    _refuse_unsupported_platform()
+    _use_utf8_output()
     oo()

nooa_cli-0.0.12/src/nooa_cli/coding/__init__.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Shared coding-agent components used by terminal and protocol hosts."""
+
+from importlib import import_module
+
+_EXPORT_MODULES = {
+    "ActivityShellTools": "activity",
+    "FileEdit": "activity",
+    "TerminalCommandFinished": "activity",
+    "TerminalCommandOutput": "activity",
+    "TerminalCommandStarted": "activity",
+    "CodingAgent": "agent",
+    "discover_agent_instruction_files": "instructions",
+    "render_agent_instructions": "instructions",
+    "load_coding_skills_dirs": "settings",
+    "CodingSlashCommand": "slash_commands",
+    "CodingSlashCommandRegistry": "slash_commands",
+}
+
+
+def __getattr__(name: str):
+    """Load host components only when requested, not for leaf utility imports."""
+    if name not in _EXPORT_MODULES:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value = getattr(import_module(f"{__name__}.{_EXPORT_MODULES[name]}"), name)
+    globals()[name] = value
+    return value
+
+
+__all__ = [
+    "ActivityShellTools",
+    "CodingAgent",
+    "CodingSlashCommand",
+    "CodingSlashCommandRegistry",
+    "FileEdit",
+    "TerminalCommandFinished",
+    "TerminalCommandOutput",
+    "TerminalCommandStarted",
+    "discover_agent_instruction_files",
+    "load_coding_skills_dirs",
+    "render_agent_instructions",
+]

{nooa_cli-0.0.10 → nooa_cli-0.0.12}/src/nooa_cli/coding/activity.py

@@ -69,8 +69,15 @@ def _edit_diff(
     old_text: str,
     new_text: str,
     start_line: int | None,
+    *,
+    whole_file: bool = False,
 ) -> tuple[str, bool]:
-    """Return a bounded, line-oriented unified diff and its completeness."""
+    """Return a bounded, line-oriented unified diff and its completeness.
+
+    ``whole_file`` marks both texts as complete file contents, where a missing
+    final newline is a real file state worth reporting. Fragment diffs stop
+    mid-file, so the EOF marker there was noise.
+    """
     if _diff_input_is_too_large(old_text) or _diff_input_is_too_large(new_text):
         return _omitted_diff(path, "file content exceeds the safe diff preview limit")
 
@@ -91,7 +98,13 @@ def _edit_diff(
         if not line.endswith("\n"):
             # difflib emits the source line verbatim, so unterminated content
             # would run the next marker onto the same line ("-a+b").
-            line = f"{line}\n\\n"
+            if whole_file:
+                line = f"{line}\n\\n"
+            else:
+                # A fragment routinely stops before the file's final
+                # newline; marking that as "no newline at end of file"
+                # reported a file state that does not exist.
+                line = f"{line}\n"
         output.write(line)
     return output.getvalue(), not output.was_truncated
 
@@ -252,7 +265,9 @@ class ActivityShellTools(Skill):
         stdin: Annotated[
             str | None, spec(description="Text piped to stdin (replaces heredocs)")
         ] = None,
-        timeout: Annotated[float, spec(description="Max seconds")] = 30.0,
+        timeout: Annotated[
+            float | None, spec(description="Max seconds; None uses the shell's default_timeout")
+        ] = None,
     ) -> ShellResult:
         command_id = str(uuid4())
         bounded_command = pformat(command, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
@@ -313,7 +328,13 @@ class ActivityShellTools(Skill):
     async def run_stream(
         self,
         command: Annotated[str, spec(description="Shell command to execute")],
-        timeout: Annotated[float, spec(description="Max seconds to wait before timeout")] = 30.0,
+        *,
+        stdin: Annotated[
+            str | None, spec(description="Text piped to stdin (replaces heredocs)")
+        ] = None,
+        timeout: Annotated[
+            float | None, spec(description="Max seconds; None uses the shell's default_timeout")
+        ] = None,
     ) -> AsyncIterator[StreamEvent | StreamDone]:
         command_id = str(uuid4())
         bounded_command = pformat(command, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
@@ -324,12 +345,18 @@ class ActivityShellTools(Skill):
                 command=bounded_command,
                 working_directory=str(self.cwd),
                 command_truncated=command_truncated,
+                stdin=(
+                    pformat(stdin, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
+                    if stdin is not None
+                    else None
+                ),
+                stdin_truncated=stdin is not None and len(stdin) > _MAX_EVENT_TEXT_CHARS,
             )
         )
         finished = False
         stdout_buffer = TruncatingStringIO(limit=_MAX_COMMAND_OUTPUT_CHARS // 2)
         stderr_buffer = TruncatingStringIO(limit=_MAX_COMMAND_OUTPUT_CHARS // 2)
-        stream = self._shell.run_stream(command, timeout=timeout)
+        stream = self._shell.run_stream(command, stdin=stdin, timeout=timeout)
         try:
             async for item in stream:
                 if isinstance(item, StreamDone):
@@ -504,6 +531,7 @@ class ActivityShellTools(Skill):
                 old_diff_text or "",
                 content,
                 None,
+                whole_file=True,
             )
         self._emit(
             FileEdit(

{nooa_cli-0.0.10 → nooa_cli-0.0.12}/src/nooa_cli/coding/agent.py

@@ -9,12 +9,14 @@ from typing import TYPE_CHECKING, Annotated, Any
 
 from nooa import Context, hidden, strategy
 from nooa.agentdoc import doc, spec
+from nooa.agents import TokenBudgetSummarizer
 from nooa.config import CodeActConfig, PredictConfig
 from nooa.interactive import (
+    Done,
     InteractiveAgent,
-    RespondReason,
-    RespondResult,
+    NeedInput,
     SummarizationConfig,
+    Waiting,
     install_summarizer,
 )
 from nooa.paths import get_project_dir
@@ -31,7 +33,7 @@ if TYPE_CHECKING:
     from nooa.runtime.channels import Channel
     from nooa.unifiedllm import UnifiedLLM
 
-__all__ = ["CodingAgent", "RespondReason"]
+__all__ = ["CodingAgent"]
 
 
 class CodingAgent(InteractiveAgent):
@@ -41,10 +43,10 @@ class CodingAgent(InteractiveAgent):
     unrelated worktree changes. Use the shell for files and commands, the repo
     tools for definitions and references, and todos for multi-step work.
 
-    Complete and verify the requested work before returning ``DONE``. Send each
-    user-facing answer or question through ``self.message()`` as a complete
-    Markdown document. Return ``NEED_INPUT`` only when human input is required,
-    and ``WAIT`` only while an actual background job is active.
+    Complete and verify the requested work before returning ``Done``. Put the
+    reply to the user in ``Done.message`` as a complete Markdown document.
+    Return ``NeedInput`` only when human input is required, and ``Waiting``
+    only while an actual background job is active.
     """
 
     # Attributes carrying this agent's own tools. SkillRegistry refuses to let
@@ -144,16 +146,41 @@ class CodingAgent(InteractiveAgent):
         summary_tags = [tag for tag in tags if ".." in tag]
         summarizers = getattr(self, "_summarizers", [])
         summarizer = summarizers[0] if summarizers else None
+        config = getattr(summarizer, "config", None) if summarizer else None
+        pending = getattr(summarizer, "_pending_task", None) if summarizer else None
+        automatic = bool(getattr(summarizer, "_automatic_context_budget", False))
+        declared_policy = getattr(summarizer, "policy", None) if summarizer else None
+        policy = (
+            declared_policy
+            if isinstance(declared_policy, str) and declared_policy
+            else "token_budget"
+            if isinstance(summarizer, TokenBudgetSummarizer)
+            else "custom"
+            if summarizer is not None
+            else "none"
+        )
         stats = self.context_stats
         return {
             "active_events": len(tags),
             "summary_count": len(summary_tags),
             "summary_tags": summary_tags,
             "has_summarizer": summarizer is not None,
-            "policy": getattr(summarizer, "policy", "none") if summarizer else "none",
-            "current_tokens": getattr(stats, "total_tokens", 0) if stats else 0,
-            "max_tokens": getattr(summarizer, "max_tokens", 0) if summarizer else 0,
-            "preserve_recent": getattr(summarizer, "preserve_recent", 0) if summarizer else 0,
+            "policy": policy,
+            "current_tokens": getattr(stats, "prompt_tokens", 0) if stats else 0,
+            "max_tokens": getattr(config, "max_tokens", 0) if config else 0,
+            "threshold_fraction": (
+                getattr(summarizer, "_automatic_context_budget_percent", None)
+                if automatic
+                else None
+            ),
+            "preserve_recent": getattr(config, "preserve_recent", 0) if config else 0,
+            "compaction_pending": pending is not None,
+            "compaction_ready": bool(
+                pending is not None
+                and pending.done()
+                and getattr(summarizer, "_pending_summary", None)
+                and getattr(summarizer, "_pending_range", None)
+            ),
         }
 
     @hidden
@@ -165,16 +192,23 @@ class CodingAgent(InteractiveAgent):
 
     @hidden
     @strategy(CodeActStrategy(config=CodeActConfig(cell_timeout=1800.0)))
-    async def handle(self, notification: dict[str, list[Any]]) -> RespondResult:
+    async def handle(self, notification: dict[str, list[Any]]) -> Done | NeedInput | Waiting:
         """Fulfill the newest coding request delivered in ``notification``.
 
         Work until the request is complete or genuinely needs user input. Use
         as many small execution cells as necessary and inspect each result
         before proceeding. Never claim a check passed without running it.
 
-        End with exactly one ``return_result(RespondReason.<reason>,
-        explanation="...")``. The explanation must say what completed, what
-        input is needed, or which live job is still running.
+        End the turn with exactly one ``return_result(...)`` of one of these:
+
+        - ``Done(message=..., explanation=...)`` — the request is complete.
+          ``message`` is the reply the host shows the user; ``explanation``
+          is a short status line. Add ``evidence=[...]`` for checks you ran.
+        - ``NeedInput(question=...)`` — you cannot continue without an
+          answer. The host shows the question, so do not also send it with
+          ``self.message()``. Add ``options=[...]`` for a single choice.
+        - ``Waiting(message=..., explanation=..., on=[...])`` — a background
+          job is still running; ``on`` names the job or channel.
         """
         ...
 
@@ -182,6 +216,7 @@ class CodingAgent(InteractiveAgent):
     async def close(self) -> None:
         shell = self.shell
         try:
+            await self.aclose()
             await self.skills.aclose()
         finally:
             try:

nooa_cli-0.0.12/src/nooa_cli/commands/_connect_advertised_media.py

@@ -0,0 +1,142 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Wizard step that shows which media inputs the model is said to accept.
+
+Published model information (the model listing, server details or the
+OpenRouter catalogue) may list input types such as images or audio. This step
+shows those as suggestions and lets the user decide: test them, enable them
+without testing, pick them by hand, or turn media off. Listed media is never
+enabled automatically.
+"""
+
+
+def offer_suggestions(state, previous):
+    """Show the media inputs listed for the selected model and ask how to use them.
+
+    ``state`` is the wizard state; ``previous`` is the list of media inputs the
+    entry had before (shown as "Current inputs"). Depending on the answer this
+    sets ``state.test_media_inputs`` (inputs to test) or ``state.media_inputs``
+    (inputs to enable without testing).
+
+    Returns True if the user made a choice here, and False if no question was
+    asked: the choice already came from command-line options, ``--yes`` was
+    given, or nothing was suggested.
+    """
+    from nooa.unifiedllm import connect
+
+    from . import _connect_prompts as prompts
+    from . import _connect_view as view
+
+    if not state.metadata_displayed:
+        from ._connect_wizard import show_model_metadata
+
+        show_model_metadata(state)
+    from ._connect_input_policy import media_route
+    from ._connect_wizard import model_media_hints
+
+    hints = model_media_hints(state)
+    report = connect.advertised_media_suggestions(
+        hints,
+        source=(hints or {}).get(
+            "media_source", "published model information" if hints else "unknown"
+        ),
+        api_style=state.api_style,
+        entry=media_route(state),
+        decision_image_transport=state.decision_image_transport or "json",
+        typesafe_danger_zone_images=state.typesafe_danger_zone_images,
+    )
+    from ._connect_wizard import scrub_setup
+
+    view.section("Media setup")
+    for note in report["notes"]:
+        if note not in {
+            "Media support isn't listed. You can test inputs or choose them yourself.",
+            "No media is listed.",
+        }:
+            view.note(scrub_setup(state, note))
+    from ._connect_input_policy import available_media
+
+    supported = available_media(state)
+    # Formats this interface can't send are already excluded from the choices.
+    explained = [
+        (view.media_label(kind) + " test", reason)
+        for kind, reason in report["unavailable_checks"].items()
+        if kind in supported
+    ]
+    if explained:
+        view.fields(scrub_setup(state, explained))
+
+    def input_label(kind):
+        return {"audio": "Audio clips", "video": "Videos"}.get(kind, view.media_label(kind))
+
+    suggested_label = ", ".join(input_label(kind) for kind in report["suggested"])
+    checkable_label = ", ".join(input_label(kind) for kind in report["checkable"])
+    view.fields(
+        [
+            ("Suggested inputs", suggested_label),
+            ("Current inputs", ", ".join(view.media_label(kind) for kind in previous) or "Off"),
+        ]
+        if suggested_label
+        else [("Current inputs", ", ".join(view.media_label(kind) for kind in previous) or "Off")]
+    )
+    if (
+        state.media_inputs is not None
+        or state.test_media_inputs is not None
+        or state.yes
+        or not report["suggested"]
+    ):
+        return False
+    options = []
+    can_test = not state.no_probe and state.approval == "all" and bool(report["checkable"])
+    all_inputs = (
+        ["image"]
+        if state.api_style in connect.DECISION_API_STYLES
+        else ["image", "audio", "video", "pdf"]
+    )
+    all_report = connect.advertised_media_suggestions(
+        {"id": state.model, "input_modalities": all_inputs},
+        api_style=state.api_style,
+        entry=media_route(state),
+        decision_image_transport=state.decision_image_transport or "json",
+        typesafe_danger_zone_images=state.typesafe_danger_zone_images,
+    )
+    can_test_all = not state.no_probe and state.approval == "all" and bool(all_report["checkable"])
+    if can_test:
+        options.append(("test", f"Test and enable {checkable_label}"))
+    if can_test_all:
+        options.append(("test-all", "Test all media inputs"))
+    options.extend(
+        (
+            ("suggested", f"Enable {suggested_label} without testing"),
+            ("manual", "Select media inputs manually"),
+            ("none", "Turn media inputs off"),
+        )
+    )
+    action = prompts.labelled_choice(
+        "Choose how to use the listed media inputs",
+        tuple(options),
+        default="test" if can_test else "test-all" if can_test_all else "manual",
+    )
+    if action in {"test", "test-all"}:
+        state.test_media_inputs = (
+            list(report["checkable"]) if action == "test" else list(all_inputs)
+        )
+        state.media_inputs = list(previous)
+        state.inherit_media_inputs = True
+        if action == "test-all":
+            supported = available_media(state)
+            for kind, reason in all_report["unavailable_checks"].items():
+                if kind not in report["unavailable_checks"] and kind in supported:
+                    view.fields(scrub_setup(state, [(view.media_label(kind) + " test", reason)]))
+    elif action == "manual":
+        from ._connect_wizard import select_manual_media
+
+        select_manual_media(
+            state,
+            previous,
+            **({"available": ("image",)} if state.api_style in connect.DECISION_API_STYLES else {}),
+        )
+    else:
+        state.media_inputs = list(report["suggested"]) if action == "suggested" else []
+        state.inherit_media_inputs = False
+    return True

nooa_cli-0.0.12/src/nooa_cli/commands/_connect_input_policy.py

@@ -0,0 +1,124 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Which media inputs the wizard may offer for the chosen API style.
+
+Each API style can send only some media kinds (for example, the Anthropic
+Messages and OpenAI Responses clients send images and PDFs, Chat Completions
+also sends audio and video, decision clients send images). The rules live in
+``nooa.media_policy``; this module applies them to the wizard state. It limits
+the media picker to the kinds the API style can send, and asks the user to fix
+an entry whose saved media inputs include kinds the API style cannot send.
+"""
+
+import click
+
+
+def media_route(state):
+    """Return a model entry describing the endpoint and API style chosen so far.
+
+    The entry is built from the wizard state without any network request. It
+    is only used to look up which media kinds that API style can send; it says
+    nothing about what the model itself accepts.
+    """
+    if state.editing is not None:
+        # When editing, the existing entry's client and provider settings are
+        # kept unchanged, and they decide how requests are sent at runtime.
+        # The wizard's api_style label may not match them, so use the entry.
+        return state.editing
+    style = state.api_style or "chat"
+    prefix = "anthropic/" if style == "anthropic" else "openai/"
+    return {
+        "model_name": prefix + (state.model or ""),
+        "api_base": state.endpoint,
+        "client_type": "decision"
+        if style in {"systemone", "openai"}
+        else "responses"
+        if style == "responses"
+        else "completion",
+    }
+
+
+def available_media(state, *, entry=None):
+    """Return the media kinds the API style of ``entry`` (or the wizard state) can send."""
+    from nooa.media_policy import entry_input_interface, implemented_input_kinds
+
+    return implemented_input_kinds(
+        entry_input_interface(entry if entry is not None else media_route(state))
+    )
+
+
+def picker_options(state, *, entry=None):
+    """Return keyword arguments that limit the media picker to the kinds that can be sent."""
+    available = available_media(state, entry=entry)
+    # When all four kinds can be sent (Chat Completions), return no arguments so
+    # the picker is called exactly as before, with its default list of kinds.
+    return {"available": available} if len(available) != 4 else {}
+
+
+def repair_native_media(state, current, *, entry=None, explicit=False):
+    """Make sure the enabled media inputs ``current`` can be sent with this API style.
+
+    Only the Anthropic Messages and OpenAI Responses styles are checked here.
+    If every enabled kind can be sent, the list is returned unchanged. If not,
+    the user chooses: drop the kinds that cannot be sent, turn media off, or
+    cancel. The chosen list is stored on ``state`` and returned; cancel returns
+    None. Nothing is removed without the user's choice, and the saved entry
+    being edited is not modified here (only the new entry being built is).
+
+    With ``explicit`` (the list came from ``--media-inputs``) or ``--yes``,
+    there is no one to ask, so a ``click.UsageError`` is raised instead.
+    This only concerns enabled inputs; media tests chosen with "Test all" are
+    handled separately and may report kinds that were skipped.
+    """
+    from nooa.media_inputs import validate_media_inputs
+    from nooa.media_policy import (
+        entry_input_interface,
+        implemented_input_kinds,
+        unsupported_input_reason,
+    )
+
+    from . import _connect_prompts as prompts
+    from . import _connect_view as view
+
+    enabled = list(validate_media_inputs(current))
+    interface = entry_input_interface(entry if entry is not None else media_route(state))
+    if interface not in {"anthropic", "responses"}:
+        return enabled
+    available = implemented_input_kinds(interface)
+    unsupported = [kind for kind in enabled if kind not in available]
+    if not unsupported:
+        return enabled
+    reason = unsupported_input_reason(interface, unsupported)
+    if explicit or state.yes:
+        raise click.UsageError(
+            reason + " Use --media-inputs image,pdf or --media-inputs - to repair, or choose Chat."
+        )
+    view.warning(reason)
+    action = prompts.labelled_choice(
+        "Repair unsupported media permissions for this interface",
+        (
+            ("supported", "Remove unsupported inputs and keep image/PDF settings"),
+            ("off", "Turn all media inputs off"),
+            ("cancel", "Cancel without changing or saving; choose another interface"),
+        ),
+        default="cancel",
+    )
+    if action == "cancel":
+        return None
+    selected = [kind for kind in enabled if kind in available] if action == "supported" else []
+    state.media_inputs = selected
+    state.inherit_media_inputs = False
+    state.guided_media_revised = True
+    return selected
+
+
+def validate_native_declaration(state, *, entry=None):
+    """Raise ``click.UsageError`` if ``--media-inputs`` names a kind this API style cannot send.
+
+    Runs before any request is sent, so an invalid option fails early.
+    """
+    if state.media_inputs is None:
+        return
+    from ._connect_prompts import parse_media_inputs
+
+    repair_native_media(state, parse_media_inputs(state.media_inputs), entry=entry, explicit=True)