zai-cli 0.1.0__py3-none-any.whl

zai/core/agent.py

@@ -0,0 +1,701 @@
+import os
+import re
+import json
+import html
+import difflib
+from pathlib import Path
+from rich.console import Console
+from rich.prompt import Confirm
+from .fallback import format_model_selection
+from .cancellation import OperationCancelled, operation, raise_if_cancelled
+
+console = Console()
+
+# Legacy in-memory marker retained for compatibility with existing integrations.
+_file_backups: dict = {}
+
+# Session token counter
+_session_tokens: int = 0
+
+LEGACY_AGENT_SYSTEM = """You are zai, a smart AI coding assistant in the terminal.
+
+TOOLS (only use when the user asks you to act on files or run something):
+
+Emit each tool call as validated JSON inside a <tool_call> wrapper:
+<tool_call>
+{"name":"write_file","arguments":{"path":"folder/file.txt","content":"file contents"}}
+</tool_call>
+
+Available names and arguments:
+- write_file: {"path": string, "content": string}
+- read_file: {"path": string}
+- edit_file: {"path": string, "search": string, "replace": string}
+- create_folder: {"path": string}
+- rename_path: {"source": string, "destination": string}
+- list_files: {"path": string} (path defaults to ".")
+- run_command: {"command": string}
+- mcp_call: {"server": string, "tool": string, "arguments": object}
+- plugin_call: {"plugin": string, "tool": string, "arguments": object}
+
+RULES:
+- For greetings, questions, or explanations → just reply in plain text, NO tools
+- Only use tools when user explicitly asks to create / edit / run something
+- When modifying an existing file → use edit_file, not write_file
+- Never show code in markdown blocks — use write_file to actually create it
+- JSON must be valid: double quotes, no comments, and no trailing commas
+- After tools run, do NOT repeat or confirm what was done — the output already shows it
+"""
+
+AGENT_SYSTEM = """You are zai, a smart AI coding assistant in the terminal.
+
+Use the tools supplied by the API only when the user asks you to act on files,
+inspect project state, or run something.
+
+RULES:
+- For greetings, questions, or explanations, reply in plain text without tools
+- Only use tools when the user asks to create, edit, inspect, or run something
+- When modifying an existing file, use edit_file rather than write_file
+- Never show code in markdown when the user asked you to create the file
+- Tool arguments must match the supplied JSON schema exactly
+- After tools run, do not repeat what the tool output already showed
+"""
+
+PLAN_SYSTEM = """You are zai in PLAN MODE. Analyze what the user wants to accomplish.
+DO NOT emit tool calls. DO NOT create or modify any files yet.
+Write a numbered plan describing exactly what you will do, file by file.
+Be specific: mention each file name, what will be created or changed.
+End your response with exactly: "Ready to execute. Type 'yes' to proceed."
+"""
+
+
+def _parse_attrs(attrs_str: str) -> dict:
+    return dict(re.findall(r'(\w+)=["\']([^"\']*)["\']', attrs_str))
+
+
+def _show_diff(old: str, new: str, path: str):
+    """Display colored unified diff between old and new content."""
+    old_lines = old.splitlines(keepends=True)
+    new_lines = new.splitlines(keepends=True)
+    diff = list(difflib.unified_diff(
+        old_lines, new_lines,
+        fromfile=f"before/{path}", tofile=f"after/{path}", n=2
+    ))
+    if not diff:
+        return
+    for line in diff[:80]:
+        line = line.rstrip()
+        if line.startswith('+') and not line.startswith('+++'):
+            console.print(f"[green]{line}[/green]")
+        elif line.startswith('-') and not line.startswith('---'):
+            console.print(f"[red]{line}[/red]")
+        elif line.startswith('@@'):
+            console.print(f"[cyan]{line}[/cyan]")
+        else:
+            console.print(f"[dim]{line}[/dim]")
+
+
+def _verify_file_content(path: Path, expected: str) -> bool:
+    """Verify that a text file exists and contains exactly what was requested."""
+    try:
+        return path.is_file() and path.read_text(
+            encoding="utf-8", errors="ignore"
+        ) == expected
+    except OSError:
+        return False
+
+
+def _rollback_file(path: Path, previous_content: str | None) -> None:
+    """Best-effort rollback for a file mutation that failed verification."""
+    try:
+        if previous_content is None:
+            if path.is_file():
+                path.unlink()
+        else:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            from .storage import atomic_write_text
+
+            atomic_write_text(
+                path,
+                previous_content,
+                mode=0o644,
+                lock=False,
+            )
+    except OSError:
+        pass
+
+
+def _execute_tool(tag: str, attrs: dict, content: str, cwd: str) -> str:
+    raise_if_cancelled()
+    from .hooks import fire, check_security
+
+    if not fire("PreToolUse", {"tool": tag, "attrs": attrs, "content": content[:200]}):
+        return f"Tool {tag} blocked by hook"
+
+    result = _execute_tool_inner(tag, attrs, content, cwd)
+
+    fire("PostToolUse", {"tool": tag, "result": result[:200]})
+    return result
+
+
+def _execute_tool_inner(tag: str, attrs: dict, content: str, cwd: str) -> str:
+    from .hooks import check_security
+    from .security import resolve_project_path
+    from .process import run_direct
+    from .errors import FileError
+    from .undo import record_created_folder, record_file_change, record_rename
+    from .storage import atomic_write_text
+
+    if tag == "write_file":
+        path = attrs.get("path", "")
+        if not path:
+            return "Error: no path given"
+        file_content = html.unescape(content)
+        warnings = check_security(file_content)
+        if warnings:
+            for w in warnings:
+                console.print(f"[yellow]  Security: {w}[/yellow]")
+        try:
+            fpath = resolve_project_path(cwd, path)
+        except FileError as e:
+            return f"Error: {e}"
+        previous_content = None
+        existed = fpath.exists()
+        # Show diff and save backup if file exists
+        if existed:
+            if not fpath.is_file():
+                return f"Error: not a file: {path}"
+            old_content = fpath.read_text(encoding="utf-8", errors="ignore")
+            previous_content = old_content
+            if old_content != file_content:
+                console.print(f"[yellow]  Modifying:[/yellow] {path}")
+                _show_diff(old_content, file_content, path)
+            else:
+                return f"File unchanged: {path}"
+
+        try:
+            fpath.parent.mkdir(parents=True, exist_ok=True)
+            atomic_write_text(fpath, file_content, mode=0o644, lock=False)
+        except OSError as e:
+            return f"Error: could not write {path}: {e}"
+        if not _verify_file_content(fpath, file_content):
+            _rollback_file(fpath, previous_content if existed else None)
+            return f"Error: verification failed after writing {path}; change rolled back"
+        undo_recorded = record_file_change(
+            cwd,
+            fpath,
+            previous_content if existed else None,
+        )
+        if existed and not undo_recorded:
+            console.print(
+                "[yellow]  Undo backup skipped for sensitive or oversized file.[/yellow]"
+            )
+        size = len(file_content)
+        console.print(f"[green]  Created:[/green] {fpath}  ({size} chars)")
+        return f"File created: {path} ({size} chars)"
+
+    elif tag == "edit_file":
+        path = attrs.get("path", "")
+        try:
+            fpath = resolve_project_path(cwd, path)
+        except FileError as e:
+            return f"Error: {e}"
+        if not fpath.exists():
+            return f"Error: file not found: {path}"
+        if not fpath.is_file():
+            return f"Error: not a file: {path}"
+        search_m = re.search(r'<search>(.*?)</search>', content, re.DOTALL)
+        replace_m = re.search(r'<replace>(.*?)</replace>', content, re.DOTALL)
+        if not search_m or not replace_m:
+            return "Error: edit_file needs <search>...</search> and <replace>...</replace> tags"
+        search_text = html.unescape(search_m.group(1).strip('\n'))
+        replace_text = html.unescape(replace_m.group(1).strip('\n'))
+        old_content = fpath.read_text(encoding="utf-8", errors="ignore")
+        if search_text not in old_content:
+            return f"Error: search text not found in {path}. Use read_file first to check exact content."
+        new_content = old_content.replace(search_text, replace_text, 1)
+        console.print(f"[yellow]  Editing:[/yellow] {path}")
+        _show_diff(old_content, new_content, path)
+        try:
+            atomic_write_text(fpath, new_content, mode=0o644, lock=False)
+        except OSError as e:
+            return f"Error: could not edit {path}: {e}"
+        if not _verify_file_content(fpath, new_content):
+            _rollback_file(fpath, old_content)
+            return f"Error: verification failed after editing {path}; change rolled back"
+        if not record_file_change(cwd, fpath, old_content):
+            console.print(
+                "[yellow]  Undo backup skipped for sensitive or oversized file.[/yellow]"
+            )
+        console.print(f"[green]  Edited:[/green] {path}")
+        return f"File edited: {path}"
+
+    elif tag == "read_file":
+        path = attrs.get("path", "")
+        try:
+            fpath = resolve_project_path(cwd, path)
+        except FileError as e:
+            return f"Error: {e}"
+        if not fpath.exists():
+            matches = [f for f in os.listdir(cwd) if os.path.splitext(f)[0] == path or f == path]
+            if matches:
+                fpath = resolve_project_path(cwd, matches[0])
+            else:
+                return f"File not found: {path}"
+        if not fpath.is_file():
+            return f"Error: not a file: {path}"
+        text = fpath.read_text(encoding="utf-8", errors="ignore")
+        console.print(f"[dim]  Read: {fpath.name} ({len(text)} chars)[/dim]")
+        return f"Contents of {fpath.name}:\n{text[:4000]}"
+
+    elif tag == "create_folder":
+        path = attrs.get("path", "")
+        try:
+            fpath = resolve_project_path(cwd, path)
+        except FileError as e:
+            return f"Error: {e}"
+        existed = fpath.exists()
+        try:
+            fpath.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            return f"Error: could not create folder {path}: {e}"
+        if not fpath.is_dir():
+            return f"Error: verification failed after creating folder {path}"
+        if not existed:
+            record_created_folder(cwd, fpath)
+        console.print(f"[green]  Folder:[/green] {fpath}")
+        return f"Folder created: {path}"
+
+    elif tag == "rename_path":
+        source = attrs.get("from", "")
+        destination = attrs.get("to", "")
+        if not source or not destination:
+            return "Error: rename_path needs from= and to= attributes"
+
+        try:
+            source_path = resolve_project_path(cwd, source)
+            destination_path = resolve_project_path(cwd, destination)
+        except FileError as e:
+            return f"Error: {e}"
+        if not source_path.exists():
+            return f"Error: path not found: {source}"
+        if destination_path.exists():
+            return f"Error: destination already exists: {destination}"
+
+        source_was_dir = source_path.is_dir()
+        try:
+            destination_path.parent.mkdir(parents=True, exist_ok=True)
+            source_path.rename(destination_path)
+        except OSError as e:
+            return f"Error: could not rename {source} to {destination}: {e}"
+        rename_verified = (
+            not source_path.exists()
+            and destination_path.exists()
+            and destination_path.is_dir() == source_was_dir
+        )
+        if not rename_verified:
+            try:
+                if destination_path.exists() and not source_path.exists():
+                    destination_path.rename(source_path)
+            except OSError:
+                pass
+            return (
+                f"Error: verification failed after renaming {source} to "
+                f"{destination}; rollback attempted"
+            )
+        record_rename(cwd, source_path, destination_path)
+        console.print(f"[green]  Renamed:[/green] {source} -> {destination}")
+        return f"Path renamed: {source} -> {destination}"
+
+    elif tag == "list_files":
+        path = attrs.get("path", ".")
+        try:
+            fpath = resolve_project_path(cwd, path, allow_root=True)
+        except FileError as e:
+            return f"Error: {e}"
+        if not fpath.exists():
+            return f"Directory not found: {path}"
+        if not fpath.is_dir():
+            return f"Error: not a directory: {path}"
+        items = sorted(os.listdir(fpath))
+        result = "\n".join(
+            f"{'[dir] ' if (fpath / i).is_dir() else ''}{i}" for i in items
+        )
+        console.print(f"[dim]  Listed: {fpath}[/dim]")
+        return f"Files in {path}:\n{result}"
+
+    elif tag == "run_command":
+        cmd = content.strip()
+        if not cmd:
+            return "Error: no command given"
+        console.print(f"[yellow]  Run:[/yellow] {cmd}")
+        result = run_direct(
+            cmd,
+            cwd=cwd,
+            timeout=30,
+            approval=lambda reason: Confirm.ask(
+                f"  Approval required ({reason}). Run it?",
+                default=False,
+            ),
+        )
+        if result.blocked_reason:
+            return f"Error: command blocked ({result.blocked_reason})"
+        if result.cancelled:
+            return "Command cancelled"
+        if result.returncode != 0:
+            details = result.output[:1800] if result.output else "no output"
+            return f"Error: command failed with exit code {result.returncode}: {details}"
+        return result.output[:2000] if result.output else "Done (no output)"
+
+    elif tag == "mcp_call":
+        server = attrs.get("server", "")
+        tool = attrs.get("tool", "")
+        if not server or not tool:
+            return "Error: mcp_call needs server= and tool= attributes"
+        try:
+            arguments = json.loads(content) if content.strip() else {}
+        except Exception:
+            arguments = {}
+        if not Confirm.ask(
+            f"  Allow MCP tool {server}/{tool} with arguments {arguments}?",
+            default=False,
+        ):
+            return "MCP tool call cancelled"
+        console.print(f"[magenta]  MCP:[/magenta] {server}/{tool}")
+        try:
+            from ..mcp.client import call_mcp_tool
+            result = call_mcp_tool(server, tool, arguments)
+        except Exception as e:
+            result = f"MCP error: {e}"
+        raise_if_cancelled()
+        return result
+
+    elif tag == "plugin_call":
+        plugin_name = attrs.get("plugin", "")
+        tool_name = attrs.get("tool", "")
+        if not plugin_name or not tool_name:
+            return "Error: plugin_call needs plugin= and tool= attributes"
+        try:
+            arguments = json.loads(content) if content.strip() else {}
+        except Exception:
+            arguments = {}
+        from ..plugins.loader import get_manifest
+
+        manifest = get_manifest(plugin_name) or {}
+        permissions = ", ".join(manifest.get("permissions", [])) or "none"
+        if not Confirm.ask(
+            f"  Allow trusted plugin tool {plugin_name}/{tool_name} "
+            f"(permissions: {permissions})?",
+            default=False,
+        ):
+            return "Plugin tool call cancelled"
+        console.print(f"[blue]  Plugin:[/blue] {plugin_name}/{tool_name}")
+        try:
+            from ..plugins.loader import get_loaded
+            plugins = get_loaded()
+            if plugin_name not in plugins:
+                return f"Plugin '{plugin_name}' not loaded. Run: zai plugin list"
+            plugin = plugins[plugin_name]
+            tools = plugin.get_tools()
+            if tool_name not in tools:
+                return f"Tool '{tool_name}' not found in plugin '{plugin_name}'"
+            result = tools[tool_name](**arguments)
+            raise_if_cancelled()
+            return str(result)
+        except OperationCancelled:
+            raise
+        except Exception as e:
+            return f"Plugin error: {e}"
+
+    return f"Unknown tool: {tag}"
+
+
+TOOL_PATTERN = re.compile(
+    r'<(write_file|read_file|create_folder|rename_path|list_files|run_command|edit_file|mcp_call|plugin_call)([^>]*)(?:>(.*?)</\1>|/>)',
+    re.DOTALL,
+)
+STRUCTURED_TOOL_PATTERN = re.compile(
+    r"<tool_call>\s*(.*?)\s*</tool_call>",
+    re.DOTALL,
+)
+
+
+def _structured_to_legacy(name: str, arguments: dict) -> tuple[dict, str]:
+    """Adapt validated JSON arguments to the existing execution implementation."""
+    if name == "write_file":
+        return {"path": arguments["path"]}, arguments["content"]
+    if name == "edit_file":
+        content = (
+            f"<search>{html.escape(arguments['search'])}</search>"
+            f"<replace>{html.escape(arguments['replace'])}</replace>"
+        )
+        return {"path": arguments["path"]}, content
+    if name in {"read_file", "create_folder", "list_files"}:
+        return {"path": arguments["path"]}, ""
+    if name == "rename_path":
+        return {
+            "from": arguments["source"],
+            "to": arguments["destination"],
+        }, ""
+    if name == "run_command":
+        return {}, arguments["command"]
+    if name == "mcp_call":
+        return {
+            "server": arguments["server"],
+            "tool": arguments["tool"],
+        }, json.dumps(arguments["arguments"])
+    if name == "plugin_call":
+        return {
+            "plugin": arguments["plugin"],
+            "tool": arguments["tool"],
+        }, json.dumps(arguments["arguments"])
+    return {}, ""
+
+
+def _load_system(cwd: str) -> str:
+    """Build system prompt: CLAUDE.md (project) + global + AGENT_SYSTEM + MCP tools."""
+    parts = []
+
+    # Global user instructions
+    global_md = Path.home() / ".zai" / "CLAUDE.md"
+    if global_md.exists():
+        txt = global_md.read_text(encoding="utf-8", errors="ignore").strip()
+        if txt:
+            parts.append(f"USER INSTRUCTIONS (global ~/.zai/CLAUDE.md):\n{txt}")
+
+    # Project instructions
+    project_md = Path(cwd) / "CLAUDE.md"
+    if project_md.exists():
+        txt = project_md.read_text(encoding="utf-8", errors="ignore").strip()
+        if txt:
+            parts.append(f"PROJECT INSTRUCTIONS (CLAUDE.md):\n{txt}")
+
+    parts.append(AGENT_SYSTEM)
+
+    # Active MCP tools
+    try:
+        from ..mcp.client import get_all_tools
+        all_tools = get_all_tools()
+        if all_tools:
+            mcp_lines = ["\nMCP TOOLS AVAILABLE through mcp_call:"]
+            for server, tools in all_tools.items():
+                for t in tools:
+                    desc = t.get("description", "")[:80]
+                    props = list(t.get("inputSchema", {}).get("properties", {}).keys())
+                    mcp_lines.append(
+                        f'- {server}/{t["name"]}: {desc} '
+                        f'(arguments: {", ".join(props[:4])})'
+                    )
+            parts.append("\n".join(mcp_lines))
+    except Exception:
+        pass
+
+    # Plugin tools
+    try:
+        from ..plugins.loader import get_agent_descriptions
+        plugin_desc = get_agent_descriptions()
+        if plugin_desc:
+            parts.append(plugin_desc)
+    except Exception:
+        pass
+
+    return "\n\n---\n\n".join(parts)
+
+
+def parse_and_execute(response: str, cwd: str) -> tuple[str, list[str]]:
+    """Find tool calls in AI response, execute them, return (clean_text, results)."""
+    from pydantic import ValidationError
+    from .tool_schema import format_validation_error, validate_tool_call
+
+    results = []
+    clean = response
+
+    for match in STRUCTURED_TOOL_PATTERN.finditer(response):
+        raw_call = match.group(1).strip()
+        try:
+            data = json.loads(raw_call)
+            name, arguments = validate_tool_call(data)
+            attrs, content = _structured_to_legacy(name, arguments)
+            result = _execute_tool(name, attrs, content, cwd)
+            results.append((name, result))
+        except json.JSONDecodeError as error:
+            results.append((
+                "tool_call",
+                f"Error: invalid tool JSON at position {error.pos}: {error.msg}",
+            ))
+        except ValidationError as error:
+            results.append((
+                "tool_call",
+                f"Error: invalid tool call: {format_validation_error(error)}",
+            ))
+        clean = clean.replace(match.group(0), "")
+
+    # Legacy per-tool XML remains accepted during migration.
+    for m in TOOL_PATTERN.finditer(response):
+        tag = m.group(1)
+        attrs = _parse_attrs(m.group(2))
+        content = (m.group(3) or "").strip()
+        result = _execute_tool(tag, attrs, content, cwd)
+        results.append((tag, result))
+        clean = clean.replace(m.group(0), "")
+
+    return clean.strip(), results
+
+
+def execute_native_tool_calls(tool_calls: list, cwd: str) -> list[tuple[str, str, str]]:
+    """Validate and execute provider-native tool calls."""
+    from pydantic import ValidationError
+    from .tool_schema import format_validation_error, validate_tool_call
+
+    results = []
+    for call in tool_calls:
+        call_id = getattr(call, "id", "") or "tool-call"
+        raw_name = getattr(call, "name", "")
+        raw_arguments = getattr(call, "arguments", {})
+        try:
+            name, arguments = validate_tool_call({
+                "name": raw_name,
+                "arguments": raw_arguments,
+            })
+            attrs, content = _structured_to_legacy(name, arguments)
+            result = _execute_tool(name, attrs, content, cwd)
+            results.append((call_id, name, result))
+        except ValidationError as error:
+            result = f"Error: invalid tool call: {format_validation_error(error)}"
+            results.append((call_id, raw_name or "tool_call", result))
+    return results
+
+
+def plan_agent(user_message: str, history: list, cwd: str, preferred: str = None) -> str:
+    """Generate a plan without executing any tools."""
+    from .fallback import stream_with_fallback
+    from ..providers.base import Message
+
+    messages = list(history) + [Message(role="user", content=user_message)]
+    try:
+        content, model = stream_with_fallback(messages, system=PLAN_SYSTEM, preferred=preferred)
+        console.print(f"[dim]── {model} ──[/dim]")
+        return content
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        return ""
+
+
+def undo_last(cwd: str) -> str:
+    """Restore the latest recorded filesystem action, including after restart."""
+    from .undo import undo_last_action
+
+    result = undo_last_action(cwd)
+    if not result.startswith(("Nothing", "Cannot")):
+        console.print(f"[green]  {result}[/green]")
+    return result
+
+
+def run_agent(user_message: str, history: list, cwd: str, preferred: str = None) -> str:
+    with operation():
+        return _run_agent(user_message, history, cwd, preferred)
+
+
+def _run_agent(user_message: str, history: list, cwd: str, preferred: str = None) -> str:
+    """
+    Full agentic loop: send → AI responds with tool calls → execute → feed back → repeat.
+    Returns final response text.
+    """
+    global _session_tokens
+    from .fallback import chat_with_fallback
+    from ..providers.base import Message
+    from .tool_schema import get_tool_definitions
+    from .context import ContextManager, bound_tool_result
+
+    system = _load_system(cwd)
+    context = ContextManager(model=preferred)
+    context.replace_messages(list(history))
+    context.add("user", user_message)
+    messages = context.get_messages()
+    MAX_TURNS = 6
+    clean_text = ""
+    used_model = preferred or "ai"
+
+    MUTATION_TAGS = {"write_file", "edit_file", "create_folder", "rename_path"}
+
+    for turn in range(MAX_TURNS):
+        raise_if_cancelled()
+        try:
+            with console.status("[cyan]Thinking...[/cyan]"):
+                response, used_model = chat_with_fallback(
+                    messages,
+                    system=system,
+                    preferred=preferred,
+                    tools=get_tool_definitions(),
+                )
+            content = response.content
+        except OperationCancelled:
+            raise
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            return ""
+
+        _session_tokens += response.tokens_used
+
+        # Strip tool tags BEFORE showing anything — never show raw XML
+        if response.tool_calls:
+            clean_text = content.strip()
+            native_results = execute_native_tool_calls(response.tool_calls, cwd)
+            tool_results = [
+                (name, result) for _, name, result in native_results
+            ]
+        else:
+            clean_text, tool_results = parse_and_execute(content, cwd)
+        raise_if_cancelled()
+
+        if not tool_results:
+            # Pure text response — show it and stop
+            if clean_text.strip():
+                console.print(clean_text)
+            console.print(f"[dim]── {format_model_selection(used_model)} ──[/dim]")
+            return clean_text
+
+        # Tools ran — check what happened
+        errors = [res for tag, res in tool_results if res.startswith("Error") or "error" in res.lower()[:30]]
+        has_mutation = any(tag in MUTATION_TAGS for tag, _ in tool_results)
+        has_result_tool = any(
+            tag not in MUTATION_TAGS
+            for tag, _ in tool_results
+        )
+
+        if has_mutation and not has_result_tool and not errors:
+            # Pure filesystem mutations already showed their verified outcome inline.
+            console.print(f"[dim]── {format_model_selection(used_model)} ──[/dim]")
+            return clean_text or "\n".join(
+                result for tag, result in tool_results if tag in MUTATION_TAGS
+            )
+
+        # Need another round: read-only tools (AI needs file content to act) or errors
+        tool_summary = "\n".join(f"[{tag}] {res}" for tag, res in tool_results)
+        if response.tool_calls:
+            messages.append(Message(
+                role="assistant",
+                content=content,
+                tool_calls=response.tool_calls,
+            ))
+            for call_id, name, result in native_results:
+                messages.append(Message(
+                    role="tool",
+                    content=bound_tool_result(result),
+                    tool_call_id=call_id,
+                    tool_name=name,
+                ))
+        else:
+            messages.append(Message(role="assistant", content=content))
+            if errors:
+                messages.append(Message(
+                    role="user",
+                    content=f"Tool errors:\n{tool_summary}\nFix and retry.",
+                ))
+            else:
+                messages.append(Message(
+                    role="user",
+                    content=f"Tool results:\n{tool_summary}",
+                ))
+
+    console.print(f"[dim]── {format_model_selection(used_model)} ──[/dim]")
+    return clean_text