rote-cli 0.12.1__tar.gz → 0.14.0__tar.gz

{rote_cli-0.12.1 → rote_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: rote-cli
-Version: 0.12.1
+Version: 0.14.0
 Summary: Compile AI agent skills into cheap, fast, deterministic pipelines that run without an LLM in the loop
 Project-URL: Homepage, https://roteskills.com
 Project-URL: Repository, https://github.com/trevhud/rote
@@ -29,11 +29,11 @@ Requires-Dist: pyyaml>=6.0
 Provides-Extra: api
 Requires-Dist: anthropic>=0.89; extra == 'api'
 Provides-Extra: dbos
-Requires-Dist: dbos>=2.26; extra == 'dbos'
+Requires-Dist: dbos<3,>=2.26; extra == 'dbos'
 Provides-Extra: dev
 Requires-Dist: anthropic>=0.89; extra == 'dev'
-Requires-Dist: dbos>=2.26; extra == 'dev'
-Requires-Dist: fastmcp>=3.4.2; extra == 'dev'
+Requires-Dist: dbos<3,>=2.26; extra == 'dev'
+Requires-Dist: fastmcp<4,>=3.4.2; extra == 'dev'
 Requires-Dist: httpx>=0.28; extra == 'dev'
 Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: openai>=2.45; extra == 'dev'
@@ -43,12 +43,12 @@ Requires-Dist: ruff>=0.6; extra == 'dev'
 Requires-Dist: temporalio>=1.7; extra == 'dev'
 Requires-Dist: types-pyyaml; extra == 'dev'
 Provides-Extra: mcp
-Requires-Dist: fastmcp>=3.4.2; extra == 'mcp'
+Requires-Dist: fastmcp<4,>=3.4.2; extra == 'mcp'
 Requires-Dist: httpx>=0.28; extra == 'mcp'
 Provides-Extra: openai-api
 Requires-Dist: openai>=2.45; extra == 'openai-api'
 Provides-Extra: serve
-Requires-Dist: fastmcp>=3.4.2; extra == 'serve'
+Requires-Dist: fastmcp<4,>=3.4.2; extra == 'serve'
 Requires-Dist: httpx>=0.28; extra == 'serve'
 Provides-Extra: temporal
 Requires-Dist: temporalio>=1.7; extra == 'temporal'
@@ -257,6 +257,24 @@ override with `--agent`. The output directory splits into `compiled/`
 (the agent's `pipeline.yaml`, `extracted/`, `signatures/`, eval seeds,
 and a `compile-report.md`) and `runtime/<runtime>/` (the adapter's
 emitted code + a README on how to run, signal gates, and deploy).
+`compiled/compile-metrics.json` preserves final token counts, session ID,
+and the driver's cost estimate before emission starts, so an adapter
+failure does not lose the paid run's metrics. Missing final output stays
+null with `usage_complete: false`; unchanged updates retain prior metrics.
+
+Local `api` and `openai-api` compilation automatically discovers your
+registered, authenticated MCP servers and exposes their read-only tools.
+Pass `--no-mcp` to skip that discovery and compile without live MCP calls:
+
+```sh
+rote compile examples/bdr-outreach/skill --local --agent api --no-mcp --out /tmp/bdr-compiled
+```
+
+This leaves the emitted pipeline's MCP bindings intact. The flag also works
+with `rote analyze` and with an API driver selected through config or
+auto-detection. It rejects cloud compilation, subprocess drivers, and
+`--baseline`, whose raw skill run uses its own MCP tools. API drivers bill
+through your API credentials.
 
 ### Other commands
 
@@ -434,9 +452,8 @@ plain-Python subprocess); those need a Node toolchain / Docker, so they
 run locally with `pytest tests/ -m slow`, not in CI.
 
 Known gaps: the extracted modules are `NotImplementedError` stubs
