codebind 0.6.17__tar.gz → 0.6.18__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.6.17
+Version: 0.6.18
 Summary: A frontend-neutral model loop for persistent IPython sessions.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili
@@ -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.` 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.` 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.17 → codebind-0.6.18}/README.md

@@ -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.` 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.` 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.17 → codebind-0.6.18}/pyproject.toml

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

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

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

{codebind-0.6.17 → codebind-0.6.18}/src/codebind/conversation.py

@@ -19,6 +19,7 @@ from langchain_core.messages import (
 )
 
 from .images import PreparedImage, prepare_mime_image
+from .model_text import bounded_text
 
 
 class ConversationStore(Protocol):
@@ -319,7 +320,19 @@ def _canonical_mime_bundle(
     label: str,
     images: list[tuple[str, PreparedImage]] | None,
 ) -> dict[str, Any]:
-    data = {key: deepcopy(item) for key, item in value.items() if not key.startswith("image/")}
+    def bounded_item(key: str, item: Any) -> Any:
+        if key.startswith("text/"):
+            if isinstance(item, str):
+                return bounded_text(item)
+            if isinstance(item, list) and all(isinstance(part, str) for part in item):
+                return bounded_text("".join(item))
+        return deepcopy(item)
+
+    data = {
+        key: bounded_item(key, item)
+        for key, item in value.items()
+        if not key.startswith("image/")
+    }
     try:
         image = prepare_mime_image(value)
     except ValueError as error:
@@ -370,7 +383,7 @@ def _normalize_notebook(
         ):
             raise ValueError("Invalid Codebind notebook cell")
         identifiers.add(identifier)
-        cell: dict[str, Any] = {"id": identifier, "type": cell_type, "source": source}
+        cell: dict[str, Any] = {"id": identifier, "type": cell_type, "source": bounded_text(source)}
         if cell_type == "code":
             execution_count = raw_cell.get("execution_count")
             outputs = raw_cell.get("outputs", [])
@@ -384,6 +397,12 @@ def _normalize_notebook(
                 if not isinstance(output, dict):
                     raise ValueError("Invalid Codebind cell output")
                 normalized = deepcopy(output)
+                if output.get("output_type") == "stream":
+                    text = output.get("text")
+                    if isinstance(text, str):
+                        normalized["text"] = bounded_text(text)
+                    elif isinstance(text, list) and all(isinstance(part, str) for part in text):
+                        normalized["text"] = bounded_text("".join(text))
                 data = output.get("data")
                 if isinstance(data, dict):
                     normalized["data"] = _canonical_mime_bundle(

{codebind-0.6.17 → codebind-0.6.18}/src/codebind/execution.py

@@ -16,6 +16,7 @@ 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 .jupyter import JupyterLabBridge
 from .terminal import preview_tool_output, record_tool_output, show_input
 
@@ -388,9 +389,10 @@ class IPythonExecutor:
         displays: list[str] = []
         images: list[PreparedImage] = []
         omissions: list[str] = []
+        seen_images: set[str] = set()
         for index, data in enumerate(bundles):
             if isinstance(data, dict) and "text/plain" in data:
-                displays.append(str(data["text/plain"]))
+                displays.append(bounded_text(str(data["text/plain"])))
             if not isinstance(data, dict):
                 continue
             if len(images) >= _MAXIMUM_IMAGES_PER_REPORT:
@@ -402,20 +404,27 @@ class IPythonExecutor:
             except ValueError as error:
                 omissions.append(f"Display {index + 1}: {error}")
             else:
-                if image is not None:
+                if image is not None and image.source_sha256 not in seen_images:
                     images.append(image)
+                    seen_images.add(image.source_sha256)
 
         exception = result.error_before_exec or result.error_in_exec
         error = (
-            {"type": type(exception).__name__, "message": str(exception)}
+            {"type": type(exception).__name__, "message": bounded_text(str(exception))}
             if exception is not None
             else None
         )
+        value = result.result
+        rendered_result = (
+            f"<{type(value).__name__}: {len(value):,} bytes>"
+            if isinstance(value, (bytes, bytearray, memoryview))
+            else bounded_text(repr(value)) if value is not None else None
+        )
         return ExecutionReport(
             ok=result.success,
-            stdout=stdout,
-            stderr=stderr,
-            result=repr(result.result) if result.result is not None else None,
+            stdout=bounded_text(stdout),
+            stderr=bounded_text(stderr),
+            result=rendered_result,
             displays=tuple(displays),
             error=error,
             images=tuple(images),

codebind-0.6.18/src/codebind/model_text.py

@@ -0,0 +1,16 @@
+"""Keep model-facing text bounded without changing native IPython history."""
+
+from __future__ import annotations
+
+MAXIMUM_MODEL_TEXT_CHARACTERS = 16_384
+
+
+def bounded_text(value: str, limit: int = MAXIMUM_MODEL_TEXT_CHARACTERS) -> str:
+    """Keep useful head and tail text; do not send enormous binary representations."""
+    if len(value) <= limit:
+        return value
+    if value.startswith(("b'", 'b"', "bytearray(b'", 'bytearray(b"')):
+        return f"<binary representation omitted: {len(value):,} characters>"
+    head, tail = limit // 2, limit // 4
+    omitted = len(value) - head - tail
+    return value[:head] + f"\n… {omitted:,} characters omitted …\n" + value[-tail:]