codebind 0.6.15__tar.gz → 0.6.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.15
+Version: 0.6.16
 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:
 
@@ -75,7 +78,7 @@ Inspect this project and tell me what to implement first.
 ```
 
 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.16}/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:
 
@@ -47,7 +49,7 @@ Inspect this project and tell me what to implement first.
 ```
 
 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.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.15"
+version = "0.6.16"
 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.16}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.6.15"
+version = "0.6.16"
 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.16/src/codebind/context.md

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

codebind-0.6.16/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.16}/src/codebind/extension.py

@@ -13,6 +13,8 @@ from IPython.terminal.interactiveshell import TerminalInteractiveShell
 from langchain_core.language_models import BaseChatModel
 
 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 +28,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()
@@ -99,9 +104,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):

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

@@ -86,7 +86,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 +313,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)
@@ -384,6 +389,8 @@ 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
 
     return restore