-you fill in with real API-client code, a Restate adapter is planned, and
-`fan_out` nodes currently receive the whole upstream list in one
-invocation (per-element dispatch is a planned enhancement). Published on
+you fill in with real API-client code, and a Restate adapter is planned.
+Published on
 PyPI as [`rote-cli`](https://pypi.org/project/rote-cli/) via tag-driven
 Trusted Publishing ([docs/releasing.md](docs/releasing.md)).
 
@@ -502,6 +519,9 @@ rote/
   archetype: a bounded browser-automation loop stays one agent node
   while the date math, filtering, and reporting around it compile to
   code, plus the measured runs that forced the loop-aware cost model
+- [`examples/rote-compile/`](examples/rote-compile/): the compiler compiling
+  its own core skill, with preserved artifacts and an offline audit of
+  the generated workflow's runtime and data-flow failures
 
 ---
 
@@ -509,19 +529,19 @@ rote/
 
 In rough priority order:
 
-1. **Re-compile BDR end-to-end with `signature_spec`**: the bundled IR
-   was hand-extended with structured schemas; the rubric now teaches the
-   field, but no real run has produced one yet.
-2. **Pre-filter as a `pure_function` node**: today hard thresholds are
-   lifted into a judge's `forward()`, which works for Temporal but not
-   Cloudflare; a separate node makes the short-circuit uniform.
-3. **More example skills**: BDR is one shape; research-heavy,
-   retrieval-heavy, and code-review skills stress the IR differently.
-4. **`fan_out` per-element dispatch**: currently the whole upstream list
-   arrives in one invocation.
-5. **The compiler compiling itself**: `rote-compile` is a SKILL.md;
-   pointing `rote compile` at it should crystallize its rubric-grade
-   pieces and leave only the genuinely fuzzy judgments in the loop.
+1. **Pre-filter as a `pure_function` node**: today hard thresholds are
+   lifted into a judge's `forward()`, which works for the Python
+   runtimes but not the TypeScript ones; a separate node makes the
+   short-circuit uniform across all six.
+2. **Make self-compilation executable**: the
+   [preserved core-skill run](examples/rote-compile/) produced valid IR,
+   and runtime emission now succeeds. Its offline audit still has
+   data-flow and agent-result contract failures. Close those gaps before
+   treating it as a working replacement compiler.
+3. **More example skills**: four archetypes are covered today (BDR
+   outreach, 100%-roteness, data-heavy, agent-loop). Research-heavy,
+   retrieval-heavy, and code-review skills each stress the IR in ways
+   none of those four do.
 
 ---
 

{rote_cli-0.12.1 → rote_cli-0.14.0}/README.md

@@ -201,6 +201,24 @@ override with `--agent`. The output directory splits into `compiled/`
 (the agent's `pipeline.yaml`, `extracted/`, `signatures/`, eval seeds,
 and a `compile-report.md`) and `runtime/<runtime>/` (the adapter's
 emitted code + a README on how to run, signal gates, and deploy).
+`compiled/compile-metrics.json` preserves final token counts, session ID,
+and the driver's cost estimate before emission starts, so an adapter
+failure does not lose the paid run's metrics. Missing final output stays
+null with `usage_complete: false`; unchanged updates retain prior metrics.
+
+Local `api` and `openai-api` compilation automatically discovers your
+registered, authenticated MCP servers and exposes their read-only tools.
+Pass `--no-mcp` to skip that discovery and compile without live MCP calls:
+
+```sh
+rote compile examples/bdr-outreach/skill --local --agent api --no-mcp --out /tmp/bdr-compiled
+```
+
+This leaves the emitted pipeline's MCP bindings intact. The flag also works
+with `rote analyze` and with an API driver selected through config or
+auto-detection. It rejects cloud compilation, subprocess drivers, and
+`--baseline`, whose raw skill run uses its own MCP tools. API drivers bill
+through your API credentials.
 
 ### Other commands
 
@@ -378,9 +396,8 @@ plain-Python subprocess); those need a Node toolchain / Docker, so they
 run locally with `pytest tests/ -m slow`, not in CI.
 
 Known gaps: the extracted modules are `NotImplementedError` stubs
