superqode 2.4.28__tar.gz → 2.4.30__tar.gz

{superqode-2.4.28 → superqode-2.4.30}/CHANGELOG.md

@@ -7,6 +7,76 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.30] - 2026-09-29
+
+### Added
+
+- Gemini CLI subscription discovery with Google sign-in setup and explicit
+  vendor-agent alternatives in the native harness model-source menu.
+- Account connections for OpenCode, fast-agent, Pi and omp, including
+  fast-agent Codex plan launch settings and reconnect support.
+- Native MiniMax Token Plan model access with a separate validated subscription
+  credential and endpoint.
+
+### Fixed
+
+- Keep subscription credentials separate from general API billing. Z.AI and
+  Alibaba Coding Plan choices explain supported-agent setup; Kimi and Copilot
+  alternatives explicitly identify their vendor harness.
+- Preserve the current agent and credentials when model setup fails, and
+  restore the saved native harness and exact model route on reconnect.
+- Retain ACP registry package versions, launch arguments, scoped environment
+  defaults and user-defined command overrides. Binary-only agents show
+  matching platform download and checksum guidance.
+- Apply subscription billing guards after child-environment overlays and keep
+  explicit Copilot tokens scoped to Copilot. OAuth/local agent health checks
+  require only explicitly declared environment variables.
+- Target the active Python environment and installed SuperQode version in SDK
+  setup hints; keep public installation guidance independent of the exporting
+  machine's installed extras.
+- Prevent interactive account and plan shortcuts from falling through to an
+  unrelated default provider in headless mode.
+- Correct connection documentation, readiness guidance, Gemini discovery and
+  Qoder/Poolside capability declarations, and refresh the published Hub catalog.
+
+## [2.4.29] - 2026-09-29
+
+### Added
+
+- Composer image attachments for direct Chat, built-in coding, and image-capable
+  ACP agents, with visible removal controls, bounded image payloads, and draft
+  restoration after rejected requests.
+- `:voice` / `:dictate` and a command-palette entry for OS dictation guidance;
+  dictated text remains editable before submission.
+
+### Changed
+
+- Repository navigation keeps its selected tab and prompt draft, supports
+  contextual Ctrl+F file search, and gives keyboard and mouse access to search
+  results. Code-search selections reveal the matching preview line.
+- Filename indexing starts when search is opened rather than during startup.
+  Code search is debounced, cancels superseded work, and prunes ignored trees
+  before traversal.
+- Command palette and prompt history overlays adapt to smaller terminals and
+  selected themes. History search ranks fuzzy matches and shows snippets around
+  matches, including those later in multiline prompts.
+- Clipboard image capture runs away from the TUI event loop.
+
+### Fixed
+
+- Terminal image drops are staged before composer insertion. Absolute paths
+  cannot be mistaken for slash commands, and prompts containing image paths
+  send native image payloads with their text. Quoted and escaped filenames are
+  supported; missing images retain the draft with a readable error.
+- Delayed focus callbacks no longer interrupt sidebar browsing. Escape restores
+  focus through search, preview, Files, and the prompt.
+- Alt+A approves a ready plan even with the composer focused; otherwise it
+  retains its return-to-agent behavior.
+- Dispatch palette entries from their own command definitions, wire previously
+  unhandled entries, and remove the duplicate context entry.
+- Keep image files out of text-reference expansion and preserve drafts when
+  attachments are added or removed.
+
 ## [2.4.28] - 2026-09-29
 
 ### Added

{superqode-2.4.28 → superqode-2.4.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.28
+Version: 2.4.30
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.28 → superqode-2.4.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.4.28"
+version = "2.4.30"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.4.28"
+__version__ = "2.4.30"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/acp/client.py

@@ -304,6 +304,9 @@ class ACPClient:
             # Applied last so a caller can override the defaults above.
             for name, value in (self.extra_env or {}).items():
                 env[str(name)] = str(value)
+            if self.subscription_vendor:
+                env, removed = subscription_child_env(self.subscription_vendor, env)
+                self.stripped_api_keys = list(dict.fromkeys([*self.stripped_api_keys, *removed]))
 
             # OpenCode's verbose logs are useful for debugging, but expensive on
             # normal runs because every non-JSON line has to be parsed and routed
@@ -431,7 +434,7 @@ class ACPClient:
             }
         )
 
