codebind 0.1.5__tar.gz → 0.3.0__tar.gz

{codebind-0.1.5 → codebind-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.1.5
-Summary: A minimal model loop over a persistent IPython session.
+Version: 0.3.0
+Summary: A frontend-neutral model loop for persistent IPython sessions.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili
 Author-email: Giovanni Gravili <ghovax@users.noreply.github.com>
@@ -17,7 +17,6 @@ Classifier: Typing :: Typed
 Requires-Dist: ipython>=9.0
 Requires-Dist: langchain-core>=1.0
 Requires-Dist: models-provider>=0.1.0
-Requires-Dist: rich>=14.0
 Requires-Python: >=3.13
 Project-URL: Repository, https://github.com/ghovax/codebind
 Project-URL: Issues, https://github.com/ghovax/codebind/issues
@@ -25,7 +24,7 @@ Description-Content-Type: text/markdown
 
 # Codebind
 
-Codebind runs a model with one tool: an IPython cell executed in the session shared with the user. Conversation history belongs to a `Session`; the model is selected independently for every call.
+Codebind is an IPython extension that runs a model with one tool: an IPython cell executed in the active session. IPython owns execution, namespace, history, magics, tracebacks, and rich display; Codebind owns only conversation and model orchestration.
 
 ## Installation
 
@@ -41,18 +40,18 @@ Or install it with any Python package installer:
 pip install codebind
 ```
 
-After installation, start the preconfigured shell from any directory:
+After installation, start ordinary IPython with the Codebind extension from any directory:
 
 ```console
 codebind
 ```
 
-It opens IPython with `chat` and `Models` already available and renders a short Markdown usage guide in the terminal. It does not modify the user's global IPython profile.
+It opens standard IPython with `chat` and `Models` in the user namespace. All normal IPython command-line options remain available.
 
 ```python
 models = Models({"openai": "OPENAI_API_KEY"})
 
-chat.ask(
+chat.send(
     "Inspect this project and tell me what to implement first.",
     models.chat("openai/gpt-5", reasoning_effort="medium"),
 )
@@ -60,6 +59,29 @@ chat.ask(
 
 Codebind does not load files or construct a project prompt automatically. The user states what should be loaded as context. Pass `instructions=` to `Session` only when an application needs its own system instructions.
 
+## Jupyter
+
+Install Codebind in the environment used by a Jupyter kernel, then start the Jupyter frontend normally:
+
+```console
+pip install codebind jupyterlab
+jupyter lab
+```
+
+Load Codebind in a notebook:
+
+```python
+%load_ext codebind
+
+models = Models({"openai": "OPENAI_API_KEY"})
+model = models.chat("openai/gpt-5")
+await chat.asend("Inspect the current notebook state.", model)
+```
+
+Codebind publishes cells, assistant Markdown, stdout, tracebacks, and rich results through IPython's MIME display system. The active frontend decides how to render HTML, Markdown, images, SVG, audio, tables, and plain text.
+
+Model-authored cells are recorded in native IPython history and displayed through the active frontend. A kernel cannot insert a genuine input cell into every possible frontend without a frontend-specific extension, so Codebind does not attempt to control notebook or editor UI.
+
 ## ChatGPT account login
 
 Models Provider can start its OpenAI browser sign-in flow directly from IPython:
@@ -72,7 +94,7 @@ authorization = await models.sign_in("openai")
 webbrowser.open(authorization.url)
 await authorization.complete()
 
-chat.ask(
+chat.send(
     "Inspect this project.",
     models.chat("openai/gpt-5", authorization=authorization),
 )

{codebind-0.1.5 → codebind-0.3.0}/README.md

@@ -1,6 +1,6 @@
 # Codebind
 
-Codebind runs a model with one tool: an IPython cell executed in the session shared with the user. Conversation history belongs to a `Session`; the model is selected independently for every call.
+Codebind is an IPython extension that runs a model with one tool: an IPython cell executed in the active session. IPython owns execution, namespace, history, magics, tracebacks, and rich display; Codebind owns only conversation and model orchestration.
 
 ## Installation
 
@@ -16,18 +16,18 @@ Or install it with any Python package installer:
 pip install codebind
 ```
 
-After installation, start the preconfigured shell from any directory:
+After installation, start ordinary IPython with the Codebind extension from any directory:
 
 ```console
 codebind
 ```
 
-It opens IPython with `chat` and `Models` already available and renders a short Markdown usage guide in the terminal. It does not modify the user's global IPython profile.
+It opens standard IPython with `chat` and `Models` in the user namespace. All normal IPython command-line options remain available.
 
 ```python
 models = Models({"openai": "OPENAI_API_KEY"})
 
-chat.ask(
+chat.send(
     "Inspect this project and tell me what to implement first.",
     models.chat("openai/gpt-5", reasoning_effort="medium"),
 )
@@ -35,6 +35,29 @@ chat.ask(
 
 Codebind does not load files or construct a project prompt automatically. The user states what should be loaded as context. Pass `instructions=` to `Session` only when an application needs its own system instructions.
 
+## Jupyter
+
+Install Codebind in the environment used by a Jupyter kernel, then start the Jupyter frontend normally:
+
+```console
+pip install codebind jupyterlab
+jupyter lab
+```
+
+Load Codebind in a notebook:
+
+```python
+%load_ext codebind
+
+models = Models({"openai": "OPENAI_API_KEY"})
+model = models.chat("openai/gpt-5")
+await chat.asend("Inspect the current notebook state.", model)
+```
+
+Codebind publishes cells, assistant Markdown, stdout, tracebacks, and rich results through IPython's MIME display system. The active frontend decides how to render HTML, Markdown, images, SVG, audio, tables, and plain text.
+
+Model-authored cells are recorded in native IPython history and displayed through the active frontend. A kernel cannot insert a genuine input cell into every possible frontend without a frontend-specific extension, so Codebind does not attempt to control notebook or editor UI.
+
 ## ChatGPT account login
 
 Models Provider can start its OpenAI browser sign-in flow directly from IPython:
@@ -47,7 +70,7 @@ authorization = await models.sign_in("openai")
 webbrowser.open(authorization.url)
 await authorization.complete()
 
-chat.ask(
+chat.send(
     "Inspect this project.",
     models.chat("openai/gpt-5", authorization=authorization),
 )

{codebind-0.1.5 → codebind-0.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "codebind"
-version = "0.1.5"
-description = "A minimal model loop over a persistent IPython session."
+version = "0.3.0"
+description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 requires-python = ">=3.13"
 license = "MIT"
@@ -26,7 +26,6 @@ dependencies = [
     "ipython>=9.0",
     "langchain-core>=1.0",
     "models-provider>=0.1.0",
-    "rich>=14.0",
 ]
 
 [[project.authors]]

{codebind-0.1.5 → codebind-0.3.0}/pyproject.toml.orig

@@ -1,7 +1,7 @@
 [project]
 name = "codebind"
-version = "0.1.5"
-description = "A minimal model loop over a persistent IPython session."
+version = "0.3.0"
+description = "A frontend-neutral model loop for persistent IPython sessions."
 readme = "README.md"
 authors = [
     { name = "Giovanni Gravili", email = "ghovax@users.noreply.github.com" }
@@ -23,7 +23,6 @@ dependencies = [
     "ipython>=9.0",
     "langchain-core>=1.0",
     "models-provider>=0.1.0",
-    "rich>=14.0",
 ]
 
 [project.urls]

{codebind-0.1.5 → codebind-0.3.0}/src/codebind/__init__.py

@@ -3,6 +3,7 @@
 from importlib.metadata import version
 
 from .execution import ExecutionReport, IPythonExecutor
+from .extension import load_ipython_extension, unload_ipython_extension
 from .session import Session
 
 
@@ -13,4 +14,6 @@ __all__ = [
     "IPythonExecutor",
     "Session",
     "__version__",
+    "load_ipython_extension",
+    "unload_ipython_extension",
 ]

codebind-0.3.0/src/codebind/cli.py

@@ -0,0 +1,17 @@
+"""Standard IPython launcher with the Codebind extension loaded."""
+
+from __future__ import annotations
+
+import sys
+
+from IPython import start_ipython
+
+from . import __version__
+
+
+def main() -> None:
+    """Start ordinary IPython with Codebind loaded as an extension."""
+    if sys.argv[1:] == ["--version"]:
+        print(f"codebind {__version__}")
+        return
+    start_ipython(argv=["--ext=codebind", *sys.argv[1:]])

codebind-0.3.0/src/codebind/display.py

@@ -0,0 +1,15 @@
+"""Frontend-neutral output through IPython's MIME display protocol."""
+
+from __future__ import annotations
+
+from IPython.display import Code, display
+
+
+def display_cell(cell: str) -> None:
+    """Display model-authored cell source in the active frontend."""
+    display(Code(cell, language="python"))
+
+
+def display_assistant(text: str) -> None:
+    """Publish assistant text as plain text and Markdown MIME representations."""
+    display({"text/plain": text, "text/markdown": text}, raw=True)

{codebind-0.1.5 → codebind-0.3.0}/src/codebind/execution.py

@@ -8,6 +8,9 @@ from typing import Any
 from IPython.core.interactiveshell import InteractiveShell
 from IPython.utils.capture import capture_output
 
+from .display import display_cell
+
+
 @dataclass(frozen=True, slots=True)
 class ExecutionReport:
     """The model-facing result of one IPython cell."""
@@ -31,18 +34,37 @@ class IPythonExecutor:
         self.shell = shell
 
     def execute(self, cell: str) -> ExecutionReport:
-        """Execute a cell, replay its visible output, and capture a structured result."""
+        """Execute a cell through IPython and replay its native rich output."""
         if not isinstance(cell, str) or not cell.strip():
             raise ValueError("cell must be a non-empty string")
 
-        displayhook = self.shell.displayhook
-        original_output_prompt = displayhook.write_output_prompt
-        displayhook.write_output_prompt = lambda: None
-        try:
-            with capture_output() as captured:
-                result = self.shell.run_cell(cell, store_history=True)
-        finally:
-            displayhook.write_output_prompt = original_output_prompt
+        display_cell(cell)
+        with capture_output() as captured:
+            result = self.shell.run_cell(cell, store_history=True)
+        captured.show()
+
+        return self._report(result, captured)
+
+    async def aexecute(self, cell: str) -> ExecutionReport:
+        """Execute an async-capable cell and replay its native rich output."""
+        if not isinstance(cell, str) or not cell.strip():
+            raise ValueError("cell must be a non-empty string")
+
+        display_cell(cell)
+        transformed = self.shell.transform_cell(cell)
+        with capture_output() as captured:
+            result = await self.shell.run_cell_async(
+                cell,
+                store_history=True,
+                transformed_cell=transformed,
+            )
+        captured.show()
+
+        return self._report(result, captured)
+
+    @staticmethod
+    def _report(result: Any, captured: Any) -> ExecutionReport:
+        """Build the model-facing text projection of an IPython execution."""
 
         displays: list[str] = []
         for output in captured.outputs:

codebind-0.3.0/src/codebind/extension.py

@@ -0,0 +1,34 @@
+"""IPython extension entry points."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from IPython.core.interactiveshell import InteractiveShell
+from models_provider import Models
+
+from .session import Session
+
+
+_NAMESPACE_ATTRIBUTE = "_codebind_extension_namespace"
+
+
+def load_ipython_extension(ipython: InteractiveShell) -> None:
+    """Load Codebind into the active IPython user namespace."""
+    previous = getattr(ipython, _NAMESPACE_ATTRIBUTE, None)
+    if isinstance(previous, dict):
+        ipython.drop_by_id(previous)
+    namespace: dict[str, Any] = {
+        "chat": Session(shell=ipython),
+        "Models": Models,
+    }
+    ipython.push(namespace)
+    setattr(ipython, _NAMESPACE_ATTRIBUTE, namespace)
+
+
+def unload_ipython_extension(ipython: InteractiveShell) -> None:
+    """Remove names added by Codebind without touching user replacements."""
+    namespace = getattr(ipython, _NAMESPACE_ATTRIBUTE, None)
+    if isinstance(namespace, dict):
+        ipython.drop_by_id(namespace)
+        delattr(ipython, _NAMESPACE_ATTRIBUTE)

{codebind-0.1.5 → codebind-0.3.0}/src/codebind/session.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 from collections.abc import Mapping, Sequence
 from typing import Any
@@ -12,9 +13,8 @@ from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage
 from langchain_core.runnables import Runnable
 
+from .display import display_assistant
 from .execution import ExecutionReport, IPythonExecutor
-from .prompts import render_cell
-from .rendering import TerminalRenderer
 
 
 IPYTHON_TOOL = {
@@ -73,7 +73,6 @@ class Session:
 
         self.shell = resolved_shell
         self.executor = IPythonExecutor(resolved_shell)
-        self.renderer = TerminalRenderer()
         self.instructions = instructions.strip() if instructions else None
         self.messages: list[BaseMessage] = []
         self.last_response: AIMessage | None = None
@@ -87,8 +86,15 @@ class Session:
         if self.instructions:
             self.messages.append(SystemMessage(self.instructions))
 
-    def ask(self, prompt: str, model: BaseChatModel) -> None:
-        """Run one user turn with the explicitly supplied model."""
+    def send(self, prompt: str, model: BaseChatModel) -> None:
+        """Send one user message synchronously."""
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+        else:
+            raise RuntimeError("send() cannot run inside an active event loop; use await asend().")
+
         text = prompt.strip()
         if not text:
             raise ValueError("prompt cannot be empty")
@@ -106,7 +112,7 @@ class Session:
             if not response.tool_calls:
                 answer = _message_text(response)
                 if answer:
-                    self.renderer.assistant(answer)
+                    display_assistant(answer)
                 return
 
             for call in response.tool_calls:
@@ -119,6 +125,38 @@ class Session:
                     )
                 )
 
+    async def asend(self, prompt: str, model: BaseChatModel) -> None:
+        """Send one user message asynchronously."""
+        text = prompt.strip()
+        if not text:
+            raise ValueError("prompt cannot be empty")
+
+        bound_model = self._bind(model)
+        self.messages.append(HumanMessage(text))
+
+        while True:
+            response = await bound_model.ainvoke(tuple(self.messages))
+            if not isinstance(response, AIMessage):
+                raise TypeError("model must return an AIMessage")
+            self.messages.append(response)
+            self.last_response = response
+
+            if not response.tool_calls:
+                answer = _message_text(response)
+                if answer:
+                    display_assistant(answer)
+                return
+
+            for call in response.tool_calls:
+                report = await self._aexecute_call(call)
+                identifier = str(call.get("id") or f"ipython-{len(self.messages)}")
+                self.messages.append(
+                    ToolMessage(
+                        json.dumps(report.as_dict(), ensure_ascii=False),
+                        tool_call_id=identifier,
+                    )
+                )
+
     @staticmethod
     def _bind(model: BaseChatModel) -> Runnable[Any, BaseMessage]:
         try:
@@ -133,11 +171,20 @@ class Session:
         if not isinstance(arguments, Mapping) or not isinstance(arguments.get("cell"), str):
             return _tool_error("InvalidArguments", "ipython requires a string cell argument")
 
-        cell = arguments["cell"]
-        render_cell(self.shell, cell)
         try:
-            report = self.executor.execute(cell)
+            report = self.executor.execute(arguments["cell"])
         except Exception as error:  # The failure must be returned to the model, not end the session.
             report = _tool_error(type(error).__name__, str(error))
-        self.renderer.tool_output(report, self.shell)
         return report
+
+    async def _aexecute_call(self, call: Mapping[str, Any]) -> ExecutionReport:
+        if call.get("name") != "ipython":
+            return _tool_error("UnknownTool", f"unknown tool: {call.get('name')!r}")
+        arguments = call.get("args")
+        if not isinstance(arguments, Mapping) or not isinstance(arguments.get("cell"), str):
+            return _tool_error("InvalidArguments", "ipython requires a string cell argument")
+
+        try:
+            return await self.executor.aexecute(arguments["cell"])
+        except Exception as error:
+            return _tool_error(type(error).__name__, str(error))

codebind-0.1.5/src/codebind/cli.py

@@ -1,45 +0,0 @@
-"""Project-local IPython launcher with Codebind conveniences preloaded."""
-
-from __future__ import annotations
-
-import argparse
-from typing import Any
-
-from IPython.core.interactiveshell import InteractiveShell
-from IPython.terminal.ipapp import TerminalIPythonApp
-from models_provider import Models
-from rich.console import Console
-from rich.markdown import Markdown
-
-from . import __version__
-from .session import Session
-
-
-BANNER = """\
-- `models = Models({...})`
-- `chat.ask("...", models.chat("provider/model"))`
-"""
-
-
-def namespace(shell: InteractiveShell) -> dict[str, Any]:
-    """Build the small namespace exposed by the Codebind shell."""
-    return {
-        "chat": Session(shell=shell),
-        "Models": Models,
-    }
-
-
-def main() -> None:
-    """Start IPython in the current directory with Codebind preloaded."""
-    parser = argparse.ArgumentParser(description="Start a model-enabled IPython session.")
-    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
-    parser.parse_args()
-
-    Console().print(Markdown(BANNER))
-    application = TerminalIPythonApp.instance()
-    application.display_banner = False
-    application.initialize([])
-    shell = application.shell
-    shell.enable_tip = False
-    shell.push(namespace(shell))
-    application.start()

codebind-0.1.5/src/codebind/prompts.py

@@ -1,36 +0,0 @@
-"""Native IPython prompt rendering for model-authored cells."""
-
-from __future__ import annotations
-
-import sys
-
-from IPython.terminal.ptutils import IPythonPTLexer
-from prompt_toolkit.document import Document
-from prompt_toolkit.formatted_text import FormattedText, PygmentsTokens
-from prompt_toolkit.shortcuts import print_formatted_text
-
-
-def render_cell(shell: object, cell: str) -> None:
-    """Render a cell with IPython's lexer, prompt tokens, and terminal style."""
-    lexer = IPythonPTLexer().lex_document(Document(cell))
-    pt_app = getattr(shell, "pt_app", None)
-    style = pt_app.app.style if pt_app is not None else None
-    sys.stdout.write(getattr(shell, "separate_in", "\n"))
-    prompts = shell.prompts
-
-    for index, _line in enumerate(cell.split("\n")):
-        prompt_tokens = (
-            prompts.in_prompt_tokens()
-            if index == 0
-            else prompts.continuation_prompt_tokens(lineno=index - 1)
-        )
-        print_formatted_text(PygmentsTokens(prompt_tokens), style=style, end="")
-        print_formatted_text(FormattedText(lexer(index)), style=style)
-
-
-def render_output_prompt(shell: object) -> None:
-    """Render an output prompt with IPython's terminal style."""
-    pt_app = getattr(shell, "pt_app", None)
-    style = pt_app.app.style if pt_app is not None else None
-    sys.stdout.write(getattr(shell, "separate_out", "") or "\n")
-    print_formatted_text(PygmentsTokens(shell.prompts.out_prompt_tokens()), style=style, end="")

codebind-0.1.5/src/codebind/rendering.py

@@ -1,43 +0,0 @@
-"""Terminal rendering for model responses and IPython tool output."""
-
-from __future__ import annotations
-
-from rich.console import Console
-from rich.markdown import Markdown
-from rich.text import Text
-
-from .execution import ExecutionReport
-from .prompts import render_output_prompt
-
-
-def _visible_output(report: ExecutionReport) -> str:
-    parts = [part for part in (report.stdout, report.stderr) if part]
-    if report.displays:
-        parts.extend(report.displays)
-    elif not parts and report.result is not None:
-        parts.append(report.result)
-    if not parts and report.error is not None:
-        parts.append(f"{report.error['type']}: {report.error['message']}")
-    return "\n".join(part.rstrip("\n") for part in parts if part).strip("\n")
-
-
-class TerminalRenderer:
-    """Render tool output and Markdown answers to the active terminal."""
-
-    def __init__(self) -> None:
-        self.console = Console()
-
-    def tool_output(self, report: ExecutionReport, shell: object) -> None:
-        """Show the complete tool output."""
-        visible = _visible_output(report)
-        if not visible:
-            return
-        output = Text.from_ansi(visible)
-        if report.ok:
-            render_output_prompt(shell)
-        self.console.print(output)
-
-    def assistant(self, text: str) -> None:
-        """Render the final model response as terminal Markdown."""
-        self.console.print()
-        self.console.print(Markdown(f"---\n\n{text}\n\n---"))