-you fill in with real API-client code, a Restate adapter is planned, and
-`fan_out` nodes currently receive the whole upstream list in one
-invocation (per-element dispatch is a planned enhancement). Published on
+you fill in with real API-client code, and a Restate adapter is planned.
+Published on
 PyPI as [`rote-cli`](https://pypi.org/project/rote-cli/) via tag-driven
 Trusted Publishing ([docs/releasing.md](docs/releasing.md)).
 
@@ -446,6 +463,9 @@ rote/
   archetype: a bounded browser-automation loop stays one agent node
   while the date math, filtering, and reporting around it compile to
   code, plus the measured runs that forced the loop-aware cost model
+- [`examples/rote-compile/`](examples/rote-compile/): the compiler compiling
+  its own core skill, with preserved artifacts and an offline audit of
+  the generated workflow's runtime and data-flow failures
 
 ---
 
@@ -453,19 +473,19 @@ rote/
 
 In rough priority order:
 
-1. **Re-compile BDR end-to-end with `signature_spec`**: the bundled IR
-   was hand-extended with structured schemas; the rubric now teaches the
-   field, but no real run has produced one yet.
-2. **Pre-filter as a `pure_function` node**: today hard thresholds are
-   lifted into a judge's `forward()`, which works for Temporal but not
-   Cloudflare; a separate node makes the short-circuit uniform.
-3. **More example skills**: BDR is one shape; research-heavy,
-   retrieval-heavy, and code-review skills stress the IR differently.
-4. **`fan_out` per-element dispatch**: currently the whole upstream list
-   arrives in one invocation.
-5. **The compiler compiling itself**: `rote-compile` is a SKILL.md;
-   pointing `rote compile` at it should crystallize its rubric-grade
-   pieces and leave only the genuinely fuzzy judgments in the loop.
+1. **Pre-filter as a `pure_function` node**: today hard thresholds are
+   lifted into a judge's `forward()`, which works for the Python
+   runtimes but not the TypeScript ones; a separate node makes the
+   short-circuit uniform across all six.
+2. **Make self-compilation executable**: the
+   [preserved core-skill run](examples/rote-compile/) produced valid IR,
+   and runtime emission now succeeds. Its offline audit still has
+   data-flow and agent-result contract failures. Close those gaps before
+   treating it as a working replacement compiler.
+3. **More example skills**: four archetypes are covered today (BDR
+   outreach, 100%-roteness, data-heavy, agent-loop). Research-heavy,
+   retrieval-heavy, and code-review skills each stress the IR in ways
+   none of those four do.
 
 ---
 

{rote_cli-0.12.1 → rote_cli-0.14.0}/pyproject.toml

@@ -69,14 +69,14 @@ openai-api = [
     "openai>=2.45",
 ]
 dbos = [
-    "dbos>=2.26",
+    "dbos>=2.26,<3",
 ]
 serve = [
-    "fastmcp>=3.4.2",
+    "fastmcp>=3.4.2,<4",
     "httpx>=0.28",
 ]
 mcp = [
-    "fastmcp>=3.4.2",
+    "fastmcp>=3.4.2,<4",
     "httpx>=0.28",
 ]
 dev = [
@@ -88,8 +88,8 @@ dev = [
     "temporalio>=1.7",
     "anthropic>=0.89",
     "openai>=2.45",
-    "dbos>=2.26",
-    "fastmcp>=3.4.2",
+    "dbos>=2.26,<3",
+    "fastmcp>=3.4.2,<4",
     "httpx>=0.28",
 ]
 
@@ -138,7 +138,11 @@ extend-exclude = ["examples"]
 select = ["E", "F", "I", "UP", "B", "SIM"]
 
 [tool.pytest.ini_options]
-addopts = "-m 'not slow'"
+# -rs: always print the REASON for every skip. A conditional skip whose
+# condition silently becomes permanent is invisible behind a bare
+# "1 skipped" count — that is how `test_per_tool_override_changes_payload`
+# went from a real test to dead weight without anyone noticing.
+addopts = "-m 'not slow' -rs"
 markers = [
     "slow: tests that need an external toolchain (Node/npm/tsc) or take >5s. Run with `pytest -m slow` to include.",
 ]

{rote_cli-0.12.1 → rote_cli-0.14.0}/src/rote/__init__.py

@@ -1,3 +1,3 @@
 """rote — compile fuzzy AI skills into deterministic workflows."""
 
-__version__ = "0.12.1"
+__version__ = "0.14.0"

{rote_cli-0.12.1 → rote_cli-0.14.0}/src/rote/adapters/__init__.py

@@ -56,9 +56,17 @@ def _cloudflare_adapter_factory(**options: Any) -> Adapter:
     from rote.adapters.cloudflare import CloudflareAdapter, CloudflareAdapterConfig
 
     backend = _validated_backend(options)
-    if backend is None:
+    mcp_client = options.get("mcp_client")
+    if mcp_client not in (None, "direct", "binding"):
+        raise ValueError(f"mcp_client must be 'direct' or 'binding', got {mcp_client!r}")
+    if backend is None and mcp_client is None:
         return CloudflareAdapter()
-    return CloudflareAdapter(CloudflareAdapterConfig(external_backend=backend))
+    return CloudflareAdapter(
+        CloudflareAdapterConfig(
+            external_backend=backend or "mcp",
+            mcp_client=mcp_client or "direct",
+        )
+    )
 
 
 def _source_dir(options: dict[str, Any]) -> Path | None:

{rote_cli-0.12.1 → rote_cli-0.14.0}/src/rote/adapters/_common.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import hashlib
 import json
 import re
+from collections.abc import Sequence
 from pathlib import Path
 
 from rote.ir import Node, NodeKind, Pipeline, parse_input_ref
@@ -305,12 +306,20 @@ def ir_duration_to_human(s: str) -> str:
     Cloudflare's step config accepts directly. Strings that don't match
     the IR shorthand pattern are passed through unchanged (they're
     assumed to already be in an acceptable form).
+
+    A value of exactly 1 is singularized ('1 hour', not '1 hours').
+    Cloudflare's ``WorkflowDuration`` accepts either spelling, so this
+    is legibility rather than correctness — but emitted code is read by
+    humans, and '1 hours' in a reviewed artifact looks like a bug.
     """
     s = s.strip()
     m = _IR_DURATION_RE.fullmatch(s)
     if not m:
         return s
-    return f"{m.group(1)} {_UNIT_TO_HUMAN[m.group(2)]}"
+    value, unit = m.group(1), _UNIT_TO_HUMAN[m.group(2)]
+    if float(value) == 1:
+        unit = unit.removesuffix("s")
+    return f"{value} {unit}"
 
 
 _UNIT_TO_SECONDS = {
@@ -422,6 +431,72 @@ def check_input_refs_available(node: Node, available: set[str]) -> None:
             )
 
 
+def fan_out_element_param(node: Node, pipeline: Pipeline) -> str:
+    """Which ``inputs`` param carries the list a ``fan_out`` node fans over.
+
+    Every other input is shared verbatim by all invocations. Which param
+    is the list, in precedence order:
+
+    1. the param bound to the source of an incoming ``fan_out: true``
+       edge (the IR's explicit marker);
+    2. else the param bound to a node with any incoming edge — inputs
+       may also reference nodes *without* an edge (shared context, e.g.
+       BDR's ``intel``), which is what makes "the only node-bound
+       param" too naive;
+    3. else the only node-bound param.
+
+    Ambiguity after all three is an emit-time error, never a guess:
+    dispatching over the wrong list would silently judge the wrong
+    things.
+
+    This lives in the language-neutral common module because the answer
+    is a property of the IR, not of the target language — every adapter
+    must fan over the *same* input or the same pipeline would mean
+    different things on different runtimes.
+    """
+    if not node.inputs:
+        raise ValueError(f"fan_out node {node.id!r} has no inputs: nothing to fan over")
+    node_bound = {
+        param: parsed.node_id
+        for param, ref in node.inputs.items()
+        if (parsed := parse_input_ref(ref)).node_id is not None
+    }
+    edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id}
+    fan_edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id and e.fan_out}
+
+    # The tiers are tried narrowest-first, but the ORDER is provably
+    # unobservable: fan_edge_sources ⊆ edge_sources by construction, so
+    # matching(fan) ⊆ matching(edge), and a tier is accepted only when it
+    # singles out exactly one param. If the broader tier singles one out,
+    # it is necessarily the same one. (Mutation testing flags swapping
+    # these as a surviving mutant — it is equivalent, not a test gap.)
+    # The tiers still earn their place: they express which signal the
+    # author gave, and tier 2 is what handles a marker pointing at a node
+    # no input references.
+    for sources in (fan_edge_sources, edge_sources):
+        matching = sorted(p for p, src in node_bound.items() if src in sources)
+        if len(matching) == 1:
+            return matching[0]
+    if len(node_bound) != 1:
+        raise ValueError(
+            f"fan_out node {node.id!r}: cannot identify the element param — "
+            f"node-bound inputs {sorted(node_bound)} and incoming edges "
+            f"{sorted(edge_sources)} don't single one out; mark the list edge "
+            f"with `fan_out: true`"
+        )
+    return next(iter(node_bound))
+
+
+def fan_out_nodes(wave: Sequence[Node]) -> tuple[list[Node], list[Node]]:
+    """Split a wave into ``(fan_out_nodes, plain_nodes)``, order preserved.
+
+    A ``fan_out`` node dispatches once per element of its bound list, so
+    it never shares the single/parallel payload shapes an adapter emits
+    for plain nodes.
+    """
+    return [n for n in wave if n.fan_out], [n for n in wave if not n.fan_out]
+
+
 # ───────── MCP-capability refusal ─────────
 
 

{rote_cli-0.12.1 → rote_cli-0.14.0}/src/rote/adapters/_py_common.py

@@ -30,6 +30,7 @@ from rote.adapters._common import (
     DEFAULT_AGENT_MAX_ITERATIONS,
     EmitWriter,
     _to_pascal_case,
+    fan_out_element_param,
     safe_docstring_line,
 )
 from rote.ir import LLMSignature, Node, NodeKind, Pipeline, parse_input_ref
@@ -93,52 +94,65 @@ def _payload_literal(node: Node, indent: str) -> str:
     return "\n".join(lines)
 
 
-def fan_out_binding(node: Node, pipeline: Pipeline) -> tuple[str, str, dict[str, str]]:
-    """``(element_param, list_expr, scalar_exprs)`` for a ``fan_out`` node.
+_FAN_OUT_LIST_HELPER_PY = '''\
+def _fan_out_list(value: object, node_id: str, ref: str) -> list:
+    """The list a fan_out node dispatches over.
 
-    The element parameter is the one bound to the upstream *list* the
-    node fans over (ir-schema.md); every other input is shared verbatim
-    by all invocations. Which param that is, in precedence order:
-
-    1. the param bound to the source of an incoming ``fan_out: true``
-       edge (the IR's explicit marker);
-    2. else the param bound to a node with any incoming edge — inputs
-       may also reference nodes *without* an edge (shared context, e.g.
-       BDR's ``intel``), which is what makes "the only node-bound
-       param" too naive;
-    3. else the only node-bound param.
-
-    Ambiguity after all three is an emit-time error, never a guess:
-    dispatching over the wrong list would silently judge the wrong
-    things.
+    Iterating a missing key raises "'NoneType' object is not iterable",
+    which names neither the node nor the reference — in generated code
+    that is close to undebuggable, and the cause is almost always an
+    upstream node that didn't return the key the IR says it does. The
+    TypeScript runtimes emit the same guard (`fanOutList`), so a missing
+    key reports identically on every target.
     """
-    if not node.inputs:
-        raise ValueError(f"fan_out node {node.id!r} has no inputs: nothing to fan over")
-    node_bound = {
-        param: parsed.node_id
-        for param, ref in node.inputs.items()
-        if (parsed := parse_input_ref(ref)).node_id is not None
-    }
-    edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id}
-    fan_edge_sources = {e.from_ for e in pipeline.edges if e.to == node.id and e.fan_out}
-
-    for sources in (fan_edge_sources, edge_sources):
-        matching = sorted(p for p, src in node_bound.items() if src in sources)
-        if len(matching) == 1:
-            element_param = matching[0]
-            break
-    else:
-        if len(node_bound) != 1:
-            raise ValueError(
-                f"fan_out node {node.id!r}: cannot identify the element param — "
-                f"node-bound inputs {sorted(node_bound)} and incoming edges "
-                f"{sorted(edge_sources)} don't single one out; mark the list edge "
-                f"with `fan_out: true`"
-            )
-        element_param = next(iter(node_bound))
+    if not isinstance(value, list):
+        raise TypeError(
+            f"fan_out node {node_id!r} expected a list from {ref!r}, got "
+            f"{type(value).__name__}. The upstream node must return that "
+            f"key as a list."
+        )
+    return value
+'''
+
+
+def fan_out_list_helper() -> str:
+    """The ``_fan_out_list`` guard emitted into Python runtimes that fan out.
+
+    Behavioral emitted code, like ``_serialize``: if the runtimes' guards
+    drift, the same broken pipeline reports differently per target.
+    """
+    return _FAN_OUT_LIST_HELPER_PY
+
+
+def fan_out_binding(
+    node: Node, pipeline: Pipeline, indent: str = ""
+) -> tuple[str, str, dict[str, str]]:
+    """``(element_param, list_expr, scalar_exprs)`` for a ``fan_out`` node.
+
+    The Python rendering of :func:`fan_out_element_param` — which input
+    is the list is a language-neutral property of the IR, so it is
+    resolved there and only the expressions are built here.
 
+    ``indent`` is the column the ``_fan_out_list(`` token sits at; the
+    guard call wraps against it rather than running long on one line.
+    """
+    element_param = fan_out_element_param(node, pipeline)
+    # Narrowing only: fan_out_element_param raises on a node with no
+    # inputs, so reaching here means there is something to fan over.
+    assert node.inputs is not None
     scalars = {p: _ref_to_python_expr(r) for p, r in node.inputs.items() if p != element_param}
-    return element_param, _ref_to_python_expr(node.inputs[element_param]), scalars
+    ref = node.inputs[element_param]
+    inner = indent + "    "
+    # json.dumps, not !r: emitted Python uses double quotes throughout
+    # (the repo's ruff-format style), same as _py_literal.
+    list_expr = (
+        "_fan_out_list(\n"
+        f"{inner}{_ref_to_python_expr(ref)},\n"
+        f"{inner}{json.dumps(node.id)},\n"
+        f"{inner}{json.dumps(ref)},\n"
+        f"{indent})"
+    )
+    return element_param, list_expr, scalars
 
 
 # ───────── JSON Schema → Pydantic source ─────────
@@ -218,38 +232,47 @@ class _SchemaToPydantic:
 
     The Python analog of the Cloudflare adapter's ``json_schema_to_zod``.
     Named ``$defs`` become named classes / ``Literal`` aliases; inline
-    object schemas get synthesized names. Blocks are accumulated in
-    dependency order (a class is emitted only after everything it
-    references), so the generated module imports cleanly top-to-bottom.
+    object schemas get synthesized names. Each root schema resolves its
+    own definitions; generated names and dependency-ordered blocks are
+    shared across the module.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, *, reserved_names: tuple[str, ...] = ()) -> None:
         self._defs: dict[str, dict[str, Any]] = {}
         self._blocks: list[str] = []
         self._emitted: dict[str, str] = {}  # $def name -> python name
         self._in_progress: set[str] = set()
-        self._used_names: set[str] = set()
+        self._used_names: set[str] = {
+            *keyword.kwlist,
+            *reserved_names,
+            "Any",
+            "Literal",
+            "BaseModel",
+            "ConfigDict",
+            "Field",
+            "PROMPT",
+            "MODEL",
+            "TEMPERATURE",
+        }
         self.uses_literal = False
         self.uses_config_dict = False
         self.uses_field = False
 
     # ── public API ──
 
-    def add_defs(self, defs: dict[str, Any]) -> None:
-        for name, schema in defs.items():
-            if name in self._defs and self._defs[name] != schema:
-                raise ValueError(
-                    f"signature emission: $defs entry {name!r} appears in both input "
-                    f"and output schemas with different definitions"
-                )
-            self._defs[name] = schema
-
     def emit_root(self, class_name: str, schema: dict[str, Any]) -> None:
         if schema.get("type") != "object":
             raise ValueError(
                 f"signature emission: root signature schema for {class_name} must be "
                 f"an object schema, got type={schema.get('type')!r}"
             )
+        # A #/$defs reference belongs to its root document. Sharing this
+        # cache across input/output can bind even identical wrappers to the
+        # wrong nested definition. Only Python symbol allocation is global.
+        self._defs = schema.get("$defs", {})
+        self._emitted.clear()
+        self._in_progress.clear()
+        self._used_names.add(class_name)
         self._emit_object_class(class_name, schema)
 
     @property
@@ -484,9 +507,7 @@ def emit_signature_module(
     spec = node.signature_spec
     pascal = _to_pascal_case(node.id)
 
-    converter = _SchemaToPydantic()
-    converter.add_defs(spec.input_schema.get("$defs", {}))
-    converter.add_defs(spec.output_schema.get("$defs", {}))
+    converter = _SchemaToPydantic(reserved_names=(pascal, f"{pascal}Input", f"{pascal}Output"))
     converter.emit_root(f"{pascal}Input", spec.input_schema)
     converter.emit_root(f"{pascal}Output", spec.output_schema)