cmpnd 0.27.2__tar.gz → 0.27.3__tar.gz

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

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

{cmpnd-0.27.2 → cmpnd-0.27.3}/cmpnd/__init__.py

@@ -214,3 +214,8 @@ def de_instrument() -> None:
     _gepa_patch.unpatch_gepa()
     _program_patch.unpatch_program_state()
     _rlm_patch.unpatch_rlm_tools()
+
+
+def _mcp_tool(declaration):  # pyright: ignore[reportUnusedFunction] -- generated bundles call this hook
+    """Keep generated declarations importable outside a worker without granting access."""
+    return declaration

{cmpnd-0.27.2 → cmpnd-0.27.3}/cmpnd/_authored_import.py

@@ -122,7 +122,6 @@ def _program_facts(
     from .authored import ProgramFacts
 
     references = deployment._mcp_tool_references(program)
-    deployment._refuse_mcp_tools_outside_rlm(program, references)
     pinned: dict[tuple[str, str], Any] = {}
     if references:
         import httpx

{cmpnd-0.27.2 → cmpnd-0.27.3}/cmpnd/deployment.py

@@ -250,7 +250,7 @@ def _mcp_tool_references(module) -> list[Any]:
     """Every MCP reference the program's tools carry, deduplicated, in a stable order."""
     references: list[Any] = []
     seen: set[tuple[str, str]] = set()
-    for tool in packaging.module_tools(module).values():
+    for tool in packaging.declared_module_tools(module).values():
         reference = mcp_servers.mcp_tool_reference(tool)
         if reference is None:
             continue
@@ -262,48 +262,6 @@ def _mcp_tool_references(module) -> list[Any]:
     return references
 
 
-def _refuse_mcp_tools_outside_rlm(module, references: list[Any]) -> None:
-    """Refuse a program that declares MCP tools and is not a `dspy.RLM`.
-
-    **At deploy, because the alternative arrives mid-turn in a deployed program.** The
-    worker answers an MCP-backed tool where `dspy.RLM`'s inner interpreter parks waiting
-    for one; that is the only place it can intervene without the kernel holding a token it
-    must never see. A `dspy.ReAct` program calls its tools from kernel Python directly, so
-    the call reaches the `def` the packager generated and raises — loud, but at run time,
-    in front of whoever is reading the answer rather than whoever can change the program.
-
-    **A state check and not a name check.** `isinstance` against the live class is what
-    makes a subclass, a rename and a re-export all answer correctly; matching
-    `type(module).__name__` against a list would pass the first and refuse the last. It is
-    the reason this lives here and not in serve: the create body's `module_class` is a
-    display string a client fills in, and a guard over it would fail open in both
-    directions.
-
-    Absent `dspy.RLM` refuses too, following `cmpnd.callback`'s idiom. A dspy with no RLM
-    is a dspy with no path that can serve these tools at all, so refusing is the honest
-    answer rather than a gap.
-    """
-    if not references:
-        return
-    # Deferred, as every other dspy use in this module is: a deploy of a program with no
-    # MCP tools returns above and never pays for the import.
-    import dspy
-
-    if isinstance(module, getattr(dspy, "RLM", type(None))):
-        return
-    names = ", ".join(sorted(reference.tool_name for reference in references))
-    noun = "the MCP tool" if len(references) == 1 else "the MCP tools"
-    raise ValueError(
-        f"{type(module).__name__} declares {noun} {names}, and only dspy.RLM can call "
-        "them once deployed. The platform answers an MCP tool call underneath the sandbox, "
-        "at the point where RLM's interpreter waits for a tool result, and no other module "
-        "reaches that point — its tool call runs inside the sandbox, where the call would "
-        f"reach a stub and raise. Either wrap this program's work in dspy.RLM, or give "
-        f"{type(module).__name__} ordinary Python tools, which deploy as source and run in "
-        "the sandbox."
-    )
-
-
 def _server_identity(url: str) -> str:
     """A tool server's URL in the one form two spellings of it compare equal in.
 
@@ -381,7 +339,7 @@ def _resolve_mcp_tool_references(client: httpx.Client, config, references: list[
             server_url=reference.server_url,
             tool_name=reference.tool_name,
             schema_hash=str(tool.get("schema_hash") or ""),
-            input_schema=tool.get("input_schema") or {},
+            input_schema=mcp_servers.registry_schema(tool),
             description=str(tool.get("description") or ""),
         )
     return pinned
@@ -424,10 +382,8 @@ def deploy(module, metric=None, timeout=300, metadata=None):
     # Resolve the program's MCP tool references against the org's registry, before
     # anything is packaged and before a deployment row exists. A program with no MCP
     # tools asks the registry nothing.
+    # Validate declarations before contacting the registry or creating a deployment.
     references = _mcp_tool_references(module)
-    # Before the round trip, because it needs nothing from the registry: a module that
-    # cannot call these tools at all is refused whatever the registry says about them.
-    _refuse_mcp_tools_outside_rlm(module, references)
     pinned_mcp_tools: dict[tuple[str, str], Any] = {}
     if references:
         with httpx.Client(timeout=httpx.Timeout(_TIMEOUT_SECONDS, connect=_CONNECT_TIMEOUT_SECONDS)) as client:

{cmpnd-0.27.2 → cmpnd-0.27.3}/cmpnd/mcp_servers.py

@@ -696,7 +696,7 @@ def _registered_tools(url: str, timeout_s: float) -> list[PinnedTool] | None | o
             server_url=url,
             tool_name=str(tool.get("name", "")),
             schema_hash=str(tool.get("schema_hash", "")),
-            input_schema=tool.get("input_schema") or {},
+            input_schema=registry_schema(tool),
             description=str(tool.get("description", "")),
         )
         for tool in (detail.json() or {}).get("tools") or []
@@ -704,6 +704,17 @@ def _registered_tools(url: str, timeout_s: float) -> list[PinnedTool] | None | o
     ]
 
 
+def registry_schema(tool: Mapping[str, Any]) -> Mapping[str, Any]:
+    """Require the registry's pinned schema before constructing a callable declaration."""
+    schema = tool.get("input_schema")
+    if not isinstance(schema, dict):
+        raise ValueError(
+            f"the registry could not supply the pinned schema for tool {tool.get('name')!r}; "
+            "restore the tool registry and refresh the server before deploying"
+        )
+    return schema
+
+
 def _tool_from_pinned(pinned: PinnedTool, reference: McpToolReference) -> dspy.Tool:
     """Build the local declaration DSPy needs without a live MCP session."""
     import dspy

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

@@ -722,29 +722,11 @@ def _resolve_an_mcp_tool(
 
 
 def _generate_mcp_tool_stub(pinned: typing.Any, signature: typing.Any) -> str:
-    """The `def` a resolved MCP tool becomes in the generated program.
-
-    A declaration plus a signature, and a body that is a refusal. The deployed program
-    runs in the kernel, which has no MCP client and must never hold a credential, so the
-    worker intercepts the call before this function's body runs. Reaching the body means
-    no tool token was dispatched for it, and a body that returned something instead would
-    answer the model with a lie.
-
-    The signature is synthesized rather than `*args, **kwargs` because `dspy.RLM` builds
-    each callable stub and each prompt entry from `inspect.signature(tool.func)` — a tool
-    the model cannot see a signature for is a tool it cannot call.
-
-    The docstring's reader is the model, which is why it carries two generated sentences
-    after the server's own description. The first says who answers the call. The second
-    states the shape the result comes back as, because a deployed call returns the
-    protocol's own result object while a LOCAL run through DSPy's conversion flattens it
-    to text — so a model told only what the server says would read the dict as a string.
-    """
+    """Generate a callable declaration with the registered tool's pinned signature."""
     body_lines = [f"def {signature.name}({signature.rendered}) -> dict:"]
     body_lines.extend(_docstring_lines(pinned.description))
-    body_lines.append("    raise RuntimeError(")
-    body_lines.append(f'        "{signature.name} is served by an MCP tool server and cannot run in this process"')
-    body_lines.append("    )")
+    body_lines.append("    raise RuntimeError('this MCP tool requires a worker with registered tool support')")
+    body_lines.append(f"{signature.name} = __import__('cmpnd')._mcp_tool({signature.name})")
     return "\n".join(body_lines)
 
 
@@ -761,7 +743,7 @@ def _docstring_lines(description: str) -> list[str]:
         lines.append(f"    {line}".rstrip())
     lines.append("")
     lines.append("    Served by an MCP tool server registered to this org. The worker answers this call")
-    lines.append("    before the body runs; reaching the body means no tool token was dispatched for it.")
+    lines.append("    through a scoped capability without exposing a credential to the program.")
     lines.append("")
     lines.append('    Returns an MCP tool result: {"content": [{"type": "text", "text": ...}, ...],')
     lines.append('    "isError": bool}. Read the text parts.')
@@ -796,6 +778,43 @@ def module_tools(module: dspy.Module) -> dict[str, typing.Any]:
     return dict(tools) if isinstance(tools, dict) else {}
 
 
+def declared_module_tools(module: dspy.Module) -> dict[str, typing.Any]:
+    """Collect tools throughout a module and refuse ambiguous worker routing names."""
+    import dspy
+
+    from .mcp_servers import is_bare_mcp_tool, mcp_tool_reference
+
+    collected: dict[str, typing.Any] = {}
+    pending: list[typing.Any] = [module]
+    visited: set[int] = set()
+    while pending:
+        member = pending.pop()
+        if id(member) in visited:
+            continue
+        visited.add(id(member))
+        if isinstance(member, dict):
+            pending.extend(member.values())
+            continue
+        if isinstance(member, (list, tuple)):
+            pending.extend(member)
+            continue
+        if not isinstance(member, dspy.Module):
+            continue
+        pending.extend(vars(member).values())
+        for name, tool in module_tools(member).items():
+            if is_bare_mcp_tool(tool):
+                _resolve_an_mcp_tool(name, tool, {})
+            previous = collected.get(name)
+            if previous is not None and previous is not tool:
+                old_ref = mcp_tool_reference(previous)
+                new_ref = mcp_tool_reference(tool)
+                if old_ref is not None or new_ref is not None:
+                    if old_ref != new_ref:
+                        raise ValueError(f"tool name {name!r} refers to different tools in this program")
+            collected[name] = tool
+    return collected
+
+
 def generate_program_source(
     module: dspy.Module,
     mcp_tools: Mapping[tuple[str, str], typing.Any] | None = None,
@@ -942,10 +961,13 @@ def generate_program_source(
     tool_names: list[str] = []
     mcp_declarations: list[dict[str, typing.Any]] = []
     pinned_mcp_tools = mcp_tools or {}
-    tools_dict = module_tools(module)
+    tools_dict = declared_module_tools(module)
     if tools_dict:
+        from dspy import Tool
+
         from . import mcp_servers
 
+        mcp_bindings: list[tuple[Any, str]] = []
         for name, tool in tools_dict.items():
             if name == "finish":
                 continue
@@ -957,6 +979,7 @@ def generate_program_source(
                 # 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,
@@ -972,6 +995,85 @@ def generate_program_source(
                 _extract_callable_tree(func)
                 tool_names.append(name)
 
+        # A composed constructor refers to its Python bindings, which need not share
+        # the registered routing name. Rebuild those bindings from pinned declarations
+        # without carrying the live MCP session or credential into generated source.
+        if is_user_module:
+            bindings: dict[str, str] = {}
+
+            def function_binding(func: Any) -> str:
+                if not inspect.isfunction(func) or not func.__name__.isidentifier():
+                    raise ValueError("Cannot reconstruct this tool callable; deploy the authored source file")
+                _extract_callable_tree(func)
+                if func.__name__ not in emitted_sources:
+                    raise ValueError("Cannot recover tool source; deploy the authored source file")
+                return func.__name__
+
+            def contains_mcp(value: Any, seen: set[int]) -> bool:
+                if id(value) in seen:
+                    return False
+                seen.add(id(value))
+                if mcp_servers.mcp_tool_reference(value) is not None:
+                    return True
+                members = value.values() if isinstance(value, dict) else value
+                return isinstance(value, (list, tuple, dict)) and any(contains_mcp(item, seen) for item in members)
+
+            def binding_source(value: Any, ancestors: frozenset[int]) -> str:
+                if id(value) in ancestors:
+                    raise ValueError("Cannot reconstruct cyclic MCP tool bindings; deploy the authored source file")
+                ancestors = ancestors | {id(value)}
+                reference = mcp_servers.mcp_tool_reference(value)
+                if reference is not None:
+                    for declared, source in mcp_bindings:
+                        if reference == declared:
+                            return source
+                    raise ValueError(
+                        "MCP tool binding is not declared by this program; deploy the authored source file"
+                    )
+                if isinstance(value, list):
+                    return "[" + ", ".join(binding_source(item, ancestors) for item in value) + "]"
+                if isinstance(value, tuple):
+                    return "(" + "".join(binding_source(item, ancestors) + ", " for item in value) + ")"
+                if isinstance(value, dict):
+                    if not all(isinstance(key, str) for key in value):
+                        raise ValueError("MCP tool dictionaries require string keys; deploy the authored source file")
+                    return (
+                        "{"
+                        + ", ".join(f"{key!r}: {binding_source(item, ancestors)}" for key, item in value.items())
+                        + "}"
+                    )
+                if isinstance(value, Tool):
+                    name = function_binding(value.func)
+                    if not _is_literal_constant(value.args):
+                        raise ValueError("Cannot reconstruct tool arguments; deploy the authored source file")
+                    return f"dspy.Tool({name}, name={value.name!r}, desc={value.desc!r}, args={value.args!r})"
+                if callable(value):
+                    return function_binding(value)
+                if _is_literal_constant(value):
+                    return repr(value)
+                raise ValueError("Cannot reconstruct a binding containing MCP tools; deploy the authored source file")
+
+            for method_name in ("__init__", "forward"):
+                method = getattr(cls, method_name, None)
+                if not inspect.isfunction(method):
+                    continue
+                closure = inspect.getclosurevars(method)
+                for name, value in {**closure.globals, **closure.nonlocals}.items():
+                    if not contains_mcp(value, set()):
+                        continue
+                    rendered = binding_source(value, frozenset())
+                    if name in bindings and bindings[name] != rendered:
+                        raise ValueError(
+                            f"MCP tool binding {name!r} has conflicting values; deploy the authored source file"
+                        )
+                    bindings[name] = rendered
+            if bindings:
+                # Evaluate every declaration before rebinding any name: an author's
+                # alias can itself be another registered tool's routing name.
+                names = ", ".join(bindings)
+                values = ", ".join(bindings.values())
+                lines.append(f"({names},) = ({values},)")
+
     # Reconstruct the synthetic ProgramSignature class up-front (when that
     # path applies) so its annotation imports land in sig_imports *before*
     # we emit the import block below. The class text itself is appended
@@ -1009,6 +1111,9 @@ def generate_program_source(
     extra_kwargs = ""
     if tool_names:
         extra_kwargs = f", tools=[{', '.join(tool_names)}]"
+        max_iters = getattr(module, "max_iters", None)
+        if not is_user_module and isinstance(max_iters, int):
+            extra_kwargs += f", max_iters={max_iters!r}"
 
     module_assigned = False
     if sig is not None:

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

@@ -605,3 +605,20 @@ A new hand-rolled serializer on any of those paths reopens the hole. `tests/test
 - [`./optimization-tracking.md`](../../docs/optimization-tracking.md) — how `auto_instrument`'s GEPA patch and `cmpnd/optimizers/tracker.py` turn a `GEPA.compile` call into an `OptimizationRun` with linked evals.
 - The `cmpnd-testing` skill + [`../AGENTS.md`](../AGENTS.md) § "Running Tests & Checks" — patterns for writing callback tests against real databases, including `clear_context()` usage.
 - [`serve/DB.md`](../../serve/DB.md) — the Postgres schema these payloads land in.
+
+### Registered MCP tools in ReAct
+
+`cmpnd.mcp_tools` declares registered tools for ReAct and RLM, including modules
+that contain them. Deployment resolves those declarations against the organization's
+registry and pins their schemas. Bare MCP session closures cannot be packaged.
+Conflicting tools with the same routing name are refused.
+Generated composed programs retain global and closure aliases for registered tools,
+including aliases stored in lists, tuples, or dictionaries. The packager rebuilds
+these bindings from pinned declarations without copying live MCP sessions.
+Generated mixed-tool bindings require ordinary tools to be named Python functions.
+Use authored-source deployment for partials, callable instances, lambdas, or bound methods.
+
+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.

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

{cmpnd-0.27.2 → cmpnd-0.27.3}/tests/e2e/test_traces_read.py

@@ -9,6 +9,8 @@ mismatch a mocked transport cannot. Skipped unless CMPND_E2E_API_KEY is set
 
 from __future__ import annotations
 
+import time
+
 import dspy
 import pytest
 
@@ -26,16 +28,28 @@ class TestTracesReadE2E:
         assert trace_id is not None, "no trace captured"
         program_hash = server_client.get_trace(trace_id)["trace"]["program_signature_hash"]
 
-        # list by the program that produced it finds the trace.
-        page = cmpnd.traces.list(hash=str(program_hash), limit=50, api_key=CMPND_E2E_API_KEY, endpoint=E2E_ENDPOINT)
-        assert trace_id in [t["trace_id"] for t in page["traces"]]
-
-        # show returns the trace and its spans.
+        # Detail reads the ingested source without waiting for collection projection.
         detail = cmpnd.traces.show(trace_id, api_key=CMPND_E2E_API_KEY, endpoint=E2E_ENDPOINT)
         assert detail["trace"]["trace_id"] == trace_id
         assert isinstance(detail["spans"], list)
         assert len(detail["spans"]) >= 1
 
+        # Collection publication is asynchronous. Allow its 30-second idle
+        # cooldown plus processing time, polling the same trace rather than
+        # rerunning the program and restarting the freshness window.
+        deadline = time.monotonic() + 90
+        while True:
+            page = cmpnd.traces.list(hash=str(program_hash), limit=50, api_key=CMPND_E2E_API_KEY, endpoint=E2E_ENDPOINT)
+            listed_ids = [t["trace_id"] for t in page["traces"]]
+            if trace_id in listed_ids:
+                break
+            remaining = deadline - time.monotonic()
+            assert remaining > 0, (
+                f"Trace {trace_id} is readable in detail but absent from its program's collection after 90s; "
+                f"program={program_hash}, last listed trace IDs={listed_ids}"
+            )
+            time.sleep(min(2, remaining))
+
     def test_show_missing_trace_raises(self):
         with pytest.raises(cmpnd.ApiError):
             cmpnd.traces.show("00000000-0000-0000-0000-000000000000", api_key=CMPND_E2E_API_KEY, endpoint=E2E_ENDPOINT)

{cmpnd-0.27.2 → cmpnd-0.27.3}/tests/integration/hosted_mcp_tool_optimize_probe.py

@@ -34,11 +34,10 @@ on it: what this lane is about is whether a tool call a program makes reaches a
 server, and nothing here depends on a model having *chosen* to make it. A lane about
 the choosing needs a real model, which is what ``--real-model`` is for.
 
-# The program must be an RLM
+# ReAct and RLM
 
-The platform refuses MCP tools on anything else, so the tool-calling program a user can
-actually deploy is an RLM — which is why this file's shape (a demo, a REPL turn, a
-``SUBMIT``) differs from its sibling's and is not gratuitous.
+``--tool-module react`` drives the outer kernel import. The default RLM path drives
+its interpreter. Both use the registered tool and scoped authority on every rollout.
 
     CMPND_ENDPOINT=... CMPND_API_KEY=... CMPND_DEV_LM_API_HOST=... \\
       CMPND_TOOL_SERVER_URL=... python hosted_mcp_tool_optimize_probe.py --out result.json
@@ -50,6 +49,7 @@ import argparse
 import json
 import os
 import sys
+import tempfile
 import time
 from pathlib import Path
 from typing import Any
@@ -75,6 +75,19 @@ EXAMPLES: list[dict[str, str]] = [
 # looking entirely healthy.
 TOOL = "catalog_answer"
 
+# The packager replaces this runtime tool with its pinned declaration of the same name.
+catalog_answer: Any = None
+
+
+class Research(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        self.solve = dspy.ReAct("question -> answer", tools=[catalog_answer], max_iters=1)
+
+    def forward(self, question):
+        return self.solve(question=question)
+
+
 # The litellm model both roles use, matching the sibling probe's default so one sealed
 # credential serves both lanes. Its PREFIX is what the platform files the provider
 # credential under.
@@ -118,7 +131,7 @@ class ShortAnswer(dspy.Signature):
     answer: str = dspy.OutputField()
 
 
-def build_program(tool_server: str, credential: str, timeout_s: float) -> dspy.Module:
+def build_program(tool_server: str, credential: str, timeout_s: float, module_kind: str = "rlm") -> dspy.Module:
     """The RLM under optimization, with its tools and the turn that calls one.
 
     ``cmpnd.mcp_tools`` connects to the server FROM HERE, which is what tells the deploy
@@ -168,6 +181,21 @@ def build_program(tool_server: str, credential: str, timeout_s: float) -> dspy.M
     # tools.
     tools = [tool for tool in listed if tool.name == TOOL]
 
+    if module_kind == "react":
+        global catalog_answer
+        catalog_answer = tools[0]
+        program = Research()
+        program.solve.react.demos = [
+            dspy.Example(
+                question=EXAMPLES[0]["question"],
+                trajectory="",
+                next_thought="Look up the catalogue entry",
+                next_tool_name=TOOL,
+                next_tool_args={"question": EXAMPLES[0]["question"], "style": "sentence"},
+            )
+        ]
+        return program
+
     # Two turns, not one: the first runs the demo's code and submits. The second exists
     # only so a turn that failed has somewhere to be retried from, which is what turns a
     # transient refusal into a slower rollout rather than a failed one.
@@ -221,6 +249,8 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     p = argparse.ArgumentParser(
         description="Optimize a tool-calling program through serve, the optimizer and the executor."
     )
+    p.add_argument("--tool-source", choices=("generated", "authored"), default="generated")
+    p.add_argument("--tool-module", choices=("rlm", "react"), default="rlm")
     p.add_argument("--out", required=True, help="write the ids this run produced here, as JSON")
     p.add_argument(
         "--metric-calls",
@@ -265,11 +295,39 @@ def main(argv: list[str] | None = None) -> int:
 
     cmpnd.configure(api_key=api_key, endpoint=endpoint, project_tags=["hosted-mcp-tool-optimize-probe"])
 
-    program = build_program(args.tool_server, credential, args.tool_server_timeout)
+    program = build_program(args.tool_server, credential, args.tool_server_timeout, args.tool_module)
     started_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
 
-    print(f"deploying an RLM calling {TOOL} on {args.tool_server} to {endpoint}", flush=True)
-    deployed = cmpnd.deploy(program, metric=feedback_metric, timeout=600)
+    print(f"deploying {args.tool_module} calling {TOOL} on {args.tool_server} to {endpoint}", flush=True)
+    if args.tool_source == "authored":
+        if args.tool_module != "react":
+            raise ValueError("the authored tool probe uses ReAct")
+        from cmpnd import authored, deployment
+
+        demo = dict(getattr(program, "solve").react.demos[0])
+        source = "\n".join(
+            [
+                "import dspy",
+                "import cmpnd",
+                f"dspy.configure(lm=dspy.LM({MODEL!r}, api_base={os.environ['CMPND_DEV_LM_API_HOST']!r}, cache=False))",
+                f"tools = [tool for tool in cmpnd.mcp_tools({args.tool_server!r}) if tool.name == {TOOL!r}]",
+                "class Research(dspy.Module):",
+                "    def __init__(self):",
+                "        super().__init__()",
+                "        self.solve = dspy.ReAct('question -> answer', tools=tools, max_iters=1)",
+                "    def forward(self, question):",
+                "        return self.solve(question=question)",
+                "program = Research()",
+                f"program.solve.react.demos = [dspy.Example(**{demo!r})]",
+            ]
+        )
+        with tempfile.TemporaryDirectory(prefix="cmpnd-react-source-") as directory:
+            path = Path(directory) / "research.py"
+            path.write_text(source)
+            prepared = authored.prepare_file(path, api_key=api_key, endpoint=endpoint)
+            deployed = deployment.deploy_bundle(prepared.bundle, prepared.facts, timeout=600)
+    else:
+        deployed = cmpnd.deploy(program, metric=feedback_metric, timeout=600)
     print(f"deployed {deployed}", flush=True)
 
     examples = [dspy.Example(**row).with_inputs("question") for row in EXAMPLES]