deepagents-code 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "8f48aab"
+BUILD_COMMIT = "42e4f08"

deepagents_code/_checkpointer_adapter.py

@@ -0,0 +1,86 @@
+"""Forward delta-channel history reads through langgraph-api's saver adapter.
+
+The LangGraph dev server wraps a custom checkpointer in
+`langgraph_api._checkpointer._adapter._CustomCheckpointerAdapter`. The adapter
+forwards unknown attributes to the inner saver through `__getattr__`, but
+`BaseCheckpointSaver` already defines `aget_delta_channel_history`, so the
+forwarding never fires. The adapter then runs the base ancestor walk: one
+`aget_tuple` and one full checkpoint decode per ancestor. The SQLite saver
+overrides the method with two indexed queries, and long threads pay the
+difference on every state read and every run start.
+
+This module is a best-effort patch over a private langgraph-api class. It only
+patches when the adapter still inherits the base method, and it falls back to
+the base walk when the inner saver has no override of its own. Remove it when
+the adapter forwards these methods itself.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from langchain_core.runnables import RunnableConfig
+    from langgraph.checkpoint.base import DeltaChannelHistory
+
+logger = logging.getLogger(__name__)
+
+_BASE_ASYNC = BaseCheckpointSaver.aget_delta_channel_history
+_BASE_SYNC = BaseCheckpointSaver.get_delta_channel_history
+
+
+def _overriding_inner(
+    adapter: BaseCheckpointSaver, name: str
+) -> BaseCheckpointSaver | None:
+    """Return the adapter's inner saver if it overrides the base method `name`."""
+    inner = adapter.__dict__.get("_inner")
+    if not isinstance(inner, BaseCheckpointSaver):
+        return None
+    if getattr(type(inner), name) is getattr(BaseCheckpointSaver, name):
+        return None
+    return inner
+
+
+async def _aget_delta_channel_history(
+    self: BaseCheckpointSaver, *, config: RunnableConfig, channels: Sequence[str]
+) -> Mapping[str, DeltaChannelHistory]:
+    inner = _overriding_inner(self, "aget_delta_channel_history")
+    if inner is None:
+        return await _BASE_ASYNC(self, config=config, channels=channels)
+    return await inner.aget_delta_channel_history(config=config, channels=channels)
+
+
+def _get_delta_channel_history(
+    self: BaseCheckpointSaver, *, config: RunnableConfig, channels: Sequence[str]
+) -> Mapping[str, DeltaChannelHistory]:
+    inner = _overriding_inner(self, "get_delta_channel_history")
+    if inner is None:
+        return _BASE_SYNC(self, config=config, channels=channels)
+    return inner.get_delta_channel_history(config=config, channels=channels)
+
+
+def install_delta_history_forwarding() -> None:
+    """Make langgraph-api's checkpointer adapter use the inner saver's fast path.
+
+    Call this in the server process before the adapter serves requests. It is
+    idempotent and a no-op when the adapter is missing or already overrides
+    the methods.
+    """
+    try:
+        # The adapter has no public seam; this patch exists to reach it.
+        from langgraph_api._checkpointer._adapter import (  # noqa: PLC2701
+            _CustomCheckpointerAdapter,
+        )
+    except ImportError:
+        logger.warning("langgraph-api checkpointer adapter not found; skipping patch")
+        return
+    adapter = _CustomCheckpointerAdapter
+    if adapter.aget_delta_channel_history is _BASE_ASYNC:
+        adapter.aget_delta_channel_history = _aget_delta_channel_history
+    if adapter.get_delta_channel_history is _BASE_SYNC:
+        adapter.get_delta_channel_history = _get_delta_channel_history

deepagents_code/_env_vars.py

