cmpnd 0.27.3__tar.gz → 0.27.4__tar.gz

{cmpnd-0.27.3 → cmpnd-0.27.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.27.3
+Version: 0.27.4
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>

cmpnd-0.27.4/cmpnd/_runtime_tools.py

@@ -0,0 +1,39 @@
+"""Private provenance for tools that CMPND adds while a program runs."""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+_RUNTIME_TOOL_MARKER = "_cmpnd_runtime_tool"
+
+
+class _RuntimeToolProvenance:
+    """An in-process token that keeps its identity through DSPy module copies."""
+
+    def __copy__(self) -> _RuntimeToolProvenance:
+        return self
+
+    def __deepcopy__(self, memo: dict[int, Any]) -> _RuntimeToolProvenance:
+        del memo
+        return self
+
+
+_RUNTIME_TOOL_PROVENANCE = _RuntimeToolProvenance()
+_T = TypeVar("_T")
+
+
+def mark_runtime_tool(tool: _T) -> _T:
+    """Mark a platform-created tool without trusting a caller-chosen boolean."""
+    setattr(tool, _RUNTIME_TOOL_MARKER, _RUNTIME_TOOL_PROVENANCE)
+    function = getattr(tool, "func", None)
+    if function is not None:
+        setattr(function, _RUNTIME_TOOL_MARKER, _RUNTIME_TOOL_PROVENANCE)
+    return tool
+
+
+def is_runtime_tool(tool: object) -> bool:
+    """Return whether this process marked the tool or its wrapped callable."""
+    if getattr(tool, _RUNTIME_TOOL_MARKER, None) is _RUNTIME_TOOL_PROVENANCE:
+        return True
+    function = getattr(tool, "func", None)
+    return getattr(function, _RUNTIME_TOOL_MARKER, None) is _RUNTIME_TOOL_PROVENANCE

{cmpnd-0.27.3 → cmpnd-0.27.4}/cmpnd/ir/reflection.py

@@ -14,6 +14,7 @@ from typing import Any
 
 import dspy
 
+from .._runtime_tools import is_runtime_tool
 from . import program, types
 
 _PRIM_BY_PYTYPE: dict[Any, types.PrimKind] = {
@@ -123,9 +124,17 @@ def reflect(m: Any) -> program.Module:
     react_cls = _opt("ReAct")
     if react_cls is not None and isinstance(m, react_cls):
         tools = getattr(m, "tools", None) or {}
-        # Exclude DSPy's auto-injected `finish` sentinel — identity is the
-        # user-supplied tool set, not the runtime control-flow primitive.
-        names = tuple(sorted(n for n in tools if n != "finish"))
+        # Exclude runtime control tools. DSPy supplies `finish`; a hosted worker may
+        # add marked platform tools that are absent from the authored program. Check
+        # the explicit marker rather than a name, so a user's similarly named tool
+        # remains part of the program's identity.
+        names = tuple(
+            sorted(
+                name
+                for name, tool in tools.items()
+                if name != "finish" and not (name.startswith("cmpnd_") and is_runtime_tool(tool))
+            )
+        )
         return program.ReAct(signature=project_sig(m.signature), tools=names)
 
     bestofn_cls = _opt("BestOfN")

{cmpnd-0.27.3 → cmpnd-0.27.4}/cmpnd/packaging.py

@@ -30,6 +30,8 @@ from typing import TYPE_CHECKING, Any
 
 import typing_extensions
 
+from ._runtime_tools import is_runtime_tool
+
 if TYPE_CHECKING:
     import dspy
 
@@ -802,6 +804,12 @@ def declared_module_tools(module: dspy.Module) -> dict[str, typing.Any]:
             continue
         pending.extend(vars(member).values())
         for name, tool in module_tools(member).items():
+            if name.startswith("cmpnd_") and is_runtime_tool(tool):
+                continue
+            if name.startswith("cmpnd_"):
+                raise ValueError(
+                    f"tool name {name!r} uses the reserved cmpnd_ prefix; rename the tool before deploying"
+                )
             if is_bare_mcp_tool(tool):
                 _resolve_an_mcp_tool(name, tool, {})
             previous = collected.get(name)
@@ -818,6 +826,8 @@ def declared_module_tools(module: dspy.Module) -> dict[str, typing.Any]:
 def generate_program_source(
     module: dspy.Module,
     mcp_tools: Mapping[tuple[str, str], typing.Any] | None = None,
+    *,
+    _declarations: list[dict[str, typing.Any]] | None = None,
 ) -> str:
     """Return raw Python source for module.
 
@@ -968,6 +978,12 @@ def generate_program_source(
         from . import mcp_servers
 
         mcp_bindings: list[tuple[Any, str]] = []
+
+        def mcp_tool_expression(route: str, alias: str, *, wrap: bool = False) -> str:
+            if wrap or alias != route:
+                return f"dspy.Tool({route}, name={alias!r})"
+            return route
+
         for name, tool in tools_dict.items():
             if name == "finish":
                 continue
@@ -977,18 +993,22 @@ def generate_program_source(
                 # instead of a body — see [_generate_mcp_tool_stub]. The `def`'s name is
                 # the MCP tool's own, because the declaration names the tool and the
                 # worker maps that name to the token it holds.
-                signature = mcp_servers.synthesized_signature(pinned)
-                lines.append(_generate_mcp_tool_stub(pinned, signature))
-                mcp_bindings.append((mcp_servers.mcp_tool_reference(tool), f"dspy.Tool({signature.name})"))
-                mcp_declarations.append(
-                    {
-                        "tool": signature.name,
-                        "server": pinned.server_url,
-                        "schema_hash": pinned.schema_hash,
-                        "parameters": signature.parameter_names,
-                    }
-                )
-                tool_names.append(signature.name)
+                reference = mcp_servers.mcp_tool_reference(tool)
+                route = next((route for declared, route in mcp_bindings if declared == reference), None)
+                if route is None:
+                    signature = mcp_servers.synthesized_signature(pinned)
+                    route = signature.name
+                    lines.append(_generate_mcp_tool_stub(pinned, signature))
+                    mcp_bindings.append((reference, route))
+                    mcp_declarations.append(
+                        {
+                            "tool": route,
+                            "server": pinned.server_url,
+                            "schema_hash": pinned.schema_hash,
+                            "parameters": signature.parameter_names,
+                        }
+                    )
+                tool_names.append(mcp_tool_expression(route, name))
                 continue
             func = getattr(tool, "func", None)
             if func is not None:
@@ -1024,9 +1044,10 @@ def generate_program_source(
                 ancestors = ancestors | {id(value)}
                 reference = mcp_servers.mcp_tool_reference(value)
                 if reference is not None:
-                    for declared, source in mcp_bindings:
+                    for declared, route in mcp_bindings:
                         if reference == declared:
-                            return source
+                            alias = str(getattr(value, "name", route))
+                            return mcp_tool_expression(route, alias, wrap=True)
                     raise ValueError(
                         "MCP tool binding is not declared by this program; deploy the authored source file"
                     )
@@ -1178,6 +1199,8 @@ def generate_program_source(
     # decide whether an empty list means "none" or "not resolved".
     if mcp_declarations:
         lines.append(f"{MCP_TOOLS_DECLARATION} = {mcp_declarations!r}")
+        if _declarations is not None:
+            _declarations.extend(mcp_declarations)
 
     return "\n\n".join(lines)
 
@@ -1346,7 +1369,12 @@ def generate_source_zip(
     """
     import dspy
 
-    program_source = generate_program_source(module, mcp_tools=mcp_tools)
+    tool_declarations: list[dict[str, typing.Any]] = []
+    program_source = generate_program_source(
+        module,
+        mcp_tools=mcp_tools,
+        _declarations=tool_declarations,
+    )
 
     metric_filename = None
     metric_source = None
@@ -1359,7 +1387,7 @@ def generate_source_zip(
 
     lm = _extract_lm_object(module)
     declarations = lm_configuration.resolve({"default-lm": lm} if lm is not None else {}, require_all=False)
-    manifest = {
+    manifest: dict[str, typing.Any] = {
         "lm_capabilities": declarations,
         "dependency_versions": {
             "python": platform.python_version(),
@@ -1368,6 +1396,8 @@ def generate_source_zip(
         "program": "program_source.py",
         "metric": metric_filename,
     }
+    if tool_declarations:
+        manifest["tools"] = tool_declarations
 
     buf = io.BytesIO()
     with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:

{cmpnd-0.27.3 → cmpnd-0.27.4}/docs/cli.md

@@ -282,12 +282,14 @@ immediately, because the credential goes with it. The confirmation says so.
 A program built with `cmpnd.mcp_tools` deploys against exactly this registry.
 `cmpnd deploy` resolves each of the program's tool references against it before
 packaging anything — one listing read plus one read per server, and none at all
-for a program with no MCP tools — so the bundle pins the same reduced schema the
-platform will validate every call against. An unregistered server and a tool the
-registry does not list are both refused at the terminal, naming the tool, the
-server and the command that fixes it; the platform refuses the same two
-authoritatively, plus a tool that is registered but not allow-listed and a schema
-that has changed since the program was built. See
+for a program with no MCP tools — so the bundle records declarations built from the
+current reduced schema and its hash. Serve checks that hash against the current
+registry at deploy time. mcp-tools validates each call against the current stored
+schema, so a refresh can change call validation after a program was built. An
+unregistered server and a tool the registry does not list are both refused at the
+terminal, naming the tool, the server and the command that fixes it; the platform
+refuses the same two authoritatively, plus a tool that is registered but not
+allow-listed and a schema that has changed since the program was built. See
 [`sdk-instrumentation.md`](sdk-instrumentation.md) for what the bundle carries in
 place of a tool's body.
 

{cmpnd-0.27.3 → cmpnd-0.27.4}/docs/sdk-instrumentation.md

@@ -401,7 +401,8 @@ def web_search_exa(query: str, numResults: float | None = None) -> dict:
 
 
 __cmpnd_mcp_tools__ = [{'tool': 'web_search_exa', 'server': 'https://mcp.exa.ai/mcp',
-                        'schema_hash': '…', 'parameters': ['query', 'numResults']}]
+                        'schema_hash': '…',
+                        'parameters': ['query', 'numResults']}]
 ```
 
 The body is a refusal because the deployed program runs in the kernel, which has no MCP
@@ -425,6 +426,13 @@ annotation at all for a type name the table does not carry. A property name that
 Python identifier, or is a keyword, refuses the deploy — it is never mangled, because the
 name has to reach the MCP server unchanged.
 
+The SDK uses the registry's pinned, secret-free `input_schema` to construct the generated
+function signature. The source marker and generated bundle manifest retain `schema_hash`
+and `parameters`. Serve checks the hash against the registry at deploy time, and the
+worker uses the parameters for positional binding. Runtime schema inspection reads the
+current stored schema through credentialed-egress and mcp-tools, so it does not rely on a
+schema copy in the program bundle.
+
 ### Direct local MCP discovery supports two client generations
 
 When registry lookup falls back to a direct local connection, the SDK lists tools
@@ -622,3 +630,9 @@ The WASM kernel calls tools through a typed worker import. The worker holds the
 scoped tokens and returns the MCP result document. Optional arguments omitted by
 the program remain omitted. ReAct's tool callbacks produce the application span;
 the worker adds transport measurements to that span using its correlation ID.
+
+The worker reserves the `cmpnd_` prefix for platform tools. Deployment refuses an
+authored tool that uses this prefix and asks the author to rename it. Platform tools
+that the worker adds while a program runs carry a private, copy-stable provenance token.
+Only tools carrying that token stay out of the program's identity and generated bundle.
+Setting a similarly named attribute does not grant platform provenance.

{cmpnd-0.27.3 → cmpnd-0.27.4}/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.27.3"
+version = "0.27.4"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.10"

{cmpnd-0.27.3 → cmpnd-0.27.4}/tests/test_exporter.py

@@ -13,6 +13,7 @@ from typing import Any
 from uuid import uuid4
 
 import httpx
+import pytest
 
 from cmpnd import retry
 from cmpnd.configuration import Config
@@ -1007,9 +1008,10 @@ def test_data_send_retry_exhausted_counts_error():
     assert exporter._dropped_count == 0
 
 
-def test_data_send_does_not_retry_500():
-    """A 500 is the platform's to answer for — counted once, not retried."""
-    capture = SequenceCapture([500])
+@pytest.mark.parametrize("status", [422, 500])
+def test_data_send_does_not_retry_permanent_error(status: int):
+    """The exporter counts a permanent error once and does not retry it."""
+    capture = SequenceCapture([status])
     exporter = _make_seq_exporter(capture)
 
     exporter._flush_batch([ExportItem(item_type="trace", data=_make_trace(), timestamp=0.0)])

{cmpnd-0.27.3 → cmpnd-0.27.4}/tests/test_packaging_mcp_tools.py

@@ -21,6 +21,9 @@ from __future__ import annotations
 
 import ast
 import functools
+import io
+import json
+import zipfile
 from typing import Any
 
 import pytest
@@ -28,7 +31,8 @@ import pytest
 dspy = pytest.importorskip("dspy")
 
 from cmpnd import mcp_servers  # noqa: E402
-from cmpnd.packaging import generate_program_source  # noqa: E402
+from cmpnd._runtime_tools import mark_runtime_tool  # noqa: E402
+from cmpnd.packaging import declared_module_tools, generate_program_source, generate_source_zip  # noqa: E402
 
 global_search_tool: Any = None
 global_search_tools: Any = None
@@ -132,6 +136,7 @@ class TestTheGeneratedStub:
         assert "'tool': 'web_search_exa'" in source
         assert f"'server': {_EXA_SERVER!r}" in source
         assert f"'schema_hash': {'c' * 64!r}" in source
+        assert "'input_schema'" not in source
         assert "'parameters': ['query', 'numResults']" in source
 
     def test_the_declared_parameters_are_the_defs_own_in_order(self, monkeypatch):
@@ -145,6 +150,65 @@ class TestTheGeneratedStub:
         declared = namespace["__cmpnd_mcp_tools__"][0]
         stub = namespace[declared["tool"]]
         assert list(inspect.signature(stub).parameters) == declared["parameters"]
+        assert "input_schema" not in declared
+
+    def test_the_zip_manifest_carries_the_same_pinned_declaration(self, monkeypatch):
+        tools = _exa_tools(monkeypatch)
+        archive_bytes = generate_source_zip(
+            _react_with(tools[0]),
+            mcp_tools={(_EXA_SERVER, "web_search_exa"): _EXA_SEARCH},
+        )
+        with zipfile.ZipFile(io.BytesIO(archive_bytes)) as archive:
+            manifest = json.loads(archive.read("manifest.json"))
+            namespace: dict[str, Any] = {}
+            exec(compile(archive.read("program_source.py"), "<generated>", "exec"), namespace)  # noqa: S102
+
+        assert manifest["tools"] == namespace["__cmpnd_mcp_tools__"]
+
+    def test_the_zip_preserves_an_alias_while_the_declaration_keeps_the_route(self, monkeypatch):
+        tool = _exa_tools(monkeypatch)[0]
+        tool.name = "fetch_pages"
+        archive_bytes = generate_source_zip(
+            _react_with(tool),
+            mcp_tools={(_EXA_SERVER, "web_search_exa"): _EXA_SEARCH},
+        )
+        with zipfile.ZipFile(io.BytesIO(archive_bytes)) as archive:
+            manifest = json.loads(archive.read("manifest.json"))
+            namespace: dict[str, Any] = {}
+            exec(compile(archive.read("program_source.py"), "<generated>", "exec"), namespace)  # noqa: S102
+
+        rebuilt = namespace["module"]
+        assert set(rebuilt.tools) == {"fetch_pages", "finish"}
+        assert rebuilt.tools["fetch_pages"].func.__name__ == "web_search_exa"
+        assert manifest["tools"] == [
+            {
+                "tool": "web_search_exa",
+                "server": _EXA_SERVER,
+                "schema_hash": "c" * 64,
+                "parameters": ["query", "numResults"],
+            }
+        ]
+
+    def test_two_aliases_share_one_canonical_declaration(self, monkeypatch):
+        first = _exa_tools(monkeypatch)[0]
+        second = _exa_tools(monkeypatch)[0]
+        first.name = "fetch_pages"
+        second.name = "search_pages"
+        archive_bytes = generate_source_zip(
+            dspy.ReAct("question -> answer", tools=[first, second]),
+            mcp_tools={(_EXA_SERVER, "web_search_exa"): _EXA_SEARCH},
+        )
+        with zipfile.ZipFile(io.BytesIO(archive_bytes)) as archive:
+            manifest = json.loads(archive.read("manifest.json"))
+            namespace: dict[str, Any] = {}
+            exec(compile(archive.read("program_source.py"), "<generated>", "exec"), namespace)  # noqa: S102
+
+        rebuilt = namespace["module"]
+        assert set(rebuilt.tools) == {"fetch_pages", "search_pages", "finish"}
+        assert {rebuilt.tools[name].func.__name__ for name in ("fetch_pages", "search_pages")} == {"web_search_exa"}
+        assert len(manifest["tools"]) == 1
+        assert manifest["tools"][0]["tool"] == "web_search_exa"
+        assert "input_schema" not in manifest["tools"][0]
 
     def test_the_generated_source_names_the_stub_in_the_tools_kwarg(self, monkeypatch):
         source = self._source(monkeypatch)
@@ -360,7 +424,45 @@ class TestPlainToolsAreUnaffected:
         assert "'tool': 'web_search_exa'" in source
         assert "'_add_at_module_scope'" not in source, "a source tool is not an MCP declaration"
 
+    def test_user_tool_in_the_platform_namespace_is_refused(self):
+        module = dspy.ReAct(
+            "question -> answer",
+            tools=[dspy.Tool(_add_at_module_scope, name="cmpnd_inspect_tool_schema")],
+        )
+        with pytest.raises(ValueError, match="cmpnd_inspect_tool_schema.*rename"):
+            generate_program_source(module)
+
+    def test_user_cannot_claim_platform_provenance_with_a_boolean_attribute(self):
+        tool = dspy.Tool(_add_at_module_scope, name="ordinary_tool")
+        tool._cmpnd_runtime_tool = True
+        module = _react_with(tool)
+        del module.tools[tool.name]
+        module.tools["cmpnd_inspect_tool_schema"] = tool
+
+        with pytest.raises(ValueError, match="cmpnd_inspect_tool_schema.*rename"):
+            generate_program_source(module)
+
+    def test_runtime_platform_tool_is_not_packaged(self):
+        module = _react_with(dspy.Tool(_add_at_module_scope))
+        ambient = mark_runtime_tool(dspy.Tool(_runtime_inspector_at_module_scope, name="cmpnd_inspect_tool_schema"))
+        module.tools[ambient.name] = ambient
+
+        assert "cmpnd_inspect_tool_schema" not in declared_module_tools(module)
+
+    def test_marked_non_platform_tool_is_still_packaged(self):
+        module = _react_with(dspy.Tool(_add_at_module_scope))
+        marked = dspy.Tool(_add_at_module_scope, name="inspect_tool_schema")
+        marked._cmpnd_runtime_tool = True
+        module.tools[marked.name] = marked
+
+        assert "inspect_tool_schema" in declared_module_tools(module)
+
 
 def _add_at_module_scope(x: int, y: int) -> int:
     """Add two numbers."""
     return x + y
+
+
+def _runtime_inspector_at_module_scope(tool: str) -> str:
+    """Test-only stand-in for the worker's ambient schema inspector."""
+    return tool

{cmpnd-0.27.3 → cmpnd-0.27.4}/tests/test_reflector_properties.py

@@ -12,6 +12,7 @@ import pytest
 from hypothesis import HealthCheck, assume, given, settings
 from hypothesis import strategies as st
 
+from cmpnd._runtime_tools import mark_runtime_tool
 from cmpnd.ir import (
     ChainOfThought as IR_ChainOfThought,
 )
@@ -155,6 +156,60 @@ def test_react_tool_set_changes_hash() -> None:
     assert program_signature_hash(reflect(r1)) != program_signature_hash(reflect(r2))
 
 
+def test_react_platform_tool_does_not_change_hash() -> None:
+    def search(query: str) -> str:
+        return query
+
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    react = dspy.ReAct("q -> a", tools=[search])
+    before = program_signature_hash(reflect(react))
+    ambient = mark_runtime_tool(dspy.Tool(inspect_schema, name="cmpnd_inspect_tool_schema"))
+    react.tools[ambient.name] = ambient
+
+    assert program_signature_hash(reflect(react)) == before
+
+
+def test_react_user_tool_with_platform_prefix_remains_part_of_identity() -> None:
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    plain = dspy.ReAct("q -> a", tools=[])
+    user_tool = dspy.ReAct(
+        "q -> a",
+        tools=[dspy.Tool(inspect_schema, name="cmpnd_inspect_tool_schema")],
+    )
+
+    assert program_signature_hash(reflect(user_tool)) != program_signature_hash(reflect(plain))
+
+
+def test_react_boolean_marker_cannot_remove_an_exposed_alias_from_identity() -> None:
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    plain = dspy.ReAct("q -> a", tools=[])
+    user_tool = dspy.Tool(inspect_schema, name="ordinary_tool")
+    user_tool._cmpnd_runtime_tool = True
+    forged = dspy.ReAct("q -> a", tools=[user_tool])
+    del forged.tools[user_tool.name]
+    forged.tools["cmpnd_inspect_tool_schema"] = user_tool
+
+    assert program_signature_hash(reflect(forged)) != program_signature_hash(reflect(plain))
+
+
+def test_react_marked_non_platform_tool_remains_part_of_identity() -> None:
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    plain = dspy.ReAct("q -> a", tools=[])
+    user_tool = dspy.Tool(inspect_schema, name="inspect_tool_schema")
+    user_tool._cmpnd_runtime_tool = True
+    marked = dspy.ReAct("q -> a", tools=[user_tool])
+
+    assert program_signature_hash(reflect(marked)) != program_signature_hash(reflect(plain))
+
+
 def test_refine_distinct_from_inner() -> None:
     import cmpnd.ir
 

{cmpnd-0.27.3 → cmpnd-0.27.4}/tests/test_reflector_smoke.py

@@ -54,6 +54,7 @@ import dspy
 import numpy as np
 import pytest
 
+from cmpnd._runtime_tools import mark_runtime_tool
 from cmpnd.ir import (
     KNN as IR_KNN,
 )
@@ -121,6 +122,17 @@ def _sample_tool(query: str) -> str:
     return query
 
 
+def _inspect_tool_schema(tool: str) -> str:
+    return tool
+
+
+def _build_react() -> dspy.ReAct:
+    react = dspy.ReAct("q -> a", tools=[_sample_tool])
+    inspector = mark_runtime_tool(dspy.Tool(_inspect_tool_schema, name="cmpnd_inspect_tool_schema"))
+    react.tools[inspector.name] = inspector
+    return react
+
+
 def _build_user_composite() -> dspy.Module:
     class _TwoPredictApp(dspy.Module):
         def __init__(self) -> None:
@@ -202,6 +214,7 @@ def _check_react(ir: Any) -> None:
         f"expected user tool in {ir.tools}"
     )
     assert "finish" not in ir.tools, "auto-injected finish sentinel leaked into identity"
+    assert "cmpnd_inspect_tool_schema" not in ir.tools, "ambient platform tool leaked into identity"
 
 
 def _check_best_of_n(ir: Any) -> None:
@@ -285,7 +298,7 @@ KIND_FIXTURES: tuple[KindFixture, ...] = (
         name="ReAct",
         dspy_attr="ReAct",
         ir_cls=IR_ReAct,
-        build=lambda: dspy.ReAct("q -> a", tools=[_sample_tool]),
+        build=_build_react,
         required_attrs=("signature", "tools"),
         extra=_check_react,
     ),

{cmpnd-0.27.3 → cmpnd-0.27.4}/tests/test_retry.py

@@ -29,6 +29,7 @@ class TestClassification:
         assert not retry.is_retryable(_resp(500, body={"error": "boom"}))
         assert not retry.is_retryable(_resp(400))
         assert not retry.is_retryable(_resp(404))
+        assert not retry.is_retryable(_resp(422))
         assert not retry.is_retryable(_resp(429))
 
     def test_explicit_false_is_not_retryable(self):

cmpnd-0.27.4/tests/test_runtime_tools.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import copy
+
+import dspy
+
+from cmpnd._runtime_tools import is_runtime_tool, mark_runtime_tool
+
+
+def test_an_arbitrary_boolean_on_a_tool_is_not_runtime_provenance() -> None:
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    tool = dspy.Tool(inspect_schema, name="cmpnd_inspect_tool_schema")
+    tool._cmpnd_runtime_tool = True
+
+    assert not is_runtime_tool(tool)
+
+
+def test_an_arbitrary_boolean_on_a_function_is_not_runtime_provenance() -> None:
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    inspect_schema._cmpnd_runtime_tool = True
+
+    assert not is_runtime_tool(dspy.Tool(inspect_schema, name="cmpnd_inspect_tool_schema"))
+
+
+def test_runtime_provenance_survives_tool_and_module_copies() -> None:
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    tool = mark_runtime_tool(dspy.Tool(inspect_schema, name="cmpnd_inspect_tool_schema"))
+    react = dspy.ReAct("q -> a", tools=[tool])
+
+    assert is_runtime_tool(copy.copy(tool))
+    assert is_runtime_tool(copy.deepcopy(tool))
+    assert is_runtime_tool(react.deepcopy().tools[tool.name])
+
+
+def test_runtime_provenance_survives_callable_normalization() -> None:
+    def inspect_schema(tool: str) -> str:
+        return tool
+
+    marked = mark_runtime_tool(inspect_schema)
+
+    assert is_runtime_tool(dspy.Tool(marked, name="cmpnd_inspect_tool_schema"))

{cmpnd-0.27.3 → cmpnd-0.27.4}/uv.lock

@@ -496,7 +496,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.27.3"
+version = "0.27.4"
 source = { editable = "." }
 dependencies = [
     { name = "dspy" },