cmpnd 0.86.0__tar.gz → 0.87.0__tar.gz

{cmpnd-0.86.0 → cmpnd-0.87.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.86.0
+Version: 0.87.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -19,7 +19,6 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Requires-Dist: dspy>=3.3.0
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: ipython>=8.20
 Requires-Dist: pydantic>=2.0
 Requires-Dist: typing-extensions>=4.1.0
 Requires-Dist: xxhash>=3.0.0
@@ -28,6 +27,7 @@ Requires-Dist: basedpyright>=1.39; extra == 'dev'
 Requires-Dist: boto3>=1.34; extra == 'dev'
 Requires-Dist: gepa; extra == 'dev'
 Requires-Dist: hypothesis>=6.100; extra == 'dev'
+Requires-Dist: ipython>=8.20; extra == 'dev'
 Requires-Dist: jsonschema>=4.0; extra == 'dev'
 Requires-Dist: litellm; extra == 'dev'
 Requires-Dist: litellm<1.102; (python_version >= '3.15') and extra == 'dev'
@@ -47,6 +47,8 @@ Requires-Dist: pillow>=10.0; extra == 'images'
 Provides-Extra: mcp
 Requires-Dist: dspy>=3.3.1; extra == 'mcp'
 Requires-Dist: mcp>=1.9; extra == 'mcp'
+Provides-Extra: shell
+Requires-Dist: ipython>=8.20; extra == 'shell'
 Description-Content-Type: text/markdown
 
 # cmpnd
@@ -61,6 +63,10 @@ deployments and optimization runs under that name.
 uv add cmpnd      # or: pip install cmpnd
 ```
 
+The interactive `cmpnd` shell uses IPython when you install the `shell` extra:
+`uv add 'cmpnd[shell]'` or `pip install 'cmpnd[shell]'`. The plain install
+leaves IPython out, and the shell then runs on the standard Python prompt.
+
 ## Authentication
 
 The `cmpnd` library works with the cmpnd service at

{cmpnd-0.86.0 → cmpnd-0.87.0}/README.md

@@ -10,6 +10,10 @@ deployments and optimization runs under that name.
 uv add cmpnd      # or: pip install cmpnd
 ```
 
+The interactive `cmpnd` shell uses IPython when you install the `shell` extra:
+`uv add 'cmpnd[shell]'` or `pip install 'cmpnd[shell]'`. The plain install
+leaves IPython out, and the shell then runs on the standard Python prompt.
+
 ## Authentication
 
 The `cmpnd` library works with the cmpnd service at

{cmpnd-0.86.0 → cmpnd-0.87.0}/cmpnd/callback.py

@@ -1052,8 +1052,10 @@ class _ModuleMixin(_CallbackBase):
                 cleaned_outputs = helpers.clean_outputs(captured_outputs, instance, dspy, self._max_output_field_size)
                 span.set_outputs(cleaned_outputs)
 
-                # Extract token usage if available
-                self._extract_usage_from_prediction(span, captured_outputs, dspy)
+        # A module span records no token usage. Its LM call spans carry each
+        # call's usage, and a trace's totals sum every span, so usage copied
+        # from the Prediction here would count each call once more per
+        # enclosing module.
 
         # Pop from context stack
         context.pop_span()
@@ -1462,32 +1464,6 @@ class _ModuleMixin(_CallbackBase):
             trace.tags["optimization_phase"] = phase
         return trace
 
-    def _extract_usage_from_prediction(self, span: models.SpanBuilder, outputs: Any, dspy: Any) -> None:
-        """Sum the LM usage a DSPy Prediction carries onto its module span.
-
-        This is what fills the trace row's own token totals, so a shape read
-        wrongly here reports a trace as having spent no tokens even when the LM
-        spans below it carry the right counts.
-        """
-        if not isinstance(outputs, dspy.Prediction):
-            return
-        usage_by_model = outputs.get_lm_usage() if hasattr(outputs, "get_lm_usage") else None
-        if not usage_by_model:
-            return
-        for model_usage in usage_by_model.values():
-            counts = _normalize_usage(model_usage)
-            span.prompt_tokens += counts["prompt_tokens"] or 0
-            span.completion_tokens += counts["completion_tokens"] or 0
-            span.total_tokens += counts["total_tokens"] or 0
-            span.cached_prompt_tokens += counts["cached_prompt_tokens"] or 0
-            # Summed only over the models that reported one, so a span whose
-            # models all stayed silent keeps the field absent rather than 0.
-            for name in ("reasoning_tokens", "cache_write_tokens"):
-                reported = counts[name]
-                if reported is None:
-                    continue
-                setattr(span, name, (getattr(span, name) or 0) + reported)
-
 
 class _LMMixin(_CallbackBase):
     """DSPy LM callbacks (on_lm_start/on_lm_end)."""

{cmpnd-0.86.0 → cmpnd-0.87.0}/cmpnd/cli/shell.py

@@ -648,28 +648,37 @@ def _enable_readline(namespace: dict[str, Any]) -> None:
     atexit.register(_save_history)
 
 
+_NO_IPYTHON_HINT = "IPython is not installed. For completion and history, run: pip install 'cmpnd[shell]'\n"
+
+
 def _launch_repl(namespace: dict[str, Any], banner: str) -> None:
-    """Prefer IPython (Jedi completion, history, multi-line); fall back to stdlib."""
+    """Prefer IPython (Jedi completion, history, multi-line); fall back to stdlib.
+
+    IPython ships in the optional ``cmpnd[shell]`` extra. Without it, the shell
+    prints one line that names the extra and runs on ``code.interact``.
+    """
     try:
-        from IPython import start_ipython
-        from traitlets.config import Config
+        import IPython
+        import traitlets.config
     except ImportError:
         import code
 
+        sys.stderr.write(_NO_IPYTHON_HINT)
+        sys.stderr.flush()
         _enable_readline(namespace)
         sys.stdout.write(banner)
         sys.stdout.flush()
         code.interact(banner="", local=namespace, exitmsg="")
         return
 
-    cfg = Config()
+    cfg = traitlets.config.Config()
     cfg.TerminalInteractiveShell.banner1 = banner
     cfg.TerminalInteractiveShell.banner2 = ""
     cfg.TerminalInteractiveShell.confirm_exit = False
     # IPython 9.x appends a random "Tip: use %timeit ..." after banner2.
     # Suppress — our own banner already tells users what to type.
     cfg.TerminalInteractiveShell.enable_tip = False
-    start_ipython(argv=[], user_ns=namespace, config=cfg)
+    IPython.start_ipython(argv=[], user_ns=namespace, config=cfg)
 
 
 def launch(api_key: str | None = None, endpoint: str | None = None) -> None:

{cmpnd-0.86.0 → cmpnd-0.87.0}/docs/cli.md

@@ -6,7 +6,11 @@ runs and inspects DSPy programs on the platform. Every command reads
 `--api-key` and `--endpoint`. `cmpnd auth me` prints the resolved identity.
 
 Bare `cmpnd`, with no subcommand, opens an interactive Python shell with the
-platform verbs loaded (`cmpnd.cli.shell`).
+platform verbs loaded (`cmpnd.cli.shell`). The shell runs on IPython when the
+`cmpnd[shell]` extra is installed (`pip install 'cmpnd[shell]'`), which adds
+Jedi completion, multi-line input and history search. Without the extra, the
+shell prints one line that names it and runs on the standard library's
+`code.interact` with readline completion.
 
 ## Program names
 

{cmpnd-0.86.0 → cmpnd-0.87.0}/docs/sdk-instrumentation.md

@@ -115,7 +115,7 @@ bindings, the judge picks one through `lms[name]`. A `TypeSafe` object passed in
 The hook methods, in the order you'd expect them to fire for a typical `dspy.ChainOfThought` call:
 
 - **Module lifecycle** — `on_module_start` (`callback.py`) creates a new `SpanBuilder`, and, if this is the root module call, also creates a new `TraceBuilder` via `_create_trace`. `on_module_end` closes the span, attaches outputs, and, if it was the root, exports the trace. A call is root when no span is on the stack — or when the only span above it is the `Evaluate` span, which contains many independent program runs and parents none of them, so each run under a `dspy.Evaluate` roots its own trace. Such a root span is built with `create_child_span(..., root=True)` so it does not adopt the `Evaluate` span as its parent.
-- **LM calls.** `on_lm_start` and `on_lm_end` wrap the provider call. The callback records the model, the current span token projections, and a versioned `lm_usage` evidence object. `capture_prompts` controls whether the prompt payload is recorded.
+- **LM calls.** `on_lm_start` and `on_lm_end` wrap the provider call. The callback records the model, the LM call span's token counts, and a versioned `lm_usage` evidence object. `capture_prompts` controls whether the prompt payload is recorded. Only an LM call span carries token counts. A module span records none, even when DSPy's `track_usage` puts the usage on its `Prediction`, because the SDK's trace totals and serve's trace fold both add up every span, and a module span holding its calls' usage would count each call again for every module that encloses it (`tests/test_token_attribution.py`).
 - **Adapter format/parse** — `on_adapter_format_start` / `_end` and `on_adapter_parse_start` / `_end`. Both route through the shared helpers `_start_adapter_span` and `_end_adapter_span`. The callback records one span per adapter call. DSPy's `Adapter.__init_subclass__` wraps `format` and `parse` on every subclass, so a `JSONAdapter.format` call fires the hooks twice and a `BAMLAdapter.format` call three times, each with a fresh `call_id` and the same instance. `_start_adapter_span` skips a call when the current span is the same method's adapter span on the same instance, and `_end_adapter_span` returns early for the skipped `call_id`. The outermost span is kept, since its output is what reaches the LM. `tests/test_adapter_reentrancy.py` runs the real adapters under DSPy's dispatch. An adapter span's inputs are the method's arguments, so they include the predictor's `signature`. `helpers.clean_inputs` records any signature class among a span's inputs by its label, the class name or the `in1, in2 -> out1` fields of a string signature. It never records the repr, which embeds the whole instructions and every field's metadata. The same rule covers a `Predict` called with `signature=`, as DSPy's RLM does on every turn from DSPy `main` on. The span records the signature's fields and instructions once, as its own attributes.
 - **Tools** — `on_tool_start` / `on_tool_end` (`callback.py`). One span per `dspy.Tool` invocation, with the tool's args as inputs.
 - **Interpreter (code execution)** — `_InterpreterMixin` (`callback.py`), for the DSPy `CodeInterpreter` hooks DSPy >= 3.3.1 fires around a program running code in the interpreter (`RLM`, `ProgramOfThought`, `CodeAct`, `Flex` — every module reaching it through `_create_interpreter`; `ReAct` / `ReActV2` use no interpreter and fire none). `on_interpreter_execute_start` / `_end` emit one `INTERPRETER_EXECUTE` span per REPL cell — the code in, its captured stdout out, and the `SUBMIT()` result (a DSPy `FinalOutput`) recorded distinctly from stdout. On DSPy 3.4.1 and later, `RLM` runs the sandbox side of its `dspy` stand-in as each session's first cell, marked by the `__dspy_host_token` variable (`dspy.primitives.facade.HOST_TOKEN_VAR`). That cell is DSPy's machinery rather than a step the program took, so it emits no span. `on_interpreter_tool_call_start` / `_end` synthesize a `TOOL` span for a tool called from interpreter code **only when no real `dspy.Tool` span covered the call** (a user tool routes through `Tool.__call__` and fires `on_tool_*`, so its row is suppressed to avoid a duplicate; the `llm_query` builtins fire no tool hook, so they get the synthesized span). `on_interpreter_startup_*` / `on_interpreter_shutdown_*` emit no span — their duration folds into an `interpreter.startup_ms` / `interpreter.shutdown_ms` attribute on the enclosing span, and an event with no enclosing span (a pooled pre-warm) is dropped.
@@ -840,7 +840,7 @@ A span's dict looks roughly like this:
     "span_id": "...",
     "trace_id": "...",
     "parent_span_id": "...",
-    "span_type": "predict",
+    "span_type": "lm_call",
     "start_time": "2020-01-02T00:00:00+00:00",
     "status": "ok",
     "project_tags": [],

{cmpnd-0.86.0 → cmpnd-0.87.0}/pyproject.toml

@@ -5,7 +5,7 @@ name = "cmpnd"
 # it's new) — no git tags. Bump with `uv version --bump {minor,patch}` or by
 # hand. Runtime `cmpnd.__version__` reads installed metadata, so it tracks
 # this automatically. See docs/plans/2026-07-02-sdk-pypi-tag-free-publish.md.
-version = "0.86.0"
+version = "0.87.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -45,10 +45,6 @@ dependencies = [
     # basis; the C module is an order of magnitude faster and every ordinary
     # install should have it.
     "xxhash>=3.0.0",
-    # Powers the interactive `cmpnd` shell (Jedi completion, multi-line,
-    # history search, syntax highlighting). No upper cap. The shell falls back
-    # to stdlib `code.interact` + rlcompleter if IPython somehow can't import.
-    "ipython>=8.20",
 ]
 
 [project.optional-dependencies]