@@ -77,6 +77,15 @@ Values outside 1-900 seconds are ignored in favor of the next config source.
 Also settable via `[mcp].tool_timeout` in config.toml.
 """
 
+ASK_ABOUT_SELECTION = "DEEPAGENTS_CODE_ASK_ABOUT_SELECTION"
+"""Show "Ask about this" when conversation text is selected.
+
+Enabled by default; set to a falsy value (`0`, `false`, `no`, `off`) to hide
+it. Parsed by `classify_env_bool` (an unrecognized or empty value falls through
+to the config value rather than forcing the default). Also settable via
+`[ui].ask_about_selection` in config.toml. `/reload` applies a change.
+"""
+
 AUTO_UPDATE = "DEEPAGENTS_CODE_AUTO_UPDATE"
 """Toggle automatic app updates. Enabled by default; set to a falsy value
 ('0', 'false', 'no', 'off', or empty) to opt out."""
@@ -277,13 +286,20 @@ EXPERIMENTAL = "DEEPAGENTS_CODE_EXPERIMENTAL"
 Off by default; parsed by `is_env_truthy` (see there for the accepted truthy
 values). Marks experimental runs in UI/trace metadata. Behavior behind this
 flag may change or be removed without notice.
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
 """
 
 EXTENSIONS = "DEEPAGENTS_CODE_EXTENSIONS"
 """Enable loading installed-plugin and trusted-project Python extensions."""
 
 EXTENSIONS_TRUST = "DEEPAGENTS_CODE_EXTENSIONS_TRUST"
-"""Default project extension trust policy: `ask`, `always`, or `never`."""
+"""Default project extension trust policy: `ask`, `always`, or `never`.
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
+"""
 
 EXTERNAL_EVENT_SOCKET = "DEEPAGENTS_CODE_EXTERNAL_EVENT_SOCKET"
 """Enable the local Unix-socket external event listener.
@@ -296,7 +312,11 @@ EXTERNAL_EVENT_SOCKET_PATH = "DEEPAGENTS_CODE_EXTERNAL_EVENT_SOCKET_PATH"
 """Override the default Unix-socket path for the external event listener."""
 
 EXTRA_SKILLS_DIRS = "DEEPAGENTS_CODE_EXTRA_SKILLS_DIRS"
-"""Paths added to the skill containment allowlist, split with `os.pathsep`."""
+"""Paths added to the skill containment allowlist, split with `os.pathsep`.
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
+"""
 
 GOAL_AUTO_ACCEPT_CRITERIA = "DEEPAGENTS_CODE_GOAL_AUTO_ACCEPT_CRITERIA"
 """Apply generated goal criteria automatically in Auto mode.
@@ -485,6 +505,8 @@ PLUGIN_CACHE_DIR = "DEEPAGENTS_CODE_PLUGIN_CACHE_DIR"
 """Override the plugin install/marketplace cache root.
 
 When unset, plugins are stored under `DEFAULT_CONFIG_DIR / "plugins"`.
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
 """
 
 PRICES_AUTO_UPDATE = "DEEPAGENTS_CODE_PRICES_AUTO_UPDATE"
@@ -564,7 +586,11 @@ SERVER_ENV_PREFIX = "DEEPAGENTS_CODE_SERVER_"
 """Environment variable prefix used to pass CLI config to the server subprocess."""
 
 SHELL_ALLOW_LIST = "DEEPAGENTS_CODE_SHELL_ALLOW_LIST"
-"""Comma-separated shell commands to allow (or 'recommended'/'all')."""
+"""Comma-separated shell commands to allow (or 'recommended'/'all').
+
+Set only through the launching shell or global `~/.deepagents/.env`; a project
+`.env` cannot set it.
+"""
 
 SHOW_HEADER = "DEEPAGENTS_CODE_SHOW_HEADER"
 """Show Textual's native header bar at the top of the TUI when enabled."""

deepagents_code/_git.py

@@ -17,6 +17,9 @@ _GIT_DIR_POINTER_PREFIX = "gitdir: "
 _GIT_HEAD_REF_PREFIX = "ref: "
 """Prefix used by `HEAD` when it points at a named ref instead of a commit."""
 
+_REFTABLE_HEAD_PLACEHOLDER = "refs/heads/.invalid"
+"""Ref a reftable repository writes to `HEAD`; the real refs live in `reftable/`."""
+
 _GIT_REF_PREFIXES = ("refs/heads/", "refs/remotes/", "refs/tags/", "refs/")
 """Known git ref prefixes stripped when formatting a branch-like display name."""
 
@@ -411,7 +414,8 @@ def read_git_branch_from_filesystem(path: str | Path) -> str | None:
     Returns:
         The abbreviated branch name, `HEAD` for detached HEAD, an empty string
         when `path` is not inside a git repository, or `None` when metadata
