codebind 0.6.15__tar.gz → 0.6.17__tar.gz

{codebind-0.6.15 → codebind-0.6.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.15
+Version: 0.6.17
 Summary: A frontend-neutral model loop for persistent IPython sessions.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili
@@ -18,6 +18,7 @@ Classifier: Typing :: Typed
 Requires-Dist: ipython>=9.17
 Requires-Dist: langchain-core>=1.0
 Requires-Dist: models-provider>=0.1.6
+Requires-Dist: mistune>=3.3,<4
 Requires-Dist: pillow>=11
 Requires-Dist: resvg-py>=0.5
 Requires-Dist: rich>=14.1
@@ -65,7 +66,9 @@ 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.
+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.
+
+`%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.
 
 The `%question` and `%%question` magics remain available:
 
@@ -74,8 +77,10 @@ The `%question` and `%%question` magics remain available:
 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 60 characters with `...`. Further lines appear as `… N more output lines.` The complete output remains available to the model and in IPython history; `%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.
+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.` The complete output remains available to the model and in IPython history; `%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.15 → codebind-0.6.17}/README.md

@@ -37,7 +37,9 @@ 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.
+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.
+
+`%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.
 
 The `%question` and `%%question` magics remain available:
 
@@ -46,8 +48,10 @@ The `%question` and `%%question` magics remain available:
 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 60 characters with `...`. Further lines appear as `… N more output lines.` The complete output remains available to the model and in IPython history; `%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.
