timbal 2.4.2__tar.gz → 2.6.0__tar.gz

{timbal-2.4.2 → timbal-2.6.0}/.gitignore

@@ -54,6 +54,10 @@ node_modules/
 # Internal planning docs
 planning/
 
+# Local rust WIP — do not ship in the Python package
+/rust/
+/benchmarks/rust/
+
 .claude/
 .cursor/
 

{timbal-2.4.2 → timbal-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: timbal
-Version: 2.4.2
+Version: 2.6.0
 Summary: Simple, performant, battle-tested framework for building reliable AI applications
 Project-URL: Source, https://github.com/timbal-ai/timbal
 Author-email: Timbal <team@timbal.ai>
@@ -238,6 +238,7 @@ Requires-Dist: huggingface-hub>=0.28.0; extra == 'all'
 Requires-Dist: libcst>=1.8.6; extra == 'all'
 Requires-Dist: onnxruntime>=1.20.0; extra == 'all'
 Requires-Dist: openpyxl>=3.1.5; extra == 'all'
+Requires-Dist: ormsgpack>=1.5.0; extra == 'all'
 Requires-Dist: pymupdf>=1.27.1; extra == 'all'
 Requires-Dist: python-docx>=1.1.2; extra == 'all'
 Requires-Dist: rich>=14.2.0; extra == 'all'
@@ -256,6 +257,7 @@ Provides-Extra: evals
 Requires-Dist: rich>=14.2.0; extra == 'evals'
 Provides-Extra: server
 Requires-Dist: fastapi>=0.115.8; extra == 'server'
+Requires-Dist: ormsgpack>=1.5.0; extra == 'server'
 Requires-Dist: uvicorn>=0.34.0; extra == 'server'
 Requires-Dist: websockets>=15.0.1; extra == 'server'
 Provides-Extra: voice
@@ -263,6 +265,8 @@ Requires-Dist: aiortc>=1.9.0; extra == 'voice'
 Requires-Dist: huggingface-hub>=0.28.0; extra == 'voice'
 Requires-Dist: onnxruntime>=1.20.0; extra == 'voice'
 Requires-Dist: transformers>=4.40.0; extra == 'voice'
+Provides-Extra: voice-livekit
+Requires-Dist: livekit>=1.1.14; extra == 'voice-livekit'
 Description-Content-Type: text/markdown
 
 # Timbal

{timbal-2.4.2 → timbal-2.6.0}/pyproject.toml

@@ -57,6 +57,7 @@ evals = [
 ]
 server = [
   "fastapi>=0.115.8",
+  "ormsgpack>=1.5.0",
   "uvicorn>=0.34.0",
   "websockets>=15.0.1",
 ]
@@ -66,6 +67,9 @@ voice = [
   "onnxruntime>=1.20.0",
   "transformers>=4.40.0",
 ]
+"voice-livekit" = [
+  "livekit>=1.1.14",
+]
 all = [
   "timbal[codegen]",
   "timbal[documents]",
@@ -108,6 +112,7 @@ exclude = [
   "/sandbox",
   "/scripts",
   "/benchmarks",
+  "/rust",
 ]
 
 [tool.uv]

{timbal-2.4.2 → timbal-2.6.0}/python/timbal/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.4.2'
-__version_tuple__ = version_tuple = (2, 4, 2)
+__version__ = version = '2.6.0'
+__version_tuple__ = version_tuple = (2, 6, 0)
 
 __commit_id__ = commit_id = None

{timbal-2.4.2 → timbal-2.6.0}/python/timbal/codegen/__main__.py

@@ -10,10 +10,12 @@ from pathlib import Path
 # A test asserts this table stays in sync with the modules on disk.
 _TRANSFORMER_OPS: dict[str, tuple[str, str]] = {
     "add-edge": ("add_edge", "Add an ordering or conditional edge between two workflow steps."),
+    "add-guardrail": ("add_guardrail", "Add a guardrail shorthand to the agent's guardrails list."),
     "add-mcp": ("add_mcp", "Add an MCP server to the agent's tools list."),
     "add-step": ("add_step", "Add a step to the workflow."),
     "add-tool": ("add_tool", "Add a tool to the agent's tools list."),
     "remove-edge": ("remove_edge", "Remove an edge between two workflow steps."),
+    "remove-guardrail": ("remove_guardrail", "Remove a guardrail from the agent's guardrails list by name."),
     "remove-step": ("remove_step", "Remove a step from the workflow by name."),
     "remove-tool": ("remove_tool", "Remove a tool from the agent's tools list by name."),
     "set-config": ("set_config", "Set configuration on the agent/step or on a specific tool."),

{timbal-2.4.2 → timbal-2.6.0}/python/timbal/codegen/flow.py

@@ -39,6 +39,20 @@ def _get_when_source(step: Any) -> str | None:
     return _get_callable_source(step.when["callable"])
 
 
+def _get_while_info(step: Any) -> dict[str, Any] | None:
+    """Describe a step's while_ loop config for JSON output.
+
+    Returns ``{"count": N}`` for count loops, ``{"expr": "<source>"}`` for
+    callable conditions, or None when the step doesn't loop.
+    """
+    while_ = getattr(step, "while_", None)
+    if not while_:
+        return None
+    if "count" in while_:
+        return {"count": while_["count"]}
+    return {"expr": _get_callable_source(while_["callable"]) or "<callable>"}
+
+
 def _extract_key_from_lambda(fn: Any, source_step: str) -> str | None:
     """Extract the dot-notation key path from a runtime lambda's source.
 
@@ -208,9 +222,9 @@ def _edge_kind(kinds: set[str] | None) -> str:
 
     A dependency can arise from several sources at once (e.g. an explicit
     ``depends_on`` that also reads the step's output via a param map). Precedence
-    is ``ordering > when > param`` so explicit sequencing is never masked by
-    param wiring. Unknown/missing (e.g. edges from a direct ``_link``) default to
-    ``ordering`` — the safe choice, since ordering edges are never reduced away.
+    is ``ordering > when > while > param`` so explicit sequencing is never masked
+    by param wiring. Unknown/missing (e.g. edges from a direct ``_link``) default
+    to ``ordering`` — the safe choice, since ordering edges are never reduced away.
     """
     if not kinds:
         return "ordering"
@@ -218,6 +232,8 @@ def _edge_kind(kinds: set[str] | None) -> str:
         return "ordering"
     if "when" in kinds:
         return "when"
+    if "while" in kinds:
+        return "while"
     return "param"
 
 
@@ -253,7 +269,11 @@ def get_flow(workspace_path: str | Path) -> dict[str, Any]:
 
     if isinstance(runnable, Workflow):
         for step in runnable._steps.values():
-            nodes.append(_build_node(step, include_tools=isinstance(step, Agent)))
+            node = _build_node(step, include_tools=isinstance(step, Agent))
+            while_info = _get_while_info(step)
+            if while_info is not None:
+                node["data"]["while"] = while_info
+            nodes.append(node)
 
         for _step_name, step in runnable._steps.items():
             when_source = _get_when_source(step) if step.when else None
@@ -407,6 +427,13 @@ def _fmt_node_lines(node: dict, indent: str) -> list[str]:
     elif ntype == "workflow":
         lines.append(f"{indent}workflow  {name}")
 
+    while_info = node["data"].get("while")
+    if while_info:
+        if "count" in while_info:
+            lines.append(f"{indent}  while: count={while_info['count']}")
+        else:
+            lines.append(f"{indent}  while: {while_info.get('expr', '<callable>')}")
+
     return lines
 
 
@@ -420,9 +447,10 @@ def _reduce_param_edges(edges: list[dict]) -> list[dict]:
     first step.
 
     Only edges whose single ``kind`` is ``param`` are eligible for removal —
-    explicit ordering (``depends_on`` / hooks) and ``when`` edges are always
-    kept so user-added structure never silently disappears from the compact
-    view. The full edge set (including these) is retained in the JSON output.
+    explicit ordering (``depends_on`` / hooks), ``when``, and ``while`` edges
+    are always kept so user-added structure never silently disappears from the
+    compact view. The full edge set (including these) is retained in the JSON
+    output.
     """
     adj: dict[str, list[str]] = defaultdict(list)
     for e in edges:

timbal-2.6.0/python/timbal/codegen/guardrail_specs.py

@@ -0,0 +1,161 @@
+"""Shared CST helpers for the add-guardrail / remove-guardrail transformers.
+
+Lives outside ``transformers/`` on purpose. That package is scanned by ``pkgutil`` and
+every module in it is imported as an operation, so a helper module placed there would be
+registered as a bogus operation — and, worse, having one transformer import another's
+privates couples unrelated operations together at import time.
+"""
+
+import libcst as cst
+
+from .cst_utils import (
+    collect_assignments,
+    collect_step_names,
+    is_bare_function_step,
+    resolve_entry_point_type,
+)
+
+__all__ = [
+    "guardrails_kwarg_index",
+    "literal_shorthands",
+    "rail_name",
+    "string_element",
+    "string_value",
+    "validate_guardrail_target",
+    "validate_guardrails_value",
+    "validate_shorthand",
+]
+
+
+def validate_shorthand(spec: str) -> None:
+    """Validate one ``name[:action]`` shorthand at the CLI boundary.
+
+    Unknown names/actions re-raise the presets error (it lists the valid options).
+    Rails that are valid but have required constructor params (topic, judge, keywords,
+    length) get a pointer to configure them in code instead of a pydantic dump.
+    """
+    from timbal.guardrails.presets import coerce_rail
+
+    try:
+        coerce_rail(spec)
+    except ValueError as e:
+        if "Unknown guardrail" in str(e):
+            raise
+        reason = e.errors()[0]["msg"].removeprefix("Value error, ") if hasattr(e, "errors") else str(e)
+        raise ValueError(
+            f"Guardrail {spec.partition(':')[0].strip()!r} needs configuration that a shorthand cannot "
+            f"express: {reason} Configure it in code instead — e.g. "
+            "Agent(guardrails=[TopicGuard(allow=[...])]) from timbal.guardrails."
+        ) from e
+
+
+def validate_guardrails_value(rails: object) -> None:
+    """Validate a JSON ``guardrails`` value (agent- or tool-level) at the CLI.
+
+    Accepts the whole-value string ``"default"``, a single shorthand string, or a list
+    of shorthand strings. ``"default"`` inside a *list* is rejected: at runtime the
+    preset is only recognized as the whole value, so emitting it as a list entry would
+    fail at construction with a misleading "unknown shorthand" error.
+    """
+    from timbal.guardrails.presets import DEFAULT_SHORTHANDS
+
+    if isinstance(rails, str):
+        if rails.strip().lower() != "default":
+            validate_shorthand(rails)
+        return
+    if not isinstance(rails, list) or not all(isinstance(s, str) for s in rails):
+        raise ValueError(
+            'guardrails must be a JSON list of shorthand strings (e.g. ["pii:redact", "injection:block"]) '
+            'or the string "default".'
+        )
+    for spec in rails:
+        if spec.strip().lower() == "default":
+            raise ValueError(
+                '"default" is the whole-value preset, not a list entry. Use '
+                '{"guardrails": "default"}, or list its shorthands explicitly: '
+                f"{list(DEFAULT_SHORTHANDS)}."
+            )
+        validate_shorthand(spec)
+
+
+def validate_guardrail_target(
+    tree: cst.Module | None,
+    entry_point: str,
+    step: str | None,
+    operation: str,
+) -> tuple[str, dict]:
+    """Resolve and validate the Agent the operation targets. Mirrors remove-tool."""
+    if tree is not None:
+        ep_type = resolve_entry_point_type(tree, entry_point)
+        if step:
+            if ep_type is not None and ep_type != "Workflow":
+                raise ValueError(f"--step requires a Workflow entry point, but '{entry_point}' is a {ep_type}.")
+        else:
+            if ep_type is not None and ep_type != "Agent":
+                raise ValueError(f"{operation} requires an Agent entry point, but '{entry_point}' is a {ep_type}.")
+
+    target = step if step else entry_point
+    assignments = collect_assignments(tree) if tree else {}
+
+    if tree is not None:
+        if step:
+            step_names = collect_step_names(tree, entry_point, assignments)
+            if (
+                step not in step_names
+                and step not in assignments
+                and not is_bare_function_step(tree, entry_point, step, assignments)
+            ):
+                raise ValueError(
+                    f"Workflow step '{step}' not found. "
+                    "Use the step variable name from .step(...), not the runtime name."
+                )
+        elif entry_point not in assignments:
+            raise ValueError(
+                f"Entry point variable '{entry_point}' not found in source. "
+                "Ensure timbal.yaml fqn matches the Agent/Workflow variable name."
+            )
+    return target, assignments
+
+
+def string_value(node: cst.BaseExpression) -> str | None:
+    if isinstance(node, cst.SimpleString):
+        return node.evaluated_value if isinstance(node.evaluated_value, str) else None
+    return None
+
+
+def string_element(value: str) -> cst.Element:
+    return cst.Element(value=cst.SimpleString(f'"{value}"'))
+
+
+def rail_name(spec: str) -> str:
+    """The rail identity of a shorthand — ``"pii:redact"`` and ``"pii"`` are the same rail."""
+    return spec.partition(":")[0].strip().lower()
+
+
+def guardrails_kwarg_index(call: cst.Call) -> int | None:
+    for i, arg in enumerate(call.args):
+        if isinstance(arg.keyword, cst.Name) and arg.keyword.value == "guardrails":
+            return i
+    return None
+
+
+def literal_shorthands(value: cst.BaseExpression) -> list[str] | None:
+    """The kwarg's current shorthand list, or None when it isn't literal strings.
+
+    A ``"default"`` string expands to its preset shorthands so list edits compose.
+    """
+    if (s := string_value(value)) is not None:
+        if s.strip().lower() == "default":
+            from timbal.guardrails.presets import DEFAULT_SHORTHANDS
+
+            return list(DEFAULT_SHORTHANDS)
+        return [s]
+    if isinstance(value, cst.List):
+        out: list[str] = []
+        for el in value.elements:
+            s = string_value(el.value)
+            if s is None:
+                return None
+            out.append(s)
+        return out
+    return None

{timbal-2.4.2 → timbal-2.6.0}/python/timbal/codegen/transformers/__init__.py

@@ -16,22 +16,36 @@ from timbal.codegen import parse_fqn
 from timbal.codegen.cst_utils import collect_assignments, resolve_runnable_name
 from timbal.codegen.format import format_code
 
-_transformer_modules = None
-
 
 def load_modules() -> dict:
-    modules = {}
-    for info in pkgutil.iter_modules([str(Path(__file__).parent)]):
-        mod = importlib.import_module(f"timbal.codegen.transformers.{info.name}")
-        modules[info.name] = mod
-    return modules
+    """Import every transformer module. Used for discovery/introspection, not dispatch —
+    see :func:`_load_operation` for why running an operation must not import them all."""
+    return {
+        info.name: importlib.import_module(f"timbal.codegen.transformers.{info.name}")
+        for info in pkgutil.iter_modules([str(Path(__file__).parent)])
+    }
+
 
+def _module_names() -> set[str]:
+    """Available operation names, discovered without importing anything."""
+    return {info.name for info in pkgutil.iter_modules([str(Path(__file__).parent)])}
 
-def _get_transformer_modules() -> dict:
-    global _transformer_modules
-    if _transformer_modules is None:
-        _transformer_modules = load_modules()
-    return _transformer_modules
+
+def _load_operation(operation: str):
+    """Import the single transformer an operation needs.
+
+    Deliberately not ``load_modules()``: importing every transformer to run one means a
+    failure in any of them (a bad import, a syntax error mid-edit) breaks every unrelated
+    operation too.
+    """
+    if operation not in _module_names():
+        raise ValueError(f"unknown operation: {operation}")
+    try:
+        return importlib.import_module(f"timbal.codegen.transformers.{operation}")
+    except Exception as e:
+        raise ValueError(
+            f"operation '{operation.replace('_', '-')}' failed to load: {type(e).__name__}: {e}"
+        ) from e
 
 
 class _UsageAnalyzer(cst.CSTVisitor):
@@ -301,10 +315,7 @@ def apply_operation(workspace_path: str | Path, operation: str, **kwargs) -> str
     except cst.ParserSyntaxError as e:
         raise ValueError(f"Cannot parse {spec.path}: {e}") from e
 
-    modules = _get_transformer_modules()
-    mod = modules.get(operation)
-    if mod is None:
-        raise ValueError(f"unknown operation: {operation}")
+    mod = _load_operation(operation)
 
     args = SimpleNamespace(**kwargs)
     result = mod.run(spec.target, args, tree=tree)

timbal-2.6.0/python/timbal/codegen/transformers/add_guardrail.py

@@ -0,0 +1,113 @@
+"""add-guardrail: wire a guardrail shorthand into the Agent's guardrails list.
+
+```bash
+python -m timbal.codegen add-guardrail --spec "pii:redact"
+python -m timbal.codegen add-guardrail --spec default          # set guardrails="default"
+python -m timbal.codegen add-guardrail --spec "moderation:warn" --step agent_a
+```
+
+Semantics on the existing ``guardrails=`` kwarg:
+
+- absent → ``guardrails=["<spec>"]`` (or ``guardrails="default"`` for the default preset)
+- string ``"default"`` → expanded to its shorthand list, then the spec is merged in
+- string shorthand → converted to a two-element list
+- list of string literals → the spec is appended; an entry with the same rail *name*
+  (the part before ``:``) is replaced, since duplicate rail names are invalid at runtime
+- anything non-literal (a variable, rail instances) → loud error; edit the code directly
+"""
+
+import argparse
+
+import libcst as cst
+
+from ..guardrail_specs import (
+    guardrails_kwarg_index,
+    literal_shorthands,
+    rail_name,
+    string_element,
+    validate_guardrail_target,
+    validate_shorthand,
+)
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    sp = subparsers.add_parser(
+        "add-guardrail",
+        help="Add a guardrail shorthand to the agent's guardrails list.",
+    )
+    sp.add_argument(
+        "--spec",
+        required=True,
+        help='Guardrail shorthand: "default", or "<name>[:action]" (e.g. "pii:redact", "injection:block").',
+    )
+    sp.add_argument(
+        "--step",
+        default=None,
+        help="Target step name within a Workflow. When provided, the guardrail is added to that step's Agent.",
+    )
+
+
+def _validate_spec(spec: str) -> None:
+    """Reject unknown shorthands loudly at the CLI boundary."""
+    if spec.strip().lower() == "default":
+        return
+    validate_shorthand(spec)
+
+
+def run(entry_point: str, args: argparse.Namespace, *, tree: cst.Module | None = None) -> cst.CSTTransformer:
+    _validate_spec(args.spec)
+    target, _assignments = validate_guardrail_target(
+        tree, entry_point, getattr(args, "step", None), "add-guardrail"
+    )
+    return GuardrailAdder(target, args.spec.strip())
+
+
+class GuardrailAdder(cst.CSTTransformer):
+    def __init__(self, target: str, spec: str) -> None:
+        self.target = target
+        self.spec = spec
+        self.matched = False
+
+    def _edit_call(self, call: cst.Call) -> cst.Call:
+        self.matched = True
+        idx = guardrails_kwarg_index(call)
+
+        if self.spec.lower() == "default":
+            new_value: cst.BaseExpression = cst.SimpleString('"default"')
+        else:
+            current = [] if idx is None else literal_shorthands(call.args[idx].value)
+            if current is None:
+                raise ValueError(
+                    "The existing guardrails= value is not a literal string/list of shorthands "
+                    "(it may hold rail instances or a variable). Edit the source directly."
+                )
+            name = rail_name(self.spec)
+            merged = [s for s in current if rail_name(s) != name]
+            merged.append(self.spec)
+            if merged == current:
+                return call  # already present — idempotent
+            new_value = cst.List(elements=[string_element(s) for s in merged])
+
+        new_arg = cst.Arg(keyword=cst.Name("guardrails"), value=new_value)
+        if idx is None:
+            return call.with_changes(args=[*call.args, new_arg])
+        return call.with_changes(args=[*call.args[:idx], new_arg, *call.args[idx + 1 :]])
+
+    def leave_Assign(self, original_node: cst.Assign, updated_node: cst.Assign) -> cst.Assign:  # noqa: ARG002
+        for assign_target in updated_node.targets:
+            if (
+                isinstance(assign_target.target, cst.Name)
+                and assign_target.target.value == self.target
+                and isinstance(updated_node.value, cst.Call)
+            ):
+                return updated_node.with_changes(value=self._edit_call(updated_node.value))
+        return updated_node
+
+    def leave_AnnAssign(self, original_node: cst.AnnAssign, updated_node: cst.AnnAssign) -> cst.AnnAssign:  # noqa: ARG002
+        if (
+            isinstance(updated_node.target, cst.Name)
+            and updated_node.target.value == self.target
+            and isinstance(updated_node.value, cst.Call)
+        ):
+            return updated_node.with_changes(value=self._edit_call(updated_node.value))
+        return updated_node

timbal-2.6.0/python/timbal/codegen/transformers/remove_guardrail.py

@@ -0,0 +1,91 @@
+"""remove-guardrail: remove a guardrail from the Agent's guardrails list by rail name.
+
+```bash
+python -m timbal.codegen remove-guardrail --name pii
+python -m timbal.codegen remove-guardrail --name injection --step agent_a
+```
+
+Matches list entries by rail *name* (the part before ``:``), so ``--name pii`` removes
+``"pii"``, ``"pii:redact"``, or ``"pii:block"``. A ``guardrails="default"`` string is
+expanded to its shorthand list first. Removing the last rail drops the kwarg entirely.
+Removing an already-absent rail is an idempotent success.
+"""
+
+import argparse
+
+import libcst as cst
+
+from ..guardrail_specs import (
+    guardrails_kwarg_index,
+    literal_shorthands,
+    rail_name,
+    string_element,
+    validate_guardrail_target,
+)
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    sp = subparsers.add_parser(
+        "remove-guardrail",
+        help="Remove a guardrail from the agent's guardrails list by rail name.",
+    )
+    sp.add_argument("--name", required=True, help='The rail name to remove (e.g. "pii", "injection").')
+    sp.add_argument(
+        "--step",
+        default=None,
+        help="Target step name within a Workflow. When provided, the guardrail is removed from that step's Agent.",
+    )
+
+
+def run(entry_point: str, args: argparse.Namespace, *, tree: cst.Module | None = None) -> cst.CSTTransformer:
+    target, _assignments = validate_guardrail_target(
+        tree, entry_point, getattr(args, "step", None), "remove-guardrail"
+    )
+    return GuardrailRemover(target, args.name.strip().lower())
+
+
+class GuardrailRemover(cst.CSTTransformer):
+    # Removing an absent rail is an idempotent success.
+    allow_noop = True
+
+    def __init__(self, target: str, name: str) -> None:
+        self.target = target
+        self.name = name
+
+    def _edit_call(self, call: cst.Call) -> cst.Call:
+        idx = guardrails_kwarg_index(call)
+        if idx is None:
+            return call  # nothing configured — idempotent
+        current = literal_shorthands(call.args[idx].value)
+        if current is None:
+            raise ValueError(
+                "The existing guardrails= value is not a literal string/list of shorthands "
+                "(it may hold rail instances or a variable). Edit the source directly."
+            )
+        remaining = [s for s in current if rail_name(s) != self.name]
+        if remaining == current:
+            return call  # not present — idempotent (still normalizes "default" only on a hit)
+        if not remaining:
+            return call.with_changes(args=[*call.args[:idx], *call.args[idx + 1 :]])
+        new_value = cst.List(elements=[string_element(s) for s in remaining])
+        new_arg = cst.Arg(keyword=cst.Name("guardrails"), value=new_value)
+        return call.with_changes(args=[*call.args[:idx], new_arg, *call.args[idx + 1 :]])
+
+    def leave_Assign(self, original_node: cst.Assign, updated_node: cst.Assign) -> cst.Assign:  # noqa: ARG002
+        for assign_target in updated_node.targets:
+            if (
+                isinstance(assign_target.target, cst.Name)
+                and assign_target.target.value == self.target
+                and isinstance(updated_node.value, cst.Call)
+            ):
+                return updated_node.with_changes(value=self._edit_call(updated_node.value))
+        return updated_node
+
+    def leave_AnnAssign(self, original_node: cst.AnnAssign, updated_node: cst.AnnAssign) -> cst.AnnAssign:  # noqa: ARG002
+        if (
+            isinstance(updated_node.target, cst.Name)
+            and updated_node.target.value == self.target
+            and isinstance(updated_node.value, cst.Call)
+        ):
+            return updated_node.with_changes(value=self._edit_call(updated_node.value))
+        return updated_node