-        exists but cannot be parsed confidently.
+        exists but cannot be parsed confidently (including reftable
+        repositories, whose `HEAD` file only holds a placeholder).
     """
     git_dir = find_git_dir(path)
     if git_dir is None:
@@ -431,7 +435,9 @@ def read_git_branch_from_filesystem(path: str | Path) -> str | None:
         return ""
     if head.startswith(_GIT_HEAD_REF_PREFIX):
         ref = head.removeprefix(_GIT_HEAD_REF_PREFIX).strip()
-        return _abbreviate_git_ref(ref) if ref else None
+        if not ref or ref == _REFTABLE_HEAD_PLACEHOLDER:
+            return None
+        return _abbreviate_git_ref(ref)
     return "HEAD"
 
 

deepagents_code/_js_cost.py

@@ -7,6 +7,7 @@ import dataclasses
 import hashlib
 import itertools
 import json
+import logging
 import math
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, override
@@ -19,6 +20,7 @@ from langgraph.checkpoint.base import (
     empty_checkpoint,
 )
 from langgraph.config import get_config
+from langgraph.errors import GraphBubbleUp, NodeCancelledError
 from langgraph.types import Command
 
 from deepagents_code.cost_tracking import (
@@ -37,6 +39,8 @@ if TYPE_CHECKING:
 
     from deepagents_code.cost_tracking import CostBreakdown
 
+logger = logging.getLogger(__name__)
+
 _ACCOUNTING_KEY = "__deepagents_js_cost_owner"
 _RESPONSE_FORMAT_KEY = "__deepagents_subagent_response_format"
 
@@ -172,6 +176,17 @@ def _cost_task(
                 config=config,
                 tool_call_id=runtime.tool_call_id,
             )
+        except asyncio.CancelledError, GraphBubbleUp, NodeCancelledError:
+            raise
+        except Exception as exc:
+            logger.debug("Subagent %r failed", subagent_type, exc_info=exc)
+            return {
+                "error": (
+                    f"Subagent {subagent_type!r} failed: "
+                    f"{type(exc).__name__}: {str(exc)[:300]}. You may retry this task."
+                ),
+                "failed": True,
+            }
         finally:
             if invocation is not None:
                 active.discard(invocation)

deepagents_code/_langsmith_runtime.py

@@ -0,0 +1,91 @@
+"""Run untraced `@traceable` bookkeeping inline on the server loop.
+
+LangChain wraps every middleware `awrap_tool_call` and `awrap_model_call` hook
+in `langsmith.traceable`. Its async wrapper sends two calls to a worker thread
+per hook: one to set up the run and one to end it. It does this even when
+tracing is off and both calls only build an empty container. About 20 traced
+hooks run per tool round trip, so each round trip pays for about 40 thread
+hops that do no work.
+
+`install_untraced_inline_override` installs a LangSmith runtime override. The
+override runs those two calls inline when they cannot trace, and gives every
+other call to LangSmith's default thread hop.
+"""
+
+from __future__ import annotations
+
+import functools
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import contextvars
+    from collections.abc import Awaitable, Callable
+
+    DefaultAioToThread = Callable[..., Awaitable[Any]]
+
+logger = logging.getLogger(__name__)
+
+
+def _target(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Return the function a `functools.partial` wraps, else `func` itself.
+
+    Returns:
+        The underlying callable.
+    """
+    return func.func if isinstance(func, functools.partial) else func
+
+
+def _runs_inline(
+    ctx: contextvars.Context,
+    func: Callable[..., Any],
+    args: tuple[Any, ...],
+) -> bool:
+    """Whether a `traceable` bookkeeping call cannot trace, so it is cheap.
+
+    Only run setup and run end qualify. Any other call (for example an async
+    `Client` API method) can do network I/O, so it keeps the thread hop.
+
+    Returns:
+        `True` when the call is safe to run on the event loop.
+    """
+    from langsmith import run_helpers
+    from langsmith.utils import tracing_is_enabled
+
+    target = _target(func)
+    if target is getattr(run_helpers, "_setup_run", None):
+        return not ctx.run(tracing_is_enabled)
+    if target is getattr(run_helpers, "_handle_container_end", None):
+        container = args[0] if args else None
+        return isinstance(container, dict) and container.get("new_run") is None
+    return False
+
+
+async def _untraced_inline_aio_to_thread(
+    default: DefaultAioToThread,
+    ctx: contextvars.Context,
+    func: Callable[..., Any],
+    /,
+    *args: Any,  # forwards arbitrary LangSmith call arguments
+    **kwargs: Any,  # forwards arbitrary LangSmith call arguments
+) -> Any:  # noqa: ANN401  # returns whatever `func` returns
+    """Run untraced bookkeeping inline; hop to a thread for everything else.
+
+    Returns:
+        The result of `func`.
+    """
+    if _runs_inline(ctx, func, args):
+        return ctx.run(func, *args, **kwargs)
+    return await default(ctx, func, *args, **kwargs)
+
+
+def install_untraced_inline_override() -> None:
+    """Install the override for this process.
+
+    The override is process-global. Call it only in the server process, which
+    owns its event loop and pins one tracing configuration for its lifetime.
+    """
+    import langsmith
+
+    langsmith.set_runtime_overrides(aio_to_thread=_untraced_inline_aio_to_thread)
+    logger.debug("Installed inline LangSmith runtime override for untraced runs")

