codebind 0.6.16__tar.gz → 0.6.18__tar.gz

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

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

@@ -48,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 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.16 → codebind-0.6.18}/pyproject.toml

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

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

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

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

@@ -12,6 +12,7 @@ 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
@@ -58,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:
@@ -263,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.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:]

{codebind-0.6.16 → codebind-0.6.18}/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.16 → codebind-0.6.18}/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
@@ -326,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())
@@ -391,6 +417,8 @@ def install_question_mode(shell: TerminalInteractiveShell) -> Callable[[], None]
         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