@@ -59,6 +55,14 @@ dependencies = [
 images = [
     "pillow>=10.0",
 ]
+# The interactive `cmpnd` shell's IPython front end: Jedi completion, multi-line
+# input, history search and syntax highlighting. Optional, because IPython and its
+# dependency tree would otherwise land in every environment that only traces or
+# deploys programs. Without it, the shell runs on stdlib `code.interact` with
+# rlcompleter and prints one line that names this extra. No upper cap.
+shell = [
+    "ipython>=8.20",
+]
 # The MCP client library, needed only by `cmpnd.mcp_tools` when it connects to a tool
 # server from a notebook. Optional and lazily imported: it pulls a transport stack that
 # an SDK used purely for tracing, deploying and optimizing never touches, and its
@@ -110,6 +114,9 @@ dev = [
     # Exercises the image-thumbnail path (the `images` extra) so the positive
     # branch is covered in CI, not just the Pillow-absent fallback.
     "pillow>=10.0",
+    # Exercises the shell's IPython front end (the `shell` extra) so both REPL
+    # branches are covered in CI.
+    "ipython>=8.20",
     # The metadata validator the release path runs, brought in-tree so sdk-lint
     # can check a freshly built wheel + sdist BEFORE release day. Floor is the
     # first twine whose `packaging` understands `Metadata-Version: 2.5`, which

{cmpnd-0.86.0 → cmpnd-0.87.0}/tests/test_cli/test_shell.py

@@ -708,7 +708,21 @@ class TestDeployHelper:
 class TestReplFallback:
     def test_falls_back_when_ipython_missing(self):
         with mock.patch.dict("sys.modules", {"IPython": None}):
-            with mock.patch("code.interact") as interact:
+            with mock.patch("code.interact", autospec=True) as interact:
                 shell._launch_repl({"x": 1}, "BANNER\n")
         interact.assert_called_once()
         assert interact.call_args.kwargs["local"] == {"x": 1}
+
+    def test_fallback_names_the_shell_extra(self, capsys):
+        with mock.patch.dict("sys.modules", {"IPython": None}):
+            with mock.patch("code.interact", autospec=True):
+                shell._launch_repl({}, "BANNER\n")
+        err = capsys.readouterr().err
+        assert err.count("\n") == 1
+        assert "pip install 'cmpnd[shell]'" in err
+
+    def test_ipython_prints_no_fallback_line(self, capsys):
+        with mock.patch("IPython.start_ipython", autospec=True) as start:
+            shell._launch_repl({}, "BANNER\n")
+        start.assert_called_once()
+        assert "cmpnd[shell]" not in capsys.readouterr().err

{cmpnd-0.86.0 → cmpnd-0.87.0}/tests/test_lm_usage_shapes.py

@@ -575,73 +575,3 @@ def test_finish_reason_from_typed_response():
 def test_finish_reason_absent_when_nothing_reports_one():
     span = _span_for(_responses_usage(), response=_ResponsesResponse("in_progress"))
     assert span.attributes.get("lm.finish_reason") == "in_progress"
-
-
-# --- Module-level aggregation (the trace's own totals) ---------------------
-
-
-@pytest.mark.parametrize("shape", _SHAPE_PARAMS)
-def test_prediction_usage_aggregates_on_every_shape(shape: str):
-    """``Prediction.get_lm_usage()`` feeds the module span, and so the trace row.
-
-    A trace reporting no prompt or completion tokens at all, while its LM spans
-    below carry counts, is this path reading zeros one level above them.
-    """
-    import dspy
-
-    from cmpnd.callback import CmpndCallback
-
-    with mock.patch("cmpnd.exporter.ensure_exporter_started", autospec=True):
-        callback = CmpndCallback()
-
-    span = mock.MagicMock()
-    span.prompt_tokens = 0
-    span.completion_tokens = 0
-    span.total_tokens = 0
-    span.cached_prompt_tokens = 0
-    span.reasoning_tokens = None
-    span.cache_write_tokens = None
-
-    prediction = dspy.Prediction(answer="Paris")
-    prediction.set_lm_usage({"openai/gpt-5.6-luna": _SHAPES[shape]()})
-
-    callback._extract_usage_from_prediction(span, prediction, dspy)
-
-    assert span.prompt_tokens == 2900
-    assert span.completion_tokens == 17
-    assert span.total_tokens == 2917
-    assert span.cached_prompt_tokens == 1024
-    assert span.reasoning_tokens == 12
-
-
-def test_prediction_usage_sums_across_models():
-    import dspy
-
-    from cmpnd.callback import CmpndCallback
-
-    with mock.patch("cmpnd.exporter.ensure_exporter_started", autospec=True):
-        callback = CmpndCallback()
-
-    span = mock.MagicMock()
-    span.prompt_tokens = 0
-    span.completion_tokens = 0
-    span.total_tokens = 0
-    span.cached_prompt_tokens = 0
-    span.reasoning_tokens = None
-    span.cache_write_tokens = None
-
-    prediction = dspy.Prediction(answer="Paris")
-    prediction.set_lm_usage(
-        {
-            "openai/gpt-5.6-luna": _chat_usage(),
-            "anthropic/claude-sonnet-4": _responses_usage(),
-        }
-    )
-
-    callback._extract_usage_from_prediction(span, prediction, dspy)
-
-    assert span.prompt_tokens == 5800
-    assert span.completion_tokens == 34
-    assert span.reasoning_tokens == 24
-    # Nothing reported a cache write, so the sum stays absent rather than 0.
-    assert span.cache_write_tokens is None

cmpnd-0.87.0/tests/test_token_attribution.py

@@ -0,0 +1,122 @@
+"""Each LM call's tokens land on exactly one span: its own LM call span.
+
+A trace's token total is the sum over its spans, both in the SDK's own trace
+roll-up and in serve's trace fold. A module span that also carried the usage of
+the LM calls beneath it would count every call once per enclosing module.
+
+These tests run real DSPy modules over the in-process fake provider, with DSPy's
+``track_usage`` on so each ``Prediction`` reports its LM usage, and check what
+the callback hands the exporter.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest import mock
+
+import pytest
+
+dspy = pytest.importorskip("dspy")
+litellm = pytest.importorskip("litellm")
+
+from cmpnd import configure, shutdown_exporter  # noqa: E402
+from cmpnd.callback import CmpndCallback  # noqa: E402
+from cmpnd.context import clear_context  # noqa: E402
+from cmpnd.models import SpanType  # noqa: E402
+from tests.e2e import fake_lm  # noqa: E402
+
+
+class _RecordingExporter:
+    def __init__(self) -> None:
+        self.traces: list[Any] = []
+
+    def export_trace_start(self, trace: Any) -> None:
+        pass
+
+    def export_trace_finalize(self, trace: Any) -> None:
+        self.traces.append(trace)
+
+    def export_span(self, span: Any) -> None:
+        pass
+
+    def export_trace(self, trace: Any) -> None:
+        self.traces.append(trace)
+
+
+@pytest.fixture
+def traced():
+    """Run a callable under the cmpnd callback and return the exported trace."""
+    saved_providers = list(litellm.custom_provider_map)
+    fake_lm.register()
+    configure(api_key="test_key")
+    exporter = _RecordingExporter()
+
+    def run(program: Any, **kwargs: Any) -> Any:
+        with (
+            mock.patch("cmpnd.exporter.get_exporter", autospec=True, return_value=exporter),
+            mock.patch("cmpnd.exporter.ensure_exporter_started", autospec=True),
+        ):
+            callback = CmpndCallback()
+            lm = dspy.LM(fake_lm.FAKE_MODEL, cache=False)
+            with dspy.context(lm=lm, callbacks=[callback], track_usage=True):
+                prediction = program(**kwargs)
+        # The fixture only matters if DSPy really reported usage on the Prediction.
+        assert prediction.get_lm_usage(), "track_usage did not attach LM usage"
+        assert len(exporter.traces) == 1
+        return exporter.traces[0]
+
+    yield run
+
+    litellm.custom_provider_map = saved_providers
+    clear_context()
+    import cmpnd.configuration
+
+    cmpnd.configuration._config = None
+    shutdown_exporter()
+
+
+def _spans(trace: Any) -> list[Any]:
+    return list(trace._batch_spans)
+
+
+def _lm_spans(trace: Any) -> list[Any]:
+    return [s for s in _spans(trace) if s.span_type == SpanType.LM_CALL]
+
+
+def _assert_tokens_only_on_lm_calls(trace: Any) -> None:
+    for span in _spans(trace):
+        if span.span_type == SpanType.LM_CALL:
+            continue
+        assert (span.prompt_tokens, span.completion_tokens, span.total_tokens, span.cached_prompt_tokens) == (
+            0,
+            0,
+            0,
+            0,
+        ), f"{span.span_type.value} span carries tokens"
+        assert span.reasoning_tokens is None
+        assert span.cache_write_tokens is None
+
+
+def test_module_over_one_lm_call_counts_the_call_once(traced):
+    trace = traced(dspy.Predict("text -> sentiment"), text="I love it")
+
+    [lm_span] = _lm_spans(trace)
+    assert lm_span.prompt_tokens > 0
+    assert lm_span.completion_tokens > 0
+    _assert_tokens_only_on_lm_calls(trace)
+    assert trace.prompt_tokens == lm_span.prompt_tokens
+    assert trace.completion_tokens == lm_span.completion_tokens
+    assert trace.total_tokens == lm_span.total_tokens
+
+
+def test_nested_modules_count_each_call_once(traced):
+    """ChainOfThought wraps a Predict: two module spans over one LM call."""
+    trace = traced(dspy.ChainOfThought("question -> answer"), question="What is 2 + 2?")
+
+    lm_spans = _lm_spans(trace)
+    assert len(lm_spans) == 1
+    assert len([s for s in _spans(trace) if s.span_type != SpanType.LM_CALL]) >= 2
+    _assert_tokens_only_on_lm_calls(trace)
+    assert trace.prompt_tokens == sum(s.prompt_tokens for s in lm_spans)
+    assert trace.completion_tokens == sum(s.completion_tokens for s in lm_spans)
+    assert trace.total_tokens == sum(s.total_tokens for s in lm_spans)

{cmpnd-0.86.0 → cmpnd-0.87.0}/uv.lock

@@ -505,7 +505,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.86.0"
+version = "0.87.0"
 source = { editable = "." }
 default-groups = ["dspy-3-4-1"]
 dependencies = [
@@ -514,7 +514,6 @@ dependencies = [
     { name = "dspy", version = "3.4.0", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-5-cmpnd-dspy-3-4-0' or (extra == 'extra-5-cmpnd-mcp' and extra == 'group-5-cmpnd-dspy-3-3-0') or (extra == 'group-5-cmpnd-dspy-3-3-0' and extra == 'group-5-cmpnd-dspy-3-3-1') or (extra == 'group-5-cmpnd-dspy-3-3-0' and extra == 'group-5-cmpnd-dspy-3-4-1') or (extra == 'group-5-cmpnd-dspy-3-3-1' and extra == 'group-5-cmpnd-dspy-3-4-1')" },
     { name = "dspy", version = "3.4.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-5-cmpnd-dspy-3-4-1' or (extra == 'group-5-cmpnd-dspy-3-3-0' and extra == 'group-5-cmpnd-dspy-3-3-1') or (extra == 'group-5-cmpnd-dspy-3-3-0' and extra == 'group-5-cmpnd-dspy-3-4-0') or (extra == 'group-5-cmpnd-dspy-3-3-1' and extra == 'group-5-cmpnd-dspy-3-4-0') or (extra == 'extra-5-cmpnd-mcp' and extra != 'group-5-cmpnd-dspy-3-3-1' and extra != 'group-5-cmpnd-dspy-3-4-0') or (extra != 'group-5-cmpnd-dspy-3-3-0' and extra != 'group-5-cmpnd-dspy-3-3-1' and extra != 'group-5-cmpnd-dspy-3-4-0')" },
     { name = "httpx" },
-    { name = "ipython" },
     { name = "pydantic" },
     { name = "typing-extensions" },
     { name = "xxhash" },
@@ -527,6 +526,7 @@ dev = [
     { name = "gepa", version = "0.1.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-5-cmpnd-dspy-3-3-0' or (extra == 'group-5-cmpnd-dspy-3-3-1' and extra == 'group-5-cmpnd-dspy-3-4-0') or (extra == 'group-5-cmpnd-dspy-3-3-1' and extra == 'group-5-cmpnd-dspy-3-4-1') or (extra == 'group-5-cmpnd-dspy-3-4-0' and extra == 'group-5-cmpnd-dspy-3-4-1')" },
     { name = "gepa", version = "0.1.4", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'extra-5-cmpnd-mcp' or extra != 'group-5-cmpnd-dspy-3-3-0' or extra == 'group-5-cmpnd-dspy-3-3-1' or extra == 'group-5-cmpnd-dspy-3-4-0' or extra == 'group-5-cmpnd-dspy-3-4-1'" },
     { name = "hypothesis" },
+    { name = "ipython" },
     { name = "jsonschema" },
     { name = "litellm" },
     { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
@@ -552,6 +552,9 @@ mcp = [
     { name = "dspy", version = "3.4.1", source = { registry = "https://pypi.org/simple" }, marker = "extra == 'group-5-cmpnd-dspy-3-4-1' or (extra == 'group-5-cmpnd-dspy-3-3-0' and extra == 'group-5-cmpnd-dspy-3-3-1') or (extra == 'group-5-cmpnd-dspy-3-3-0' and extra == 'group-5-cmpnd-dspy-3-4-0') or (extra == 'group-5-cmpnd-dspy-3-3-1' and extra == 'group-5-cmpnd-dspy-3-4-0') or (extra == 'extra-5-cmpnd-mcp' and extra != 'group-5-cmpnd-dspy-3-3-1' and extra != 'group-5-cmpnd-dspy-3-4-0') or (extra != 'group-5-cmpnd-dspy-3-3-0' and extra != 'group-5-cmpnd-dspy-3-3-1' and extra != 'group-5-cmpnd-dspy-3-4-0')" },
     { name = "mcp" },
 ]
+shell = [
+    { name = "ipython" },
+]
 
 [package.dev-dependencies]
 dspy-3-3-0 = [
@@ -577,7 +580,8 @@ requires-dist = [
     { name = "gepa", marker = "extra == 'dev'" },
     { name = "httpx", specifier = ">=0.27.0" },
     { name = "hypothesis", marker = "extra == 'dev'", specifier = ">=6.100" },
-    { name = "ipython", specifier = ">=8.20" },
+    { name = "ipython", marker = "extra == 'dev'", specifier = ">=8.20" },
+    { name = "ipython", marker = "extra == 'shell'", specifier = ">=8.20" },
     { name = "jsonschema", marker = "extra == 'dev'", specifier = ">=4.0" },
     { name = "litellm", marker = "python_full_version >= '3.15' and extra == 'dev'", specifier = "<1.102" },
     { name = "litellm", marker = "extra == 'dev'" },
@@ -596,7 +600,7 @@ requires-dist = [
     { name = "typing-extensions", specifier = ">=4.1.0" },
     { name = "xxhash", specifier = ">=3.0.0" },
 ]
-provides-extras = ["images", "mcp", "dev", "fake-provider"]
+provides-extras = ["images", "shell", "mcp", "dev", "fake-provider"]
 
 [package.metadata.requires-dev]
 dspy-3-3-0 = [{ name = "dspy", specifier = "==3.3.0" }]