omnimancer-cli 0.2.7__tar.gz → 0.2.10__tar.gz

{omnimancer_cli-0.2.7/omnimancer_cli.egg-info → omnimancer_cli-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.7
+Version: 0.2.10
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT
@@ -96,6 +96,9 @@ omn -p "fix the failing tests" --dangerously-skip-permissions
 
 # Verbose output / explicit config file
 omn -p "audit the security module" --verbose --config ~/.omnimancer/config.json
+
+# Raise the tool-iteration cap for big jobs (default: 25)
+omn -p "migrate every test file to pytest fixtures" --max-iterations 100
 ```
 
 The `--provider`, `--model`, and `--base-url` flags are **session overrides**: they
@@ -240,7 +243,7 @@ Tool names match the agent's toolset (`Read`, `Write`, `Edit`, `Bash`, `Glob`, `
 | `/help [command]` | Show help (optionally for a specific command) |
 | `/quit` | Exit (also: `/exit`, Ctrl+D) |
 | `/clear` | Clear terminal screen |
-| `/switch <provider> [model]` | Switch provider or model |
+| `/switch <provider> [model]` | Switch provider or model (uncataloged models are registered on the fly) |
 | `/models [filter]` | List available models (alias: `/model`) |
 | `/providers` | List all providers with status |
 | `/agent on\|off\|status` | Toggle agent mode |

{omnimancer_cli-0.2.7 → omnimancer_cli-0.2.10}/README.md

@@ -45,6 +45,9 @@ omn -p "fix the failing tests" --dangerously-skip-permissions
 
 # Verbose output / explicit config file
 omn -p "audit the security module" --verbose --config ~/.omnimancer/config.json
+
+# Raise the tool-iteration cap for big jobs (default: 25)
+omn -p "migrate every test file to pytest fixtures" --max-iterations 100
 ```
 
 The `--provider`, `--model`, and `--base-url` flags are **session overrides**: they
@@ -189,7 +192,7 @@ Tool names match the agent's toolset (`Read`, `Write`, `Edit`, `Bash`, `Glob`, `
 | `/help [command]` | Show help (optionally for a specific command) |
 | `/quit` | Exit (also: `/exit`, Ctrl+D) |
 | `/clear` | Clear terminal screen |
-| `/switch <provider> [model]` | Switch provider or model |
+| `/switch <provider> [model]` | Switch provider or model (uncataloged models are registered on the fly) |
 | `/models [filter]` | List available models (alias: `/model`) |
 | `/providers` | List all providers with status |
 | `/agent on\|off\|status` | Toggle agent mode |

{omnimancer_cli-0.2.7 → omnimancer_cli-0.2.10}/omnimancer/cli/approval_integration.py

@@ -13,7 +13,11 @@ from typing import Any, Dict, List, Optional
 
 from rich.console import Console
 
-from ..core.agent.approval_manager import BatchApprovalRequest, EnhancedApprovalManager
+from ..core.agent.approval_manager import (
+    BatchApprovalRequest,
+    ChangePreview,
+    EnhancedApprovalManager,
+)
 from ..core.agent.types import Operation, OperationType
 from ..core.security.approval_workflow import ApprovalRequest, RiskLevel
 from ..core.security.permission_controller import PermissionController
@@ -181,24 +185,7 @@ class CLIApprovalIntegration:
                 risk_level=RiskLevel.MEDIUM,  # Default, can be enhanced
             )
 