deepagents_code/_run_queue_wakeup.py

@@ -0,0 +1,156 @@
+"""Wake the in-memory run queue when a run is created.
+
+The server runs on `langgraph_runtime_inmem`. Its background scheduler polls
+for pending runs: `Runs.next(wait=True)` sleeps 0.5 s, then claims only runs
+created before that sleep began. Every user turn and every interrupt resume is
+a new run, so each one waits 0.5-1.0 s before a worker starts it.
+
+This patch makes `Runs.put` set an event and makes a waiting `Runs.next` wait
+on that event instead of the fixed sleep. The stock `Runs.next` still claims
+the runs, so queue order and per-thread locking do not change. The 0.5 s
+timeout stays as a fallback, so a missed wakeup costs at most the stock delay.
+
+`Runs.next` and `Runs.put` are private APIs. If their shape is not what this
+module expects, the patch logs at debug level and does nothing. Remove this
+module when `langgraph_runtime_inmem` wakes the scheduler on put.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import functools
+import inspect
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable
+
+logger = logging.getLogger(__name__)
+
+_POLL_INTERVAL = 0.5
+"""Fallback wait in seconds; matches the stock `Runs.next` sleep."""
+
+_PATCHED_MARKER = "_dcode_run_queue_wakeup"
+"""Attribute set on each wrapper so a second install is a no-op."""
+
+
+class _Wakeup:
+    """Edge-triggered signal from `Runs.put` to a waiting `Runs.next`.
+
+    The event binds to the scheduler loop on the first wait. A put before
+    that first wait is not lost: the scheduler then waits the fallback
+    interval, as stock does.
+    """
+
+    def __init__(self) -> None:
+        self._event: asyncio.Event | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    async def wait(self) -> None:
+        """Wait until a run is put, or until the fallback interval passes."""
+        if self._event is None:
+            self._event = asyncio.Event()
+            self._loop = asyncio.get_running_loop()
+        with contextlib.suppress(TimeoutError):
+            async with asyncio.timeout(_POLL_INTERVAL):
+                await self._event.wait()
+        self._event.clear()
+
+    def notify(self) -> None:
+        """Wake the scheduler; safe from any thread and after loop close."""
+        event, loop = self._event, self._loop
+        if event is None or loop is None:
+            return
+        # The loop can close during shutdown; the wakeup is then moot.
+        with contextlib.suppress(RuntimeError):
+            loop.call_soon_threadsafe(event.set)
+
+
+_WAKEUP = _Wakeup()
+
+
+def _wrap_next(
+    original: Callable[[bool, int], AsyncIterator[object]],
+) -> Callable[[bool, int], AsyncIterator[object]]:
+    """Replace the fixed poll sleep with a wait on `_WAKEUP`.
+
+    Returns:
+        A drop-in replacement for the upstream `Runs.next`.
+    """
+
+    @functools.wraps(original)
+    async def next_runs(wait: bool, limit: int = 1) -> AsyncIterator[object]:
+        if wait:
+            await _WAKEUP.wait()
+        # `wait=False` skips the sleep and claims runs created before now,
+        # which includes the run that woke us.
+        async for item in original(False, limit):
+            yield item
+
+    setattr(next_runs, _PATCHED_MARKER, True)
+    return next_runs
+
+
+def _wrap_put(
+    original: Callable[..., Awaitable[object]],
+) -> Callable[..., Awaitable[object]]:
+    """Notify `_WAKEUP` after each run insert.
+
+    Returns:
+        A drop-in replacement for the upstream `Runs.put`.
+    """
+
+    @functools.wraps(original)
+    async def put(*args: object, **kwargs: object) -> object:
+        result = await original(*args, **kwargs)
+        _WAKEUP.notify()
+        return result
+
+    setattr(put, _PATCHED_MARKER, True)
+    return put
+
+
+def _has_expected_shape(runs: type) -> bool:
+    """Check that `Runs.next` and `Runs.put` look like the pinned version.
+
+    Returns:
+        `True` when both are static methods with the expected signatures.
+    """
+    next_attr = runs.__dict__.get("next")
+    put_attr = runs.__dict__.get("put")
+    if not isinstance(next_attr, staticmethod) or not isinstance(
+        put_attr, staticmethod
+    ):
+        return False
+    next_fn, put_fn = next_attr.__func__, put_attr.__func__
+    params = list(inspect.signature(next_fn).parameters)
+    return (
+        inspect.isasyncgenfunction(next_fn)
+        and params[:2] == ["wait", "limit"]
+        and inspect.iscoroutinefunction(put_fn)
+    )
+
+
+def install_run_queue_wakeup() -> bool:
+    """Patch the in-memory run queue to start new runs without the poll delay.
+
+    Returns:
+        `True` when the patch is active after the call, else `False`.
+    """
+    try:
+        from langgraph_runtime_inmem.ops import Runs
+    except ImportError:
+        logger.debug("Run queue wakeup skipped: in-memory runtime not installed")
+        return False
+    if getattr(Runs.next, _PATCHED_MARKER, False):
+        return True
+    if not _has_expected_shape(Runs):
+        logger.debug("Run queue wakeup skipped: Runs.next/put changed upstream")
+        return False
+    wrappers = {"next": _wrap_next, "put": _wrap_put}
+    for name, wrap in wrappers.items():
+        setattr(Runs, name, staticmethod(wrap(getattr(Runs, name))))
+    logger.debug("Run queue wakeup installed")
+    return True

deepagents_code/_textual_patches.py

@@ -293,6 +293,11 @@ else:
 
 
 def _rendered_text(widget: Widget) -> str | None:
+    # A widget that renders a custom visual (such as `FinalMarkdown`) can
+    # publish the text its selection offsets index into.
+    selectable = getattr(widget, "selectable_text", None)
+    if isinstance(selectable, str):
+        return selectable
     visual = widget._render()  # match Textual's get_selection path
     if isinstance(visual, (Content, Text)):
         return str(visual)

deepagents_code/_trace_redaction.py

@@ -0,0 +1,145 @@
+"""LangSmith secret redaction that reuses results across traced runs.
+
+Each traced run carries the full message history, so the stock secret
+anonymizer re-runs every rule over strings it already scanned on the previous
+model call. Redaction is a pure function of each string, so this module caches
+the masked result per input string and skips the regex passes on a repeat.
+
+Imported lazily: it pulls in `langsmith.anonymizer`, which the tracing-off
+startup path does not need.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any
+
+from langsmith.anonymizer import (
+    DEFAULT_SECRET_RULES,
+    RuleNodeProcessor,
+    StringNode,
+    StringNodeProcessor,
+    create_anonymizer,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from langsmith.anonymizer import StringNodeRule
+
+_MAX_DEPTH = 24
+"""Traversal depth; matches the default of `create_secret_anonymizer`."""
+
+_MAX_ENTRIES = 50_000
+"""Most distinct strings the cache keeps before it evicts the oldest."""
+
+_MAX_CHARS = 16 * 1024 * 1024
+"""Most characters (keys plus changed values) the cache keeps alive."""
+
+
+class CachingRuleProcessor(StringNodeProcessor):
+    """Apply secret rules per string and remember the result in a bounded LRU.
+
+    The output for a string is the same whether it comes from the cache or
+    from the rules, so the cache cannot let a secret through. Strings too large
+    for the character budget are masked each time and not cached.
+    """
+
+    def __init__(
+        self,
+        rules: list[StringNodeRule],
+        *,
+        max_entries: int = _MAX_ENTRIES,
+        max_chars: int = _MAX_CHARS,
+    ) -> None:
+        """Build the processor.
+
+        Args:
+            rules: Redaction rules, applied in order to every string.
+            max_entries: Upper bound on cached strings.
+            max_chars: Upper bound on characters the cache holds.
+        """
+        self._rules = RuleNodeProcessor(rules)
+        self._max_entries = max_entries
+        self._max_chars = max_chars
+        self._cache: OrderedDict[str, str] = OrderedDict()
+        self._chars = 0
+        # The tracer can call the anonymizer from its background thread as
+        # well as from the event loop.
+        self._lock = threading.Lock()
+
+    def mask_nodes(self, nodes: list[StringNode]) -> list[StringNode]:
+        """Return the nodes whose value changes after masking.
+
+        Args:
+            nodes: String nodes extracted from a traced payload.
+
+        Returns:
+            Replacement nodes, one for each string that the rules changed.
+        """
+        # One lock round-trip per payload, not per string: a long history has
+        # tens of thousands of string nodes.
+        with self._lock:
+            hits = [self._lookup(node["value"]) for node in nodes]
+        result: list[StringNode] = []
+        for node, hit in zip(nodes, hits, strict=True):
+            value = node["value"]
+            masked = self._apply_rules(value) if hit is None else hit
+            if masked != value:
+                result.append(StringNode(value=masked, path=node["path"]))
+        return result
+
+    def _lookup(self, value: str) -> str | None:
+        """Return the cached mask for `value` and mark it recent; caller locks."""
+        masked = self._cache.get(value)
+        if masked is not None:
+            self._cache.move_to_end(value)
+        return masked
+
+    def _apply_rules(self, value: str) -> str:
+        """Run every rule over `value` and cache the result.
+
+        Returns:
+            The masked string, or `value` itself when no rule matched.
+        """
+        changed = self._rules.mask_nodes([StringNode(value=value, path=[])])
+        masked = changed[0]["value"] if changed else value
+        self._store(value, masked)
+        return masked
+
+    def _store(self, value: str, masked: str) -> None:
+        """Cache `masked` for `value` and evict the oldest entries past bounds."""
+        cost = _cost(value, masked)
+        if cost > self._max_chars:
+            return
+        with self._lock:
+            if value in self._cache:
+                return
+            self._cache[value] = masked
+            self._chars += cost
+            while len(self._cache) > self._max_entries or self._chars > self._max_chars:
+                old_value, old_masked = self._cache.popitem(last=False)
+                self._chars -= _cost(old_value, old_masked)
+
+
+def _cost(value: str, masked: str) -> int:
+    """Return the characters a cache entry keeps alive.
+
+    An unchanged string stores the key object as its own value, so it counts
+    once.
+    """
+    return len(value) + (0 if masked is value else len(masked))
+
+
+def create_cached_secret_anonymizer() -> Callable[[Any], Any]:
+    """Build a secret anonymizer that matches `create_secret_anonymizer`.
+
+    It uses the same default rules and depth, and adds a per-string cache so
+    unchanged history strings are not scanned again on each traced run.
+
+    Returns:
+        An anonymizer to pass to `langsmith.Client(anonymizer=...)`.
+    """
+    processor = CachingRuleProcessor(list(DEFAULT_SECRET_RULES))
+    return create_anonymizer(processor, max_depth=_MAX_DEPTH)

deepagents_code/_version.py

@@ -2,7 +2,7 @@
 
 # Keep the `x-release-please-version` annotation — release-please uses it to
 # bump `__version__` in sync with `pyproject.toml` on every release PR.
-__version__ = "0.2.1"  # x-release-please-version
+__version__ = "0.2.2"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""