+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.` The complete output remains available to the model and in IPython history; `%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.15 → codebind-0.6.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.15"
+version = "0.6.17"
 description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -27,6 +27,7 @@ dependencies = [
     "ipython>=9.17",
     "langchain-core>=1.0",
     "models-provider>=0.1.6",
+    "mistune>=3.3,<4",
     "pillow>=11",
     "resvg-py>=0.5",
     "rich>=14.1",

{codebind-0.6.15 → codebind-0.6.17}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.15"
+version = "0.6.17"
 description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 authors = [
@@ -24,6 +24,7 @@ dependencies = [
     "ipython>=9.17",
     "langchain-core>=1.0",
     "models-provider>=0.1.6",
+    "mistune>=3.3,<4",
     "pillow>=11",
     "resvg-py>=0.5",
     "rich>=14.1",

codebind-0.6.17/src/codebind/async_runtime.py

@@ -0,0 +1,20 @@
+"""Bridge synchronous Codebind operations around foreign event loops."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable
+from concurrent.futures import ThreadPoolExecutor
+from typing import TypeVar
+
+_T = TypeVar("_T")
+
+
+def run_sync(operation: Awaitable[_T]) -> _T:
+    """Run a coroutine without nesting asyncio.run in a loop owned by another API."""
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(operation)
+    with ThreadPoolExecutor(max_workers=1, thread_name_prefix="codebind-async") as worker:
+        return worker.submit(asyncio.run, operation).result()

codebind-0.6.17/src/codebind/context.md

@@ -0,0 +1 @@
+Below you can find the context window information for `$model`.

codebind-0.6.17/src/codebind/context.py

@@ -0,0 +1,135 @@
+"""Provider-reported context usage for the active conversation."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from importlib.resources import files
+from string import Template
+from typing import Any
+
+import mistune
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import AIMessage, BaseMessage, ToolMessage
+from mistune.renderers.markdown import MarkdownRenderer
+
+
+def _count(value: Any) -> int:
+    return value if isinstance(value, int) and value >= 0 else 0
+
+
+def _text(value: str) -> dict[str, Any]:
+    return {"type": "text", "raw": value}
+
+
+def _paragraph(value: str) -> dict[str, Any]:
+    return {"type": "paragraph", "children": [_text(value)]}
+
+
+def _table(headers: tuple[str, ...], rows: list[tuple[str, ...]]) -> dict[str, Any]:
+    def cells(values: tuple[str, ...], *, head: bool) -> list[dict[str, Any]]:
+        return [
+            {
+                "type": "table_cell",
+                "attrs": {"align": "left" if index == 0 else "right", "head": head},
+                "children": [_text(value)],
+            }
+            for index, value in enumerate(values)
+        ]
+
+    return {
+        "type": "table",
+        "children": [
+            {"type": "table_head", "children": cells(headers, head=True)},
+            {
+                "type": "table_body",
+                "children": [
+                    {"type": "table_row", "children": cells(row, head=False)} for row in rows
+                ],
+            },
+        ],
+    }
+
+
+def format_context(messages: Sequence[BaseMessage], model: BaseChatModel, name: str) -> str:
+    """Render reported calls as Markdown; next-turn context remains an estimate."""
+    context_window = getattr(model, "context_window", None)
+    capacity = _count(context_window() if callable(context_window) else getattr(model, "context_length", 0))
+    calls = [message for message in messages if isinstance(message, AIMessage)]
+    measured = [message for message in calls if isinstance(message.usage_metadata, dict)]
+    results = [message for message in messages if isinstance(message, ToolMessage)]
+
+    def totals(group: list[AIMessage]) -> tuple[str, ...]:
+        counts = [0, 0, 0, 0]
+        for message in group:
+            usage = message.usage_metadata or {}
+            counts[0] += _count(usage.get("input_tokens"))
+            counts[1] += _count(usage.get("output_tokens"))
+            counts[2] += _count((usage.get("input_token_details") or {}).get("cache_read"))
+            counts[3] += _count((usage.get("output_token_details") or {}).get("reasoning"))
+        input_tokens, output_tokens, cached_tokens, reasoning_tokens = counts
+        cached_share = f"{cached_tokens / input_tokens:.2%}" if input_tokens else "—"
+        return (
+            f"{len(group):,}",
+            f"{input_tokens:,}",
+            f"{output_tokens:,}",
+            f"{cached_tokens:,} ({cached_share})",
+            f"{reasoning_tokens:,}",
+        )
+
+    last_reported = bool(calls and isinstance(calls[-1].usage_metadata, dict))
+    latest = calls[-1].usage_metadata if last_reported else {}
+    last_input = _count((latest or {}).get("input_tokens"))
+    last_output = _count((latest or {}).get("output_tokens"))
+    last_cached = _count(((latest or {}).get("input_token_details") or {}).get("cache_read"))
+    remaining = max(capacity - last_input - last_output, 0) if capacity and last_reported else None
+
+    def percent(value: int) -> str:
+        return f"{value / capacity:.2%}" if capacity and last_reported else "—"
+
+    tool_chars = sum(
+        len(block["text"])
+        for message in results
+        for block in message.content_blocks
+        if block.get("type") == "text" and isinstance(block.get("text"), str)
+    )
+    images = sum(1 for message in results for block in message.content_blocks if block.get("type") == "image")
+    missing = len(calls) - len(measured)
+    request_rows = [
+        ("Tool calls", *totals([message for message in measured if message.tool_calls])),
+        ("Responses", *totals([message for message in measured if not message.tool_calls])),
+        ("Reported total", *totals(measured)),
+    ]
+    if missing:
+        request_rows.append(("Unreported", f"{missing:,}", "—", "—", "—", "—"))
+    preset = Template(files("codebind").joinpath("context.md").read_text()).substitute(model=name)
+    parser = mistune.create_markdown(renderer="ast", plugins=["table"])
+    heading, *notes = parser(preset)
+    blocks = [
+        heading,
+        _paragraph(
+            "Provider-reported usage from completed calls."
+            if last_reported
+            else "Latest model call has no reported usage; remaining context cannot be measured."
+            if calls
+            else "No provider-reported model usage yet; remaining context cannot be measured."
+        ),
+        _table(
+            ("Last completed model call", "Tokens", "Share"),
+            [
+                ("Input (includes cached input)", f"{last_input:,}" if last_reported else "—", f"{percent(last_input)} of window" if capacity and last_reported else "—"),
+                ("Cached input", f"{last_cached:,}" if last_reported else "—", f"{last_cached / last_input:.2%} of input" if last_input else "—"),
+                ("Output (includes reasoning)", f"{last_output:,}" if last_reported else "—", f"{percent(last_output)} of window" if capacity and last_reported else "—"),
+                ("Estimated remaining", f"{remaining:,}" if remaining is not None else "—", f"{percent(remaining or 0)} of window" if remaining is not None else "—"),
+            ],
+        ),
+        _table(
+            ("Model calls", "Calls", "Input", "Output", "Cached input (%)", "Reasoning output"),
+            request_rows,
+        ),
+        _table(
+            ("Tool results", "Count", "Text characters", "Images"),
+            [("Recorded", f"{len(results):,}", f"{tool_chars:,}", f"{images:,}")],
+        ),
+        *notes,
+    ]
+    return MarkdownRenderer()(blocks, mistune.BlockState())

{codebind-0.6.15 → codebind-0.6.17}/src/codebind/extension.py

@@ -12,7 +12,10 @@ from IPython.core.page import page
 from IPython.terminal.interactiveshell import TerminalInteractiveShell
 from langchain_core.language_models import BaseChatModel
 
+from .async_runtime import run_sync
 from .configuration import load_configuration, load_models
+from .context import format_context
+from .display import display_assistant
 from .conversation import MemoryConversationStore, NotebookConversationStore
 from .jupyter import JupyterLabBridge, TARGET_NAME
 from .session import Session
@@ -26,6 +29,9 @@ def _close_state(state: dict[str, Any]) -> None:
     restore_control_interrupt = state.get("restore_control_interrupt")
     if callable(restore_control_interrupt):
         restore_control_interrupt()
+    restore_context_magic = state.get("restore_context_magic")
+    if callable(restore_context_magic):
+        restore_context_magic()
     restore_output_magic = state.get("restore_output_magic")
     if callable(restore_output_magic):
         restore_output_magic()
@@ -53,7 +59,7 @@ def _close_state(state: dict[str, Any]) -> None:
         try:
             asyncio.get_running_loop().create_task(discard_model())
         except RuntimeError:
-            asyncio.run(discard_model())
+            run_sync(discard_model())
 
 
 def load_ipython_extension(ipython: InteractiveShell) -> None:
@@ -99,9 +105,31 @@ def load_ipython_extension(ipython: InteractiveShell) -> None:
         "restore_terminal_question_mode": None,
         "terminal_history": None,
         "restore_output_magic": None,
+        "restore_context_magic": None,
         "restore_control_interrupt": None,
     }
 
+    line_magics = ipython.magics_manager.magics["line"]
+    previous_context_magic = line_magics.get("context")
+
+    def context_magic(line: str) -> None:
+        if line.strip():
+            raise ValueError("Usage: %context")
+        session = state.get("session")
+        messages = session.messages if isinstance(session, Session) else ()
+        display_assistant(format_context(messages, get_model(), configuration.model))
+
+    ipython.register_magic_function(context_magic, "line", "context")
+
+    def restore_context_magic() -> None:
+        if line_magics.get("context") is context_magic:
+            if previous_context_magic is None:
+                line_magics.pop("context", None)
+            else:
+                line_magics["context"] = previous_context_magic
+
+    state["restore_context_magic"] = restore_context_magic
+
     if manager is None:
         state["session"] = Session(shell=ipython, store=MemoryConversationStore())
         if isinstance(ipython, TerminalInteractiveShell):
@@ -236,7 +264,7 @@ def load_ipython_extension(ipython: InteractiveShell) -> None:
         try:
             session.send(cell if cell is not None else line, selected, notebook=history)
         except BaseException:
-            asyncio.run(discard_model())
+            run_sync(discard_model())
             raise
 
     ipython.register_magic_function(question_magic, "line_cell", "question")

{codebind-0.6.15 → codebind-0.6.17}/src/codebind/session.py

@@ -27,6 +27,7 @@ from langchain_core.messages.ai import add_ai_message_chunks
 from langchain_core.runnables import Runnable
 from models_provider import TransientProviderError
 
+from .async_runtime import run_sync
 from .display import display_assistant
 from .conversation import Conversation, ConversationStore, MemoryConversationStore
 from .execution import ExecutionReport, IPythonExecutor
@@ -146,7 +147,7 @@ class Session:
         await self._ensure_loaded()
 
     def _ensure_loaded_sync(self) -> None:
-        asyncio.run(self._ensure_loaded())
+        run_sync(self._ensure_loaded())
 
     @staticmethod
     async def _await_durable(operation: Awaitable[None]) -> None:
@@ -192,17 +193,17 @@ class Session:
         await self._commit(lambda conversation: conversation.append_notebook(notebook, turn_id))
 
     def _append_event_sync(self, event_type: str, **data: Any) -> None:
-        asyncio.run(self._append_event(event_type, **data))
+        run_sync(self._append_event(event_type, **data))
 
     def _append_message_sync(self, message: BaseMessage, turn_id: str) -> None:
-        asyncio.run(self._append_message(message, turn_id))
+        run_sync(self._append_message(message, turn_id))
 
     def _append_notebook_sync(
         self,
         notebook: list[dict[str, Any]] | None,
         turn_id: str,
     ) -> None:
-        asyncio.run(self._append_notebook(notebook, turn_id))
+        run_sync(self._append_notebook(notebook, turn_id))
 
     def _model_kwargs(self, model: BaseChatModel) -> dict[str, Any]:
         if self.conversation is None:
@@ -316,7 +317,7 @@ class Session:
             except TransientProviderError as error:
                 if retry == len(_MODEL_RETRY_DELAYS):
                     raise
-                asyncio.run(self._reset_model_connection(model))
+                run_sync(self._reset_model_connection(model))
                 time.sleep(max(0.0, error.retry_after or _MODEL_RETRY_DELAYS[retry]))
         raise AssertionError("unreachable")
 
@@ -434,7 +435,7 @@ class Session:
         try:
             asyncio.get_running_loop()
         except RuntimeError:
-            asyncio.run(self.aclear())
+            run_sync(self.aclear())
             return
         raise RuntimeError("clear() cannot run inside an active event loop; use await aclear().")
 
@@ -459,11 +460,14 @@ class Session:
     ) -> None:
         """Send one user message synchronously."""
         try:
-            asyncio.get_running_loop()
+            loop = asyncio.get_running_loop()
         except RuntimeError:
             pass
         else:
-            raise RuntimeError("send() cannot run inside an active event loop; use await asend().")
+            # Greenlet-backed sync APIs can expose their loop on this thread
+            # without this call actually running inside an asyncio task.
+            if asyncio.current_task(loop) is not None:
+                raise RuntimeError("send() cannot run inside an active event loop; use await asend().")
 
         text = prompt.strip()
         if not text:

{codebind-0.6.15 → codebind-0.6.17}/src/codebind/terminal.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import ast
+import asyncio
 import sys
 from collections.abc import Callable, Iterator
+from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from copy import deepcopy
 from unittest.mock import patch
@@ -86,7 +88,7 @@ def _history_cell(
     magic = _magic_input(transformed)
     if magic is not None and magic[0] == "question":
         return {"id": identifier, "type": "markdown", "source": magic[1]}
-    if magic is not None and magic[0] == "output":
+    if magic is not None and magic[0] in {"output", "context"}:
         return {"id": identifier, "type": "raw", "source": source}
 
     outputs: list[dict[str, object]] = []
@@ -313,6 +315,11 @@ def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]
     if prompt_session is None:
         return lambda: None
 
+    original_shell_mouse = shell.mouse_support
+    original_prompt_mouse = prompt_session.mouse_support
+    # Terminal mouse reporting intercepts scrollback, even if the prompt is idle.
+    shell.mouse_support = False
+    prompt_session.mouse_support = False
     original_style = prompt_session.style
     original_prompt_for_code = shell.prompt_for_code
     had_prompt_override = "prompt_for_code" in vars(shell)
@@ -321,12 +328,36 @@ def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]
     question_mode = False
     active_prompt = False
     pending_question = False