-            # Create change preview from operation
-            # Map OperationType to ChangeType (they have matching values)
-            from ..core.agent.approval_manager import ChangePreview, ChangeType
-
-            try:
-                change_type = ChangeType(operation.type.value)
-            except ValueError:
-                # Default to FILE_MODIFY if type not in ChangeType enum
-                change_type = ChangeType.FILE_MODIFY
-
-            change_preview = ChangePreview(
-                change_type=change_type,
-                description=operation.description,
-                # Use string preview as proposed_state
-                proposed_state=operation.preview,
-                metadata=operation.data,
-                reversible=operation.reversible,
-            )
+            change_preview = await self._build_change_preview(operation)
 
             # Present approval dialog and get user decision
             decision = await self.prompt_handler.prompt_for_approval(
@@ -226,6 +213,44 @@ class CLIApprovalIntegration:
             logger.error(f"Error in single approval handler: {e}", exc_info=True)
             return (False, False)
 
+    async def _build_change_preview(self, operation: Operation) -> ChangePreview:
+        """Build the ChangePreview shown in the approval dialog.
+
+        File writes and deletes go through the approval manager's rich
+        generators, which read the current file and produce a real unified
+        diff. Other operation types get a generic preview built from the
+        operation's own description/preview strings.
+        """
+        from ..core.agent.approval_manager import ChangePreview, ChangeType
+
+        if operation.type in (OperationType.FILE_WRITE, OperationType.FILE_DELETE):
+            try:
+                preview = await self.approval_manager.generate_operation_preview(
+                    operation
+                )
+                # The operation's description ("Edit file: ...") is more
+                # specific than the generator's generic one.
+                if operation.description:
+                    preview.description = operation.description
+                return preview
+            except Exception as e:
+                logger.debug(f"Rich preview failed, using generic preview: {e}")
+
+        try:
+            change_type = ChangeType(operation.type.value)
+        except ValueError:
+            # Default to FILE_MODIFY if type not in ChangeType enum
+            change_type = ChangeType.FILE_MODIFY
+
+        return ChangePreview(
+            change_type=change_type,
+            description=operation.description,
+            # Use string preview as proposed_state
+            proposed_state=operation.preview,
+            metadata=operation.data,
+            reversible=operation.reversible,
+        )
+
     async def _handle_batch_approval(
         self, batch_request: BatchApprovalRequest
     ) -> Dict[str, Any]:

{omnimancer_cli-0.2.7 → omnimancer_cli-0.2.10}/omnimancer/cli/command_dispatch.py

@@ -19,7 +19,7 @@ from rich.prompt import Confirm
 from rich.table import Table
 
 # Internal imports - Core
-from ..core.models import EnhancedModelInfo
+from ..core.models import EnhancedModelInfo, FallbackConfig
 from ..providers.factory import ProviderFactory
 
 # Internal imports - CLI
@@ -124,6 +124,8 @@ class CommandDispatchMixin:
             await self._handle_prompts_command(command)
         elif slash_cmd == SlashCommand.SUBAGENTS:
             await self._handle_subagents_command(command)
+        elif slash_cmd == SlashCommand.FALLBACK:
+            await self._handle_fallback_command(command)
         elif slash_cmd is not None:
             self._show_info(f"Command {slash_cmd.value} is not yet implemented")
 
@@ -284,6 +286,16 @@ class CommandDispatchMixin:
                 except Exception:
                     continue
 
+            # Merge in custom models (added via /add-model or /switch) —
+            # they live in config, not in any provider's static catalog.
+            try:
+                for custom in self.engine.config_manager.get_custom_models():
+                    bucket = all_models.setdefault(custom.provider, [])
+                    if not any(m.name == custom.name for m in bucket):
+                        bucket.append(custom)
+            except Exception:
+                pass
+
             # Apply filtering
             if filter_type == "provider" and filter_value:
                 all_models = {
@@ -411,6 +423,36 @@ class CommandDispatchMixin:
         except Exception as e:
             return f"Error displaying models: {e}"
 
+    def _register_model_on_the_fly(self, provider_name: str, model_name: str) -> None:
+        """Register an uncataloged model as a custom model so /switch works.
+
+        The entry persists in config, shows up in /models, and can be removed
+        with /remove-model if the endpoint turns out to reject it.
+        """
+        model_info = EnhancedModelInfo(
+            name=model_name,
+            provider=provider_name,
+            description="Added on the fly via /switch",
+            max_tokens=4096,
+            cost_per_million_input=0.0,
+            cost_per_million_output=0.0,
+            swe_score=50.0,
+            available=True,
+            supports_tools=True,
+            supports_multimodal=False,
+            latest_version=False,
+            deprecated=False,
+            release_date=datetime.now(),
+            context_window=4096,
+            is_free=False,
+        )
+        self.engine.config_manager.add_custom_model(model_info)
+        self._show_warning(
+            f"Model '{model_name}' isn't in the {provider_name} catalog — "
+            "registered it as a custom model and switching anyway. "
+            f"(/remove-model {model_name} {provider_name} to undo)"
+        )
+
     async def _handle_switch_command(self, command: Command) -> None:
         """Handle switch command with enhanced provider type support."""
         args = command.args
@@ -484,34 +526,10 @@ class CommandDispatchMixin:
                     all_model_names = model_names + custom_model_names
 
                     if model_name not in all_model_names:
-                        self._show_error(
-                            f"Model '{model_name}' not"
-                            " available for provider"
-                            f" '{provider_name}'."
-                        )
-                        if all_model_names:
-                            # Show suggestions for similar model names
-                            suggestions = [
-                                m
-                                for m in all_model_names
-                                if model_name.lower() in m.lower()
-                                or m.lower() in model_name.lower()
-                            ]
-                            if suggestions:
-                                models_str = ", ".join(suggestions[:5])
-                                self._show_info(
-                                    "Available models for"
-                                    f" {provider_name}:"
-                                    f" {models_str}"
-                                )
-                            else:
-                                models_str = ", ".join(all_model_names[:5])
-                                self._show_info(
-                                    "Available models for"
-                                    f" {provider_name}:"
-                                    f" {models_str}"
-                                )
-                        return
+                        # Static catalogs are forever stale and the endpoint
+                        # accepts any model string — register it on the fly
+                        # instead of refusing.
+                        self._register_model_on_the_fly(provider_name, model_name)
 
                 success = await self.engine.switch_model(provider_name, model_name)
 
@@ -1842,3 +1860,253 @@ Newest Entry: {stats['newest_entry'] or 'None'}"""
 
         except Exception as e:
             self._show_error(f"Failed to list custom models: {e}")
+
+    # ------------------------------------------------------------------
+    # /fallback
+    # ------------------------------------------------------------------
+
+    # --- helpers ----------------------------------------------------------
+
+    @staticmethod
+    def _validate_toggle_arg(arg: str) -> Optional[bool]:
+        """Return True/False for 'on'/'off', or None if the value is invalid.
+
+        Centralises validation of boolean toggle arguments so individual
+        subhandlers don't duplicate the same ``if toggle not in ("on", "off")``
+        check.
+        """
+        if arg == "on":
+            return True
+        if arg == "off":
+            return False
+        return None
+
+    def _persist_fallback_config(self, fb: FallbackConfig) -> None:
+        """Persist *fb* to disk and immediately sync the engine.
+
+        This single method replaces the repeated trio of:
+          ``config.fallback = fb``
+          ``self.engine.config_manager.save_config()``
+          ``self.engine.configure_fallback()``
+        across every subcommand handler.
+        """
+        config = self.engine.config_manager.get_config()
+        config.fallback = fb
+        self.engine.config_manager.save_config()
+        # Sync the engine's runtime handler immediately so changes take effect
+        # without requiring a restart.
+        self.engine.configure_fallback()
+
+    # --- dispatcher -------------------------------------------------------
+
+    async def _handle_fallback_command(self, command: Command) -> None:
+        """Handle the /fallback command family.
+
+        Sub-commands
+        ------------
+        /fallback                         show current fallback configuration
+        /fallback status                  same as above
+        /fallback auto [on|off]           toggle or query auto-fallback
+        /fallback order <p1> <p2> …       set the ordered fallback provider list
+        /fallback order clear             clear the fallback order (use any)
+        /fallback on-rate-limit [on|off]  toggle fallback on 429 errors
+        /fallback on-quota [on|off]       toggle fallback on quota errors
+        /fallback help                    show this help text
+        """
+        try:
+            config = self.engine.config_manager.get_config()
+            # Use a fresh FallbackConfig() default if the config object does
+            # not yet have a fallback section (e.g., existing installs).
+            fb: FallbackConfig = getattr(config, "fallback", FallbackConfig())
+
+            args = list(command.args) if command.args else []
+            sub = args[0].lower() if args else "status"
+
+            dispatch: dict[str, Any] = {
+                "status": lambda: self._show_fallback_status(fb),
+                "": lambda: self._show_fallback_status(fb),
+                "help": self._show_fallback_help,
+                "auto": lambda: self._handle_auto_subcommand(fb, args),
+                "order": lambda: self._handle_order_subcommand(fb, args),
+                "on-rate-limit": lambda: self._handle_on_rate_limit_subcommand(
+                    fb, args
+                ),
+                "on-quota": lambda: self._handle_on_quota_subcommand(fb, args),
+            }
+
+            handler = dispatch.get(sub)
+            if handler is None:
+                self._show_error(
+                    f"Unknown sub-command '{sub}'. "
+                    "Run [cyan]/fallback help[/cyan] for usage."
+                )
+            else:
+                result = handler()
+                # Subhandlers may be coroutines in the future; await if needed.
+                if asyncio.iscoroutine(result):
+                    await result
+
+        except ValueError as exc:
+            # Raised by subhandlers for invalid user input.
+            self._show_error(str(exc))
+        except Exception as exc:
+            logger.debug("Fallback command error", exc_info=True)
+            self._show_error(f"Failed to update fallback config: {exc}")
+
+    # --- subhandlers ------------------------------------------------------
+
+    def _handle_auto_subcommand(self, fb: FallbackConfig, args: list[str]) -> None:
+        """Handle ``/fallback auto [on|off]``."""
+        if len(args) < 2:
+            state = "on" if fb.auto_fallback else "off"
+            self._show_info(
+                f"Auto-fallback is currently [bold]{state}[/bold]. "
+                f"Use [cyan]/fallback auto on[/cyan] or "
+                f"[cyan]/fallback auto off[/cyan] to change."
+            )
+            return
+
+        enabled = self._validate_toggle_arg(args[1].lower())
+        if enabled is None:
+            raise ValueError("Usage: /fallback auto [on|off]")
+
+        fb.auto_fallback = enabled
+        self._persist_fallback_config(fb)
+        label = "enabled" if enabled else "disabled"
+        self._show_success(f"Auto-fallback {label}.")
+
+    def _handle_order_subcommand(self, fb: FallbackConfig, args: list[str]) -> None:
+        """Handle ``/fallback order [<p1> <p2> … | clear]``."""
+        if len(args) < 2:
+            order_str = " → ".join(fb.fallback_order) if fb.fallback_order else "(any)"
+            self._show_info(f"Current fallback order: {order_str}")
+            return
+
+        if args[1].lower() == "clear":
+            fb.fallback_order = []
+            self._persist_fallback_config(fb)
+            self._show_success(
+                "Fallback order cleared (will use any available provider)."
+            )
+            return
+
+        # Validate that each name is a known provider.
+        known = set(self.engine.providers.keys())
+        new_order: list[str] = []
+        unknown: list[str] = []
+        for name in args[1:]:
+            if name in known:
+                new_order.append(name)
+            else:
+                unknown.append(name)
+
+        if unknown:
+            self._show_warning(
+                f"Unknown provider(s) skipped: {', '.join(unknown)}. "
+                f"Known: {', '.join(sorted(known)) or 'none'}"
+            )
+        if not new_order:
+            raise ValueError("No valid providers specified. Nothing changed.")
+
+        fb.fallback_order = new_order
+        self._persist_fallback_config(fb)
+        self._show_success(f"Fallback order set: {' → '.join(new_order)}")
+
+    def _handle_on_rate_limit_subcommand(
+        self, fb: FallbackConfig, args: list[str]
+    ) -> None:
+        """Handle ``/fallback on-rate-limit [on|off]``."""
+        if len(args) < 2:
+            state = "on" if fb.fallback_on_rate_limit else "off"
+            self._show_info(f"Fallback on rate-limit (429) is [bold]{state}[/bold].")
+            return
+
+        enabled = self._validate_toggle_arg(args[1].lower())
+        if enabled is None:
+            raise ValueError("Usage: /fallback on-rate-limit [on|off]")
+
+        fb.fallback_on_rate_limit = enabled
+        self._persist_fallback_config(fb)
+        label = "enabled" if enabled else "disabled"
+        self._show_success(f"Fallback on rate-limit {label}.")
+
+    def _handle_on_quota_subcommand(self, fb: FallbackConfig, args: list[str]) -> None:
+        """Handle ``/fallback on-quota [on|off]``."""
+        if len(args) < 2:
+            state = "on" if fb.fallback_on_quota else "off"
+            self._show_info(f"Fallback on quota errors is [bold]{state}[/bold].")
+            return
+
+        enabled = self._validate_toggle_arg(args[1].lower())
+        if enabled is None:
+            raise ValueError("Usage: /fallback on-quota [on|off]")
+
+        fb.fallback_on_quota = enabled
+        self._persist_fallback_config(fb)
+        label = "enabled" if enabled else "disabled"
+        self._show_success(f"Fallback on quota errors {label}.")
+
+    # --- display helpers --------------------------------------------------
+
+    def _show_fallback_status(self, fb: FallbackConfig) -> None:
+        """Print a Rich table with the current fallback configuration."""
+        table = Table(
+            title="Fallback Configuration", show_header=True, header_style="bold cyan"
+        )
+        table.add_column("Setting", style="bold")
+        table.add_column("Value")
+        table.add_column("Description", style="dim")
+
+        auto_label = "[green]on[/green]" if fb.auto_fallback else "[yellow]off[/yellow]"
+        rl_label = (
+            "[green]on[/green]" if fb.fallback_on_rate_limit else "[yellow]off[/yellow]"
+        )
+        q_label = (
+            "[green]on[/green]" if fb.fallback_on_quota else "[yellow]off[/yellow]"
+        )
+        order_str = (
+            " [dim]→[/dim] ".join(fb.fallback_order)
+            if fb.fallback_order
+            else "[dim](any available)[/dim]"
+        )
+
+        table.add_row("auto", auto_label, "Switch without asking")
+        table.add_row("on-rate-limit", rl_label, "Fallback on 429 / rate-limit")
+        table.add_row("on-quota", q_label, "Fallback on quota exceeded")
+        table.add_row("order", order_str, "Ordered list of providers to try")
+
+        self.console.print(table)
+        self.console.print(
+            "\n[dim]Tip: [cyan]/fallback auto on[/cyan] to auto-switch silently, "
+            "[cyan]/fallback order claude openai[/cyan] to set priority.[/dim]"
+        )
+
+    def _show_fallback_help(self) -> None:
+        """Print /fallback usage."""
+        help_text = (
+            "[bold cyan]/fallback[/bold cyan] — manage rate-limit fallback "
+            "behaviour\n\n"
+            "[bold]Sub-commands[/bold]\n"
+            "  [cyan]/fallback[/cyan]                         "
+            "show current configuration\n"
+            "  [cyan]/fallback auto on|off[/cyan]             "
+            "auto-switch on rate limit (no prompt)\n"
+            "  [cyan]/fallback order <p1> <p2> …[/cyan]       "
+            "set ordered fallback providers\n"
+            "  [cyan]/fallback order clear[/cyan]              "
+            "clear order (use any available)\n"
+            "  [cyan]/fallback on-rate-limit on|off[/cyan]    "
+            "enable/disable fallback on 429\n"
+            "  [cyan]/fallback on-quota on|off[/cyan]         "
+            "enable/disable fallback on quota errors\n\n"
+            "[bold]Examples[/bold]\n"
+            "  [dim]/fallback auto on[/dim]                   "
+            "silently switch when rate-limited\n"
+            "  [dim]/fallback order claude openai gemini[/dim]  "
+            "try in this order\n"
+            "  [dim]/fallback order clear[/dim]               "
+            "reset to default (any provider)\n\n"
+            "When [bold]auto[/bold] is off (default), omnimancer will pause and ask:\n"
+            "  [yellow]⚠ Rate limit hit on claude. Fall back to openai? [Y/n][/yellow]"
+        )
+        self.console.print(Panel(help_text, title="Fallback Help", border_style="cyan"))

{omnimancer_cli-0.2.7 → omnimancer_cli-0.2.10}/omnimancer/cli/commands.py

@@ -62,6 +62,7 @@ class SlashCommand(Enum):
     PERMISSIONS = "/permissions"
     PROMPTS = "/prompts"
     SUBAGENTS = "/subagents"
+    FALLBACK = "/fallback"
 
     @classmethod
     def from_string(cls, command_str: str) -> Optional["SlashCommand"]:
@@ -390,7 +391,10 @@ def _validate_command_args(command: SlashCommand, args: List[str]) -> List[str]:
             if filter_type not in valid_filters:
                 filters_str = ", ".join(valid_filters)
                 raise ValueError(
-                    "Invalid filter type. Valid" f" filters: {filters_str}"
+                    f"Invalid filter type. Valid filters: {filters_str}. "
+                    "To register a new model use "
+                    "/add-model <model> <provider> — or just "
+                    "/switch <provider> <model>."
                 )
 
             # Validate second argument based on filter type

{omnimancer_cli-0.2.7 → omnimancer_cli-0.2.10}/omnimancer/cli/headless.py

@@ -10,9 +10,19 @@ import uuid
 from enum import Enum
 from typing import Any, Dict, Optional
 
-from ..core.models import ChatResponse
+from ..core.models import (
+    ChatResponse,
+    ToolResult,
+    ToolResultRecord,
+    parse_described_tool_calls,
+)
 from .system_prompts import build_agent_prompt
-from .tool_handler import MAX_TOOL_ITERATIONS, ToolHandler
+from .tool_handler import (
+    DUPLICATE_CALL_NUDGE,
+    MAX_TOOL_ITERATIONS,
+    RepeatedCallTracker,
+    ToolHandler,
+)
 
 
 class OutputFormat(Enum):
@@ -212,10 +222,14 @@ class HeadlessRunner:
         output_format: OutputFormat = OutputFormat.TEXT,
         no_approval: bool = False,
         verbose: bool = False,
+        max_iterations: Optional[int] = None,
     ) -> None:
         self._engine = engine
         self._no_approval = no_approval
         self._verbose = verbose
+        # Headless runs are unattended, so a cap (not a check-in prompt) is
+        # the safety net; --max-iterations sizes it to the job.
+        self._max_iterations = max_iterations or MAX_TOOL_ITERATIONS
         session_id = str(uuid.uuid4())
         self._emitter = HeadlessOutputEmitter(output_format, session_id, verbose)
         self._tokens = TokenAccumulator()
@@ -242,10 +256,11 @@ class HeadlessRunner:
         # Record of the actions the agent took, surfaced in the JSON result.
         tool_log: list = []
         turns = 0
-        # Detect runaway loops where a weak model repeats the same tool call.
-        seen_calls: dict = {}
+        # Identical repeated calls get skipped with a corrective nudge; the
+        # run is aborted only if the model keeps repeating despite nudges.
+        repeat_tracker = RepeatedCallTracker()
 
-        for iteration in range(MAX_TOOL_ITERATIONS):
+        for iteration in range(self._max_iterations):
             turns = iteration + 1
             response = await self._engine.send_message_with_tools(
                 current_message, tools
@@ -269,29 +284,37 @@ class HeadlessRunner:
                     last_stop_reason,
                 )
 
+            # The model may mimic the "[Called tools: ...]" history notation
+            # as plain text instead of issuing native tool calls — recover
+            # those so the run doesn't end with the work undone.
             if not response.tool_calls:
-                break
-
-            repeated = False
-            for tc in response.tool_calls:
-                sig = (
-                    f"{tc.name}:{json.dumps(tc.arguments, sort_keys=True, default=str)}"
-                )
-                seen_calls[sig] = seen_calls.get(sig, 0) + 1
-                if seen_calls[sig] >= 3:
-                    repeated = True
-            if repeated:
+                recovered = parse_described_tool_calls(response.content)
+                if not recovered:
+                    break
+                response.tool_calls = recovered
+
+            repeat_tracker.record(response.tool_calls)
+            offender = repeat_tracker.abort_offender(response.tool_calls)
+            if offender is not None:
                 if not last_content:
                     last_content = (
-                        "Stopped: the model kept repeating the same tool call."
+                        f"Stopped: the model repeated the same tool call "
+                        f"{repeat_tracker.count(offender)} times "
+                        f"({offender.name}) despite duplicate warnings."
                     )
                 break
 
             result_parts = []
-            for tc in response.tool_calls:
+            records = []
+            for i, tc in enumerate(response.tool_calls):
                 self._emitter.emit_tool_use(tc.name, tc.arguments)
 
-                result = await tool_handler.execute_tool_call(tc)
+                # Skip exact repeats with a nudge so the model can recover
+                # instead of the run being killed.
+                if repeat_tracker.is_duplicate(tc):
+                    result = ToolResult(content=DUPLICATE_CALL_NUDGE)
+                else:
+                    result = await tool_handler.execute_tool_call(tc)
                 self._emitter.emit_tool_result(
                     tc.name,
                     result.content or "",
@@ -305,13 +328,29 @@ class HeadlessRunner:
                     }
                 )
 
+                # Label results with the call's arguments so the model can
+                # tell which call each result belongs to.
+                label = f"{tc.name}({json.dumps(tc.arguments, default=str)})"
                 if result.error:
-                    result_parts.append(f"[{tc.name}] Error: {result.error}")
+                    result_parts.append(f"[{label}] Error: {result.error}")
                 else:
-                    result_parts.append(f"[{tc.name}] Result: {result.content}")
+                    result_parts.append(f"[{label}] Result: {result.content}")
+                records.append(
+                    ToolResultRecord(
+                        tool_call_id=tc.id or f"call_{i}",
+                        content=result.error or result.content,
+                    )
+                )
 
             # Feed results back without forcing the model to "continue".
-            current_message = "Tool results:\n\n" + "\n\n".join(result_parts)
+            results_text = "Tool results:\n\n" + "\n\n".join(result_parts)
+            if self._engine.provider_supports_native_tool_history() is True:
+                # Native protocol: structured history + empty continuation
+                # message (see interface._handle_tool_calling_flow).
+                self._engine.record_tool_results(results_text, records)
+                current_message = ""
+            else:
+                current_message = results_text
 
         usage = self._tokens.total
         self._emitter.emit_result(
@@ -335,6 +374,7 @@ async def run_headless(
     provider: Optional[str] = None,
     model: Optional[str] = None,
     base_url: Optional[str] = None,
+    max_iterations: Optional[int] = None,
 ) -> int:
     from ..core.config_manager import ConfigManager
     from ..core.engine import CoreEngine
@@ -370,5 +410,6 @@ async def run_headless(
         output_format=fmt,
         no_approval=no_approval,
         verbose=verbose,
+        max_iterations=max_iterations,
     )
     return await runner.run(prompt)