-    async def send_prompt(self, prompt: str) -> Optional[str]:
+    async def send_prompt(self, prompt: str, *, images=None) -> Optional[str]:
         """
         Send a prompt to the agent and wait for completion.
 
@@ -441,6 +444,12 @@ class ACPClient:
         self.reset_stats()
 
         content_blocks: List[ContentBlock] = [{"type": "text", "text": prompt}]
+        if images:
+            if not self._agent_capabilities.get("promptCapabilities", {}).get("image", False):
+                raise ValueError(
+                    "This ACP agent does not advertise image input. Choose an image-capable agent."
+                )
+            content_blocks.extend(image.acp_part() for image in images)
 
         response = await self._call_method(
             "session/prompt",

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/agent/loop.py

@@ -667,7 +667,7 @@ class AgentMessage:
     """A message in the agent conversation."""
 
     role: str  # "user", "assistant", "tool"
-    content: str
+    content: str | list[dict]
     tool_calls: Optional[List[Dict]] = None
     tool_call_id: Optional[str] = None
     name: Optional[str] = None  # Tool name for tool messages
@@ -2372,7 +2372,7 @@ class AgentLoop:
         """Back-compat alias for :meth:`_execute_tool_batch`."""
         return await self._execute_tool_batch(tool_calls)
 
-    async def run(self, user_message: str) -> AgentResponse:
+    async def run(self, user_message: str, *, images=None) -> AgentResponse:
         """Run the agent loop until completion.
 
         Args:
@@ -2501,7 +2501,11 @@ class AgentLoop:
             messages.extend(self._load_stored_messages())
 
         # Add user message
-        messages.append(AgentMessage(role="user", content=user_message))
+        from superqode.image_input import image_message
+
+        messages.append(
+            AgentMessage(role="user", content=image_message(user_message, images or []))
+        )
 
         # Save to session storage if enabled
         if self._session_manager:
@@ -2965,6 +2969,8 @@ class AgentLoop:
     async def run_streaming(
         self,
         user_message: str,
+        *,
+        images=None,
     ) -> AsyncIterator[str]:
         """Run the agent loop with streaming output.
 
@@ -2982,6 +2988,7 @@ class AgentLoop:
             "total_tokens": 0,
             "total_cost": 0.0,
         }
+        self.last_stream_error = ""
 
         fast_chat = self._use_fast_chat_path(user_message)
         # Resolve the real (loaded, for local) context window once so adaptive
@@ -3001,7 +3008,11 @@ class AgentLoop:
         if not fast_chat:
             messages.extend(self._load_stored_messages())
 
-        messages.append(AgentMessage(role="user", content=user_message))
+        from superqode.image_input import image_message
+
+        messages.append(
+            AgentMessage(role="user", content=image_message(user_message, images or []))
+        )
         if self._session_manager:
             self._session_manager.add_user_message(user_message)
 
@@ -3231,6 +3242,7 @@ class AgentLoop:
                     error_msg = str(e)
                     error_type = type(e).__name__
                     # Yield original streaming error for maximum transparency
+                    self.last_stream_error = error_msg
                     yield f"\n\n[Error: {error_type}] {error_msg}"
                     full_content = f"[Error: {error_type}] {error_msg}"
                     return
@@ -3264,6 +3276,7 @@ class AgentLoop:
                 except Exception as e:
                     error_msg = str(e)
                     error_type = type(e).__name__
+                    self.last_stream_error = error_msg
                     yield f"\n\n[Error: {error_type}] {error_msg}"
                     return
 

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/agents/client.py

@@ -153,7 +153,9 @@ class ACPAgentManager:
         self.connection: ClientSideConnection | None = None
         self._response_queue: asyncio.Queue = asyncio.Queue()
 
-    async def connect_to_agent(self, command: str, cwd: str | None = None) -> bool:
+    async def connect_to_agent(
+        self, command: str, cwd: str | None = None, *, extra_env: dict[str, str] | None = None
+    ) -> bool:
         """Connect to an ACP agent.
 
         Args:
