codebind 0.6.19__tar.gz → 0.6.20__tar.gz

{codebind-0.6.19 → codebind-0.6.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.19
+Version: 0.6.20
 Summary: A frontend-neutral model loop for persistent IPython sessions.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili
@@ -66,7 +66,7 @@ Start a new conversation:
 uvx codebind
 ```
 
-Press `Shift+Tab` to switch the prompt into Question mode; the prompt turns purple. Type a question and press `Enter` to send it. Press `Shift+Tab` again to return to Python mode. Ordinary `Tab` completion is unchanged. Codebind leaves terminal mouse reporting off so scrollback works while editing. Move the cursor with the keyboard or a terminal-native cursor-position shortcut, if your terminal supports one.
+Press `Shift+Tab` to switch the prompt into Question mode; the prompt turns purple. Type a question and press `Enter` to send it. `Ctrl+J` starts a new Markdown line, and so does `Shift+Enter` in terminals that report the key with modifiers (macOS Terminal does not; iTerm2, Ghostty, WezTerm, and Kitty do). `Ctrl+C` while typing returns to Python mode without interrupting the kernel. Submitting a question also returns to Python mode automatically; press `Shift+Tab` again for another question. Ordinary `Tab` completion is unchanged. Codebind leaves terminal mouse reporting off so scrollback works while editing. Move the cursor with the keyboard or a terminal-native cursor-position shortcut, if your terminal supports one.
 
 `%context` displays a Markdown breakdown of provider-reported model calls, including input, output, cached input (as tokens and a percentage of input), and reasoning tokens. It estimates context remaining after the last call; future inputs and tool output cannot be counted exactly until the provider responds.
 
@@ -80,7 +80,7 @@ Inspect this project and tell me what to implement first.
 Codebind keeps its terminal prompt and internal bookkeeping usable when a tool cell leaves an asyncio loop active on the terminal thread. This also supports sync clients that manage their own loop across tool cells, without changing IPython’s normal top-level `await` behavior.
 
 Terminal conversations remain live for the current IPython process. Previous terminal inputs and outputs, including Python cells you ran yourself, enter the model's context when you ask a question. Durable automatic resumption belongs to notebooks, where the notebook file provides an unambiguous conversation identity.
-Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. Assistant Markdown appears before the following tool cell, and tool output appears as it is written. To keep terminal scrollback usable, Codebind previews at most three gray output lines, shortening each line after 80 characters with `...`. Further lines appear as `… N more output lines.` Full output remains in IPython history, while model-facing text is bounded and displayed images stay available as image blocks; `%output 8` opens the full text of cell 8 in IPython's pager. User-entered Python cells keep IPython's normal display behavior. Assistant Markdown is rendered through IPython's terminal MIME renderer. A terminal is a stream rather than a notebook document, so these displays are not editable notebook cells.
+While a question runs, its cell shows `In [*]` and its tools show `In [N]`, as a notebook does. `Ctrl+C` during a question stops the whole turn: it prints a plain `KeyboardInterrupt` and returns to the prompt, whether the interrupt lands in the model stream or in a running tool cell. Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. Assistant Markdown appears before the following tool cell, and tool output appears as it is written. To keep terminal scrollback usable, Codebind previews at most three gray output lines, shortening each line after 80 characters with `...`. Further lines appear as `… N more output lines.` Full output remains in IPython history, while model-facing text is bounded and displayed images stay available as image blocks; `%output 8` opens the full text of cell 8 in IPython's pager. User-entered Python cells keep IPython's normal display behavior. Assistant Markdown is rendered through IPython's terminal MIME renderer. A terminal is a stream rather than a notebook document, so these displays are not editable notebook cells.
 
 ## JupyterLab
 

{codebind-0.6.19 → codebind-0.6.20}/README.md

@@ -37,7 +37,7 @@ Start a new conversation:
 uvx codebind
 ```
 
-Press `Shift+Tab` to switch the prompt into Question mode; the prompt turns purple. Type a question and press `Enter` to send it. Press `Shift+Tab` again to return to Python mode. Ordinary `Tab` completion is unchanged. Codebind leaves terminal mouse reporting off so scrollback works while editing. Move the cursor with the keyboard or a terminal-native cursor-position shortcut, if your terminal supports one.
+Press `Shift+Tab` to switch the prompt into Question mode; the prompt turns purple. Type a question and press `Enter` to send it. `Ctrl+J` starts a new Markdown line, and so does `Shift+Enter` in terminals that report the key with modifiers (macOS Terminal does not; iTerm2, Ghostty, WezTerm, and Kitty do). `Ctrl+C` while typing returns to Python mode without interrupting the kernel. Submitting a question also returns to Python mode automatically; press `Shift+Tab` again for another question. Ordinary `Tab` completion is unchanged. Codebind leaves terminal mouse reporting off so scrollback works while editing. Move the cursor with the keyboard or a terminal-native cursor-position shortcut, if your terminal supports one.
 
 `%context` displays a Markdown breakdown of provider-reported model calls, including input, output, cached input (as tokens and a percentage of input), and reasoning tokens. It estimates context remaining after the last call; future inputs and tool output cannot be counted exactly until the provider responds.
 
@@ -51,7 +51,7 @@ Inspect this project and tell me what to implement first.
 Codebind keeps its terminal prompt and internal bookkeeping usable when a tool cell leaves an asyncio loop active on the terminal thread. This also supports sync clients that manage their own loop across tool cells, without changing IPython’s normal top-level `await` behavior.
 
 Terminal conversations remain live for the current IPython process. Previous terminal inputs and outputs, including Python cells you ran yourself, enter the model's context when you ask a question. Durable automatic resumption belongs to notebooks, where the notebook file provides an unambiguous conversation identity.
-Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. Assistant Markdown appears before the following tool cell, and tool output appears as it is written. To keep terminal scrollback usable, Codebind previews at most three gray output lines, shortening each line after 80 characters with `...`. Further lines appear as `… N more output lines.` Full output remains in IPython history, while model-facing text is bounded and displayed images stay available as image blocks; `%output 8` opens the full text of cell 8 in IPython's pager. User-entered Python cells keep IPython's normal display behavior. Assistant Markdown is rendered through IPython's terminal MIME renderer. A terminal is a stream rather than a notebook document, so these displays are not editable notebook cells.
+While a question runs, its cell shows `In [*]` and its tools show `In [N]`, as a notebook does. `Ctrl+C` during a question stops the whole turn: it prints a plain `KeyboardInterrupt` and returns to the prompt, whether the interrupt lands in the model stream or in a running tool cell. Model-executed cells appear with IPython's native input counter, syntax highlighting, output prompts, streams, and tracebacks. Assistant Markdown appears before the following tool cell, and tool output appears as it is written. To keep terminal scrollback usable, Codebind previews at most three gray output lines, shortening each line after 80 characters with `...`. Further lines appear as `… N more output lines.` Full output remains in IPython history, while model-facing text is bounded and displayed images stay available as image blocks; `%output 8` opens the full text of cell 8 in IPython's pager. User-entered Python cells keep IPython's normal display behavior. Assistant Markdown is rendered through IPython's terminal MIME renderer. A terminal is a stream rather than a notebook document, so these displays are not editable notebook cells.
 
 ## JupyterLab
 

{codebind-0.6.19 → codebind-0.6.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.19"
+version = "0.6.20"
 description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 requires-python = ">=3.13"

{codebind-0.6.19 → codebind-0.6.20}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.19"
+version = "0.6.20"
 description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 authors = [

{codebind-0.6.19 → codebind-0.6.20}/src/codebind/execution.py

@@ -17,12 +17,16 @@ from IPython.utils.capture import capture_output
 from .display import display_cell
 from .images import PreparedImage, prepare_mime_image
 from .model_text import bounded_text
+from .interrupts import AgentTurnInterrupted
 from .jupyter import JupyterLabBridge
 from .terminal import preview_tool_output, record_tool_output, show_input
 
 
 _MAXIMUM_IMAGES_PER_REPORT = 32
 
+# Re-exported so the model loop can recognise a user interrupt raised here.
+__all__ = ["AgentTurnInterrupted", "ExecutionReport", "IPythonExecutor"]
+
 
 @dataclass(frozen=True, slots=True)
 class ExecutionReport:
@@ -223,6 +227,9 @@ class IPythonExecutor:
             show_input(self.shell, cell)
             with preview_tool_output() as preview, record_tool_output(self.shell):
                 result = self.shell.run_cell(cell, store_history=True)
+            # A user interrupt is not a failing tool result: it stops the turn.
+            if isinstance(result.error_before_exec or result.error_in_exec, KeyboardInterrupt):
+                raise AgentTurnInterrupted
             report = self._native_report(result)
             preview.show_notice(report.error)
             return report
@@ -308,7 +315,7 @@ class IPythonExecutor:
             if asyncio.current_task() and asyncio.current_task().cancelling():
                 raise asyncio.CancelledError
             if isinstance(result.error_before_exec or result.error_in_exec, KeyboardInterrupt):
-                raise KeyboardInterrupt
+                raise AgentTurnInterrupted
             if bridged:
                 assert bridge is not None and cell_id is not None
                 bridge.finish_code_cell(

{codebind-0.6.19 → codebind-0.6.20}/src/codebind/extension.py

@@ -19,7 +19,13 @@ from .display import display_assistant
 from .conversation import MemoryConversationStore, NotebookConversationStore
 from .jupyter import JupyterLabBridge, TARGET_NAME
 from .session import Session
-from .terminal import TerminalCellHistory, install_markdown_renderer, install_question_mode
+from .terminal import (
+    TerminalCellHistory,
+    install_markdown_renderer,
+    install_question_mode,
+    remember_question,
+    set_question_running,
+)
 
 
 _STATE_ATTRIBUTE = "_codebind_extension_state"
@@ -256,11 +262,18 @@ def load_ipython_extension(ipython: InteractiveShell) -> None:
             state["session"] = session
         selected = get_model()
         terminal_history = state.get("terminal_history")
+        is_question_cell = cell is not None
+        if is_question_cell:
+            remember_question(ipython, cell)
         history = (
             terminal_history.snapshot()
             if isinstance(terminal_history, TerminalCellHistory)
             else None
         )
+        if isinstance(ipython, TerminalInteractiveShell):
+            # Keep the running mark until the next prompt: IPython prints an
+            # interrupted question's traceback after this magic returns.
+            set_question_running(ipython, True)
         try:
             session.send(cell if cell is not None else line, selected, notebook=history)
         except BaseException:

codebind-0.6.20/src/codebind/interrupts.py

@@ -0,0 +1,9 @@
+"""Signals shared by the frontends that run the model loop."""
+
+
+class AgentTurnInterrupted(BaseException):
+    """The user pressed Ctrl+C during a question, so the whole turn must stop.
+
+    This derives from :class:`BaseException` on purpose: an interrupted question
+    is not a failing tool result, and the model loop must not turn it into one.
+    """

{codebind-0.6.19 → codebind-0.6.20}/src/codebind/jupyter.py

@@ -7,6 +7,8 @@ from collections.abc import Awaitable, Callable
 from typing import Any
 from uuid import uuid4
 
+from .interrupts import AgentTurnInterrupted
+
 TARGET_NAME = "codebind"
 _Notebook = list[dict[str, Any]]
 _QuestionHandler = Callable[[str, _Notebook], Awaitable[None]]
@@ -270,7 +272,7 @@ class JupyterLabBridge:
             if self._question_handler is None:
                 raise RuntimeError("Codebind is not ready to receive questions.")
             await self._question_handler(question, notebook)
-        except (asyncio.CancelledError, KeyboardInterrupt):
+        except (asyncio.CancelledError, KeyboardInterrupt, AgentTurnInterrupted):
             cancelled = True
         except Exception as exception:
             error = {"type": type(exception).__name__, "message": str(exception)}

{codebind-0.6.19 → codebind-0.6.20}/src/codebind/session.py

@@ -31,6 +31,7 @@ from .async_runtime import run_sync
 from .display import display_assistant
 from .conversation import Conversation, ConversationStore, MemoryConversationStore
 from .execution import ExecutionReport, IPythonExecutor
+from .interrupts import AgentTurnInterrupted
 from .jupyter import JupyterLabBridge
 
 
@@ -498,7 +499,7 @@ class Session:
                         self._tool_message(report, identifier),
                         turn_id,
                     )
-        except KeyboardInterrupt:
+        except (KeyboardInterrupt, AgentTurnInterrupted):
             self._cancel_assistant_stream(assistant_cell_id)
             self._seal_interrupted_calls_sync(turn_id)
             self._append_event_sync("turn_finished", turn_id=turn_id, status="cancelled")
@@ -546,7 +547,7 @@ class Session:
                         self._tool_message(report, identifier),
                         turn_id,
                     )
-        except (asyncio.CancelledError, KeyboardInterrupt):
+        except (asyncio.CancelledError, KeyboardInterrupt, AgentTurnInterrupted):
             self._cancel_assistant_stream(assistant_cell_id)
             await self._seal_interrupted_calls(turn_id)
             await self._append_event("turn_finished", turn_id=turn_id, status="cancelled")

{codebind-0.6.19 → codebind-0.6.20}/src/codebind/terminal.py

@@ -13,6 +13,7 @@ from unittest.mock import patch
 
 from IPython.terminal.interactiveshell import IPythonPTLexer, TerminalInteractiveShell
 from prompt_toolkit.enums import DEFAULT_BUFFER
+from prompt_toolkit.key_binding.key_processor import KeyPress
 from prompt_toolkit.filters import Condition, has_focus
 from prompt_toolkit.document import Document
 from prompt_toolkit.formatted_text import ANSI, FormattedText, PygmentsTokens, to_formatted_text
@@ -21,11 +22,54 @@ from prompt_toolkit.styles import DynamicStyle, Style, merge_styles
 from rich.console import Console
 from rich.markdown import Markdown
 
+from .interrupts import AgentTurnInterrupted
+
 
 _MISSING = object()
 _IMAGE_FORMATS = ("image/png", "image/jpeg", "image/svg+xml")
 _MAXIMUM_VISIBLE_OUTPUT_LINES = 3
 _MAXIMUM_VISIBLE_OUTPUT_CHARACTERS_PER_LINE = 80
+_MODE_ATTRIBUTE = "_codebind_terminal_mode"
+# The real stdout, while tool output is being previewed.
+_REAL_STDOUT: dict[str, object] = {}
+_SHIFT_ENTER_SEQUENCE = "\x1b[27;2;13~"
+
+
+def terminal_mode(shell: TerminalInteractiveShell) -> dict[str, bool]:
+    """Share one prompt's mode flags with the rest of the terminal session."""
+    mode = getattr(shell, _MODE_ATTRIBUTE, None)
+    if not isinstance(mode, dict):
+        mode = {
+            "question": False,
+            "running": False,
+            "submitted": False,
+            "submitted_count": None,
+            "active_prompt": False,
+            "interrupt_reported": False,
+            "question_text": None,
+        }
+        setattr(shell, _MODE_ATTRIBUTE, mode)
+    return mode
+
+
+def set_question_running(shell: TerminalInteractiveShell, running: bool) -> None:
+    """Mark that a question is executing its tool cells."""
+    terminal_mode(shell)["running"] = running
+
+
+def remember_question(shell: TerminalInteractiveShell, question: str) -> None:
+    """Record the exact question text for the cell IPython is about to run."""
+    terminal_mode(shell)["question_text"] = question
+
+
+def take_question(shell: TerminalInteractiveShell) -> str | None:
+    """Consume the recorded question text, if one is waiting."""
+    mode = getattr(shell, _MODE_ATTRIBUTE, None)
+    if not isinstance(mode, dict):
+        return None
+    question = mode.get("question_text")
+    mode["question_text"] = None
+    return question if isinstance(question, str) else None
 
 
 def _plain_ansi(value: str) -> str:
@@ -87,7 +131,8 @@ def _history_cell(
     identifier = f"terminal-{number}"
     magic = _magic_input(transformed)
     if magic is not None and magic[0] == "question":
-        return {"id": identifier, "type": "markdown", "source": magic[1]}
+        recorded = take_question(shell)
+        return {"id": identifier, "type": "markdown", "source": recorded or magic[1]}
     if magic is not None and magic[0] in {"output", "context"}:
         return {"id": identifier, "type": "raw", "source": source}
 
@@ -301,20 +346,40 @@ def preview_tool_output(
     preview_stderr = _PreviewStream(stderr, preview)
     sys.stdout = preview_stdout
     sys.stderr = preview_stderr
+    _REAL_STDOUT["stream"] = stdout
     try:
         yield preview
     finally:
+        _REAL_STDOUT.pop("stream", None)
         preview_stdout.flush()
         preview_stderr.flush()
         sys.stdout, sys.stderr = stdout, stderr
 
 
+def _interrupt_report(shell: TerminalInteractiveShell, value: BaseException) -> str:
+    """Report a user interrupt the way IPython reports an interrupted cell.
+
+    Only the exception line is printed. The frames below it belong to the model
+    client, the provider, or the standard library, so naming a cell number would
+    be misleading: the interrupted cell never completed.
+    """
+    if isinstance(value, AgentTurnInterrupted):
+        value = KeyboardInterrupt()
+    return shell.get_exception_only((KeyboardInterrupt, value, None))
+
+
 def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]:
-    """Let Shift+Tab switch the terminal prompt between Python and questions."""
+    """Switch the terminal prompt between Python and Markdown questions.
+
+    Shift+Tab toggles Question mode. While it is on, Enter submits a one-line
+    question, Shift+Enter starts a new Markdown line, and Ctrl+C returns to
+    Python mode instead of interrupting the shell.
+    """
     prompt_session = shell.pt_app
     if prompt_session is None:
         return lambda: None
 
+    mode = terminal_mode(shell)
     original_shell_mouse = shell.mouse_support
     original_prompt_mouse = prompt_session.mouse_support
     # Terminal mouse reporting intercepts scrollback, even if the prompt is idle.
@@ -325,14 +390,16 @@ def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]
     had_prompt_override = "prompt_for_code" in vars(shell)
     bindings = prompt_session.key_bindings
     transforms = shell.input_transformer_manager.cleanup_transforms
-    question_mode = False
-    active_prompt = False
-    pending_question = False
     prompt_worker: ThreadPoolExecutor | None = None
 
     def prompt_for_code() -> str:
-        nonlocal active_prompt, pending_question, prompt_worker
-        active_prompt = True
+        nonlocal prompt_worker
+        mode["active_prompt"] = True
+        mode["question_asked"] = False
+        mode["answered_only"] = False
+        mode["running"] = False
+        mode["submitted"] = False
+        mode["interrupt_reported"] = False
         try:
             try:
                 asyncio.get_running_loop()
@@ -359,28 +426,129 @@ def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]
                                 pass
                     raise
         finally:
-            active_prompt = False
-        pending_question = question_mode and bool(text.strip())
+            mode["active_prompt"] = False
+            mode["running"] = False
+        if mode["question"] and mode["question_asked"]:
+            mode["answered_only"] = not text.strip()
+        else:
+            mode["answered_only"] = False
         return text
 
     def transform_question(lines: list[str]) -> list[str]:
-        nonlocal pending_question
-        if not pending_question:
+        """Wrap the cell the user just answered, and only that cell."""
+        if not mode["question_asked"] or mode["answered_only"]:
             return lines
-        pending_question = False
+        mode["question_asked"] = False
         return ["%%question\n", *lines]
 
     def toggle_question(event) -> None:
-        nonlocal question_mode
-        question_mode = not question_mode
+        mode["question"] = not mode["question"]
         event.app.invalidate()
 
-    def submit_question(event) -> None:
+    def enter_question(event) -> None:
+        """Enter submits; the prompt session stays open for the next question."""
+        mode["question_asked"] = True
+        # Set before the prompt closes: the accepted line is drawn once more
+        # while this flag is still set, which is where In [N] becomes In [*].
+        # The cell number is latched, because execution_count does not change
+        # until the cell runs, so the next prompt would otherwise look marked too.
+        mode["submitted"] = True
+        mode["submitted_count"] = str(shell.execution_count)
         event.current_buffer.validate_and_handle()
 
-    question_active = Condition(lambda: active_prompt and question_mode)
+    def newline_question(event) -> None:
+        """Shift+Enter or Ctrl+J adds a Markdown line, as in a notebook cell."""
+        event.current_buffer.insert_text("\n")
+        event.app.invalidate()
+
+    def read_keys(_source=None):
+        """Read Shift+Enter as a newline in terminals that report it.
+
+        prompt_toolkit maps that sequence to ControlM, exactly like a plain
+        Enter, so the raw ``KeyPress.data`` is the only way to tell them apart.
+        Apple Terminal does not report Shift+Enter at all, so Ctrl+J is the
+        newline key there; terminals that do report it get the expected behaviour.
+        """
+        keys = original_read_keys()
+        if not mode["question"]:
+            return keys
+        rewritten = []
+        for key in keys:
+            data = getattr(key, "data", None)
+            if isinstance(data, str) and data == _SHIFT_ENTER_SEQUENCE:
+                rewritten.append(KeyPress("\n"))
+            else:
+                rewritten.append(key)
+        return rewritten
+
+    def interrupt_question(event) -> None:
+        """Ctrl+C discards the question and returns to Python mode."""
+        buffer = event.current_buffer
+        if buffer.complete_state:
+            buffer.cancel_completion()
+        else:
+            buffer.reset()
+        mode["question"] = False
+        mode["submitted"] = False
+        event.app.invalidate()
+
+    question_active = Condition(lambda: mode["question"])
+    original_prompt_options = shell._extra_prompt_options
+
+    def prompt_options():
+        """Let a question's own line show the running marker, In [*].
+
+        The message stays callable so the marker follows the current mode: it is
+        read when the prompt is drawn, and toggle_question redraws it.
+        """
+        options = original_prompt_options()
+        prompt_tokens = shell.prompts.in_prompt_tokens
+
+        def message():
+            tokens = prompt_tokens()
+            counter = str(shell.execution_count)
+            if counter != mode["submitted_count"]:
+                return PygmentsTokens(tokens)
+            marked = [(token, "*" if text == counter else text) for token, text in tokens]
+            return PygmentsTokens(marked)
+
+        options["message"] = message
+        return options
+
+    shell._extra_prompt_options = prompt_options
+    original_read_keys = prompt_session.input.read_keys
+    original_showtraceback = shell.showtraceback
+
+    def showtraceback(
+        exc_tuple=None,
+        filename=None,
+        tb_offset=None,
+        exception_only=False,
+        running_compiled_code=False,
+    ) -> None:
+        if mode["running"] and not exception_only:
+            _etype, value, _traceback = sys.exc_info() if exc_tuple is None else exc_tuple
+            if isinstance(value, (KeyboardInterrupt, AgentTurnInterrupted)):
+                # One interrupt can surface twice: once as the interrupted cell's
+                # KeyboardInterrupt and once as the signal that stopped the turn.
+                if not mode["interrupt_reported"]:
+                    mode["interrupt_reported"] = True
+                    stream = _REAL_STDOUT.get("stream") or sys.stdout
+                    stream.write("\n" + _interrupt_report(shell, value))
+                return
+        original_showtraceback(
+            exc_tuple,
+            filename,
+            tb_offset,
+            exception_only,
+            running_compiled_code,
+        )
+
+    shell.showtraceback = showtraceback
     bindings.add("s-tab", filter=has_focus(DEFAULT_BUFFER))(toggle_question)
-    bindings.add("enter", filter=has_focus(DEFAULT_BUFFER) & question_active)(submit_question)
+    bindings.add("enter", filter=has_focus(DEFAULT_BUFFER) & question_active)(enter_question)
+    bindings.add("c-j", filter=has_focus(DEFAULT_BUFFER) & question_active)(newline_question)
+    bindings.add("c-c", filter=has_focus(DEFAULT_BUFFER) & question_active)(interrupt_question)
     shell.prompt_for_code = prompt_for_code
     question_style = merge_styles(
         [
@@ -402,14 +570,20 @@ def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]
         ]
     )
     prompt_session.style = DynamicStyle(
-        lambda: question_style if active_prompt and question_mode else original_style
+        lambda: question_style if mode["question"] and mode["active_prompt"] else original_style
     )
     transforms.insert(0, transform_question)
+    prompt_session.input.read_keys = read_keys
 
     def restore() -> None:
         bindings.remove(toggle_question)
-        bindings.remove(submit_question)
+        bindings.remove(enter_question)
+        bindings.remove(newline_question)
+        bindings.remove(interrupt_question)
         transforms.remove(transform_question)
+        shell._extra_prompt_options = original_prompt_options
+        shell.showtraceback = original_showtraceback
+        prompt_session.input.read_keys = original_read_keys
         if had_prompt_override:
             shell.prompt_for_code = original_prompt_for_code
         else:
@@ -502,10 +676,15 @@ def record_tool_output(shell: TerminalInteractiveShell) -> Iterator[None]:
 
 
 __all__ = [
+    "AgentTurnInterrupted",
     "TerminalCellHistory",
     "install_markdown_renderer",
     "install_question_mode",
     "preview_tool_output",
     "record_tool_output",
+    "remember_question",
+    "set_question_running",
     "show_input",
+    "take_question",
+    "terminal_mode",
 ]