+    prompt_worker: ThreadPoolExecutor | None = None
 
     def prompt_for_code() -> str:
-        nonlocal active_prompt, pending_question
+        nonlocal active_prompt, pending_question, prompt_worker
         active_prompt = True
         try:
-            text = original_prompt_for_code()
+            try:
+                asyncio.get_running_loop()
+            except RuntimeError:
+                text = original_prompt_for_code()
+            else:
+                if prompt_worker is None:
+                    prompt_worker = ThreadPoolExecutor(max_workers=1, thread_name_prefix="codebind-prompt")
+                future = prompt_worker.submit(original_prompt_for_code)
+                try:
+                    text = future.result()
+                except BaseException:
+                    if not future.done():
+                        app = prompt_session.app
+                        if app.is_running and app.loop is not None:
+                            def abort_prompt() -> None:
+                                if app.is_running:
+                                    app.exit(exception=KeyboardInterrupt())
+
+                            app.loop.call_soon_threadsafe(abort_prompt)
+                            try:
+                                future.result(timeout=3)
+                            except BaseException:
+                                pass
+                    raise
         finally:
             active_prompt = False
         pending_question = question_mode and bool(text.strip())
@@ -384,6 +415,10 @@ def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]
         else:
             del shell.prompt_for_code
         prompt_session.style = original_style
+        prompt_session.mouse_support = original_prompt_mouse
+        shell.mouse_support = original_shell_mouse
+        if prompt_worker is not None:
+            prompt_worker.shutdown(wait=False, cancel_futures=True)
 
     return restore