@@ -189,6 +191,7 @@ class ACPAgentManager:
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
                 cwd=cwd or os.getcwd(),
+                env={**os.environ, **extra_env} if extra_env else None,
             )
 
             if proc.stdin is None or proc.stdout is None:

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/agents/discovery.py

@@ -77,6 +77,7 @@ async def read_agents(include_registry: bool = False) -> dict[str, "Agent"]:
                     if file.name.endswith(".toml") and file.is_file():
                         try:
                             agent: "Agent" = tomllib.load(file.open("rb"))
+                            agent["user_defined"] = search_path == user_agent_dir
                             if agent.get("active", True):
                                 # Validate required fields
                                 required_fields = ["identity", "name", "short_name", "protocol"]
@@ -115,7 +116,16 @@ async def read_agents(include_registry: bool = False) -> dict[str, "Agent"]:
             for warning in warnings:
                 console.print(f"[yellow]Warning: {warning}[/yellow]")
 
-    agent_map = {agent["identity"]: agent for agent in agents}
+    agent_map = {}
+    for agent in agents:
+        if agent.get("user_defined"):
+            short_name = str(agent.get("short_name") or "").casefold()
+            agent_map = {
+                identity: existing
+                for identity, existing in agent_map.items()
+                if str(existing.get("short_name") or "").casefold() != short_name
+            }
+        agent_map[agent["identity"]] = agent
 
     # Ensure the bundled catalog has stable terminal groups even before the
     # first network refresh.
@@ -153,6 +163,12 @@ async def read_agents(include_registry: bool = False) -> dict[str, "Agent"]:
                 existing["registry_id"] = converted.get("registry_id", "")
                 existing["registry_version"] = converted.get("registry_version", "")
                 existing["registry_source"] = converted.get("registry_source", "")
+                existing["registry_license"] = converted.get("registry_license", "")
+                existing["registry_license_url"] = converted.get("registry_license_url", "")
+                if not existing.get("user_defined"):
+                    existing["launch_env"] = converted.get("launch_env", {})
+                    if converted.get("registry_source") == "official-registry":
+                        existing["run_command"] = converted["run_command"]
                 existing["catalog_tier"] = converted.get("catalog_tier", "all")
                 existing["recommended"] = converted.get("recommended", False)
                 existing["tags"] = sorted(

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/agents/schema.py

@@ -110,6 +110,10 @@ class Agent(TypedDict):
     welcome: NotRequired[str]
     """A Markdown document shown to the user when the conversation starts. Should contain a welcome message and any advice on getting started."""
     run_command: dict[OS, str]
+    launch_env: NotRequired[dict[str, str]]
+    user_defined: NotRequired[bool]
+    """Distribution defaults applied only to this agent's subprocess."""
+    required_env: NotRequired[list[str]]
     """Command to run the agent, by OS or wildcard."""
     actions: dict[OS, dict[Action, Command]]
     """Scripts to perform actions, typically at least to install the agent."""

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/app/constants.py

@@ -725,6 +725,9 @@ COMMANDS = [
     ":sandbox doctor",
     ":sandbox run",
     ":paste",
+    ":voice",
+    ":voice off",
+    ":dictate",
     ":queue",
     ":queue add",
     ":queue edit",

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/app/css.py

@@ -248,6 +248,11 @@ ConversationLog {
 }
 #hints { text-align: center; color: #71717a; height: 1; margin-top: 0; padding: 0; }
 
+#attachment-bar { display: none; height: auto; max-height: 5; margin: 0 2; }
+#attachment-bar.visible { display: block; }
+#dictation-guide { display: none; height: auto; max-height: 5; margin: 0 2; }
+#dictation-guide.visible { display: block; }
+
 #active-tools {
     display: none;
     height: 1;

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/app/harness_picker.py

@@ -13,6 +13,7 @@ VENDOR_HARNESS_IDS = (
     "kimi-code",
     "qwen-code",
     "antigravity",
+    "gemini-cli",
     "grok",
     "copilot",
     "cursor",
@@ -80,6 +81,11 @@ def harness_install_extra(entry) -> str:
     """Return the controlled SuperQode extra for an unavailable harness."""
     if bool(getattr(entry, "available", False)):
         return ""
+    return harness_source_extra(entry)
+
+
+def harness_source_extra(entry) -> str:
+    """Declared optional extra, independent of this machine's installation."""
     return _OPTIONAL_HARNESS_EXTRAS.get(str(getattr(entry, "source", "") or ""), "")
 
 

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/app/inputs.py

@@ -50,6 +50,13 @@ class SelectionAwareInput(TextArea):
         self.load_text("")
         self._resize_to_content()
 
+    def _on_paste(self, event: events.Paste) -> None:
+        # Textual dispatches inherited handlers automatically. Stop its default
+        # insertion only when the composer successfully stages a path-only drop.
+        handler = getattr(self.app, "on_paste", None)
+        if handler is not None:
+            handler(event)
+
     def __init__(self, *args, suggester=None, **kwargs) -> None:
         # TextArea doesn't support Input's suggester API. Accept it so the prompt
         # can keep the existing construction path while using soft wrapping.
@@ -204,6 +211,12 @@ class SelectionAwareInput(TextArea):
             return
 
         if event.key == "alt+a":
+            # Let the app-level plan handler approve a ready plan before this
+            # composer shortcut can intercept the event for workspace navigation.
+            if getattr(app, "_pending_plan_status", "") == "pending" and bool(
+                getattr(app, "_pending_plan_content", "").strip()
+            ):
+                return
             if hasattr(app, "action_return_to_agent"):
                 app.action_return_to_agent()
                 event.stop()

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/app/mixins/actions_misc.py

@@ -36,6 +36,10 @@ class MiscActionsMixin:
         self._welcome_active = False
         log = self.query_one("#log", ConversationLog)
         log.redraw_conversation()
+        try:
+            self.query_one("#prompt-input", SelectionAwareInput).focus()
+        except Exception:
+            pass
         self.set_timer(0.05, self._ensure_input_focus)
 
     def action_show_help(self):
@@ -91,6 +95,40 @@ class MiscActionsMixin:
 
         self.push_screen(HistorySearchModal(entries=entries), callback=_on_dismissed)
 
+    def action_remove_attachment(self, index: int) -> None:
+        self._attach_cmd(f"remove {index}", self.query_one("#log", ConversationLog))
+        self._ensure_input_focus()
+
+    def action_voice_input(self) -> None:
+        """Keep OS dictation in the editable composer, with platform guidance."""
+        import sys
+        from rich.text import Text
+        from textual.widgets import Static
+        from superqode.app.constants import THEME
+
+        if getattr(self, "is_busy", False):
+            self.notify(
+                "Wait for the current run to finish before dictating.", title="OS Dictation"
+            )
+            return
+        if sys.platform == "darwin":
+            hint = "Use your Dictation shortcut · Enable in System Settings → Keyboard → Dictation"
+        elif sys.platform == "win32":
+            hint = "Press Win+H to start Windows voice typing"
+        else:
+            hint = "Use your desktop dictation tool to insert text into this terminal"
+        panel = self.query_one("#dictation-guide", Static)
+        text = Text("◉ OS Dictation  ", style=THEME["purple"])
+        text.append(hint, style=THEME["text"])
+        text.append(
+            "\nEdit your words, then Enter to send · :voice off to hide", style=THEME["muted"]
+        )
+        panel.update(text)
+        panel.add_class("visible")
+        if self._vim_enabled():
+            self._set_vim_state("insert")
+        self._ensure_input_focus()
+
     def action_open_editor(self):
         """Open external editor for composing message (Ctrl+E)."""
         log = self.query_one("#log", ConversationLog)
@@ -254,10 +292,31 @@ class MiscActionsMixin:
         """
         from superqode.app.inputs import SelectionAwareInput
 
+        from superqode.sidebar import CollapsibleSidebar
+
+        focused = getattr(self, "focused", None)
+        if focused is not None:
+            sidebar = next(
+                (
+                    node
+                    for node in focused.ancestors_with_self
+                    if isinstance(node, CollapsibleSidebar)
+                ),
+                None,
+            )
+            if sidebar is not None:
+                sidebar.action_toggle_search()
+                return
+
         try:
             prompt_input = self.query_one("#prompt-input", SelectionAwareInput)
         except Exception:
             return
+        draft = prompt_input.value
+        if draft.strip() and not draft.startswith(":search "):
+            if not hasattr(self, "_draft_stash"):
+                self._draft_stash = []
+            self._draft_stash.append(draft)
         prompt_input.value = ":search "
         prompt_input.cursor_position = len(prompt_input.value)
         prompt_input.focus()

{superqode-2.4.28 → superqode-2.4.30}/src/superqode/app/mixins/agent_run.py

@@ -453,6 +453,10 @@ class AgentRunMixin:
         from superqode.providers.gateway.base import Message
         from superqode.providers.gateway.litellm_gateway import LiteLLMGateway
 
+        images = getattr(self, "_current_images", [])
+        self._current_images = []
+        history = getattr(self, "_chat_history", [])
+
         try:
             provider = self._pure_mode.session.provider
             model = self._pure_mode.session.model
@@ -461,11 +465,14 @@ class AgentRunMixin:
                     log.add_error,
                     "No model is selected. Reconnect with :connect local before chatting.",
                 )
+                self._call_ui(self._restore_image_input, images)
                 return
             history = self._chat_history
             if not isinstance(history, list):
                 history = self._chat_history = []
-            history.append(Message(role="user", content=text))
+            from superqode.image_input import image_message
+
+            history.append(Message(role="user", content=image_message(text, images)))
             who = f"{provider}/{model}"
             self._call_ui(lambda: log.reset_response_stream(who))
 
@@ -520,6 +527,7 @@ class AgentRunMixin:
                         "and not an embedding-only model."
                     )
                 self._call_ui(log.add_info, note)
+                self._call_ui(self._restore_image_input, images)
                 return
             self._call_ui(lambda: log.write_final_response(full, agent=who))
 
@@ -529,6 +537,10 @@ class AgentRunMixin:
             tps = (tokens / decode_dur) if decode_dur and decode_dur > 0 else None
             self._call_ui(self._write_chat_stats, log, ttft, tps, tokens, end_t - t0)
         except Exception as exc:  # noqa: BLE001 - surface any model/transport error
+            if images:
+                self._call_ui(self._restore_image_input, images)
+                if history and history[-1].role == "user":
+                    history.pop()
             self._call_ui(log.add_error, f"Chat error: {exc}")
         finally:
             # Stops the indicator + scanning waves and restores the prompt.
@@ -540,6 +552,9 @@ class AgentRunMixin:
         from time import monotonic
         import traceback
 
+        images = getattr(self, "_current_images", [])
+        self._current_images = []
+
         # Handle session commands
         if text.strip().startswith("/sessions"):
             parts = text.strip().split(maxsplit=2)
@@ -594,12 +609,14 @@ class AgentRunMixin:
             log.add_error("Not connected to a model. Use :connect byok to select a provider/model.")
             log.add_system("Example: :connect local ollama/qwen3.6:35b-a3b")
             self.is_busy = False
+            self._restore_image_input(images)
             return
 
         if not self._pure_mode.session.connected:
             log.add_error("Connection not established. Please reconnect using :connect byok")
             log.add_system("Example: :connect local ollama/qwen3.6:35b-a3b")
             self.is_busy = False
+            self._restore_image_input(images)
             return
 
         # A builtin AgentLoop (._agent), a harness, OR a self-contained runtime
@@ -612,6 +629,7 @@ class AgentRunMixin:
             log.add_error("Agent not initialized. Please reconnect using :connect byok")
             log.add_system("Example: :connect local ollama/qwen3.6:35b-a3b")
             self.is_busy = False
+            self._restore_image_input(images)
             return
 
         provider = self._pure_mode.session.provider
@@ -946,8 +964,11 @@ class AgentRunMixin:
                 last_display_time = time.time()
 
                 try:
+                    image_kwargs = {}
+                    if images:
+                        image_kwargs["images"] = images
                     async for chunk in self._pure_mode.run_streaming(
-                        text, plan_mode=plan_mode_for_run
+                        text, plan_mode=plan_mode_for_run, **image_kwargs
                     ):
                         if getattr(self, "_cancel_requested", False) or getattr(
                             self._pure_mode, "_cancel_requested", False
@@ -979,6 +1000,11 @@ class AgentRunMixin:
                                     accumulated_chunk = ""
                                     last_display_time = current_time
 
+                    image_error = getattr(
+                        getattr(self._pure_mode, "_agent", None), "last_stream_error", ""
+                    )
+                    if images and image_error:
+                        raise ValueError(image_error)
                     if accumulated_chunk:
                         _safe_call(log.add_response_chunk, accumulated_chunk)
                 finally:
@@ -1017,6 +1043,7 @@ class AgentRunMixin:
                 if is_local:
                     self._stop_thinking()
                 self._stop_stream_animation()
+                self._restore_image_input(images)
                 self._show_error_card(
                     log,
                     f"{error_type} while running agent",
@@ -1297,6 +1324,7 @@ class AgentRunMixin:
             self._stop_thinking()
             self._stop_stream_animation()
             self.is_busy = False
+            self._restore_image_input(images)
             error_msg = str(e)
             error_trace = traceback.format_exc()
 
@@ -1532,6 +1560,17 @@ class AgentRunMixin:
             )
             return
 
+        if getattr(self, "_current_images", []):
+            images = self._current_images
+            self._current_images = []
+            self._call_ui(self._restore_image_input, images)
+            self._call_ui(
+                log.add_error,
+                "This runtime does not support image input. Use built-in coding, direct Chat, or an image-capable ACP agent.",
+            )
+            self._call_ui(self._stop_thinking)
+            return
+
         try:
             start_time = monotonic()
 
@@ -1852,6 +1891,9 @@ class AgentRunMixin:
 
         from superqode.acp.client import ACPClient
 
+        images = getattr(self, "_current_images", [])
+        self._current_images = []
+
         # Prepend file context if available (from @file references)
         file_context = getattr(self, "_current_file_context", "")
         if file_context:
@@ -2015,6 +2057,20 @@ class AgentRunMixin:
         # Closed/Open key paths set this at :connect time. Merge last so the
         # child sees the resolved key; never setdefault into SuperQode's env.
         # Only the agent the key was resolved for receives it.
+        selected_agent = getattr(get_session(), "connected_agent", None) or {}
+        override_name = f"SUPERQODE_{agent_type.upper().replace('-', '_')}_ACP_COMMAND"
+        if (
+            isinstance(selected_agent, dict)
+            and (
+                selected_agent.get("user_defined")
+                or (
+                    selected_agent.get("registry_source") == "official-registry"
+                    and agent_type not in {"prime-agent", "prime"}
+                )
+            )
+            and not os.getenv(override_name)
+        ):
+            command = selected_agent.get("run_command", {}).get("*", "") or command
         acp_extra_env = self._merge_acp_session_extra_env(agent_type, acp_extra_env)
 
         mode_label = {"auto": "🟢 AUTO", "ask": "🟡 ASK", "deny": "🔴 DENY"}.get(
@@ -2671,7 +2727,8 @@ class AgentRunMixin:
                         self._call_ui(log.add_meta, "ACP session ready. Sending prompt...", "⚡")
 
                 async def send_and_wait() -> str | None:
-                    prompt_task = asyncio.create_task(client.send_prompt(message))
+                    image_kwargs = {"images": images} if images else {}
+                    prompt_task = asyncio.create_task(client.send_prompt(message, **image_kwargs))
                     prompt_started_at = time.monotonic()
                     waiting_notice_sent = False
 
@@ -2825,6 +2882,7 @@ class AgentRunMixin:
             self._agent_process = None
             self._acp_client = None
             self._acp_client_key = None
+            self._call_ui(self._restore_image_input, images)
             self._call_ui(self._stop_thinking)
             self._call_ui(self._stop_stream_animation)
             self._call_ui(
@@ -2836,6 +2894,7 @@ class AgentRunMixin:
             self._agent_process = None
             self._acp_client = None
             self._acp_client_key = None
+            self._call_ui(self._restore_image_input, images)
             self._call_ui(self._stop_thinking)
             self._call_ui(self._stop_stream_animation)
             self._call_ui(