logify360 1.0.0__py3-none-any.whl

logify360/__init__.py

@@ -0,0 +1,99 @@
+"""Logify360 - agent tracing, LLM usage capture, and cost observability.
+
+Quick start::
+
+    from logify360 import Logify360Client
+
+    client = Logify360Client(api_key="sl_live_...")
+
+    with client.start_trace("rag_pipeline") as trace:
+        with trace.span("retrieval", span_type="retrieval") as span:
+            docs = retrieve(query)
+            span.end(output=docs)
+
+        with trace.span("generation", span_type="llm") as span:
+            from openai import OpenAI
+            response = OpenAI().chat.completions.create(...)
+            span.end(
+                output=response.choices[0].message.content,
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+            )
+
+For proxy-mode (zero-code) instrumentation, see
+``logify360.integrations.openai`` / ``anthropic`` / ``gemini``.
+"""
+
+from .client import Logify360Client
+from .evals import EvalsApi, score_confidence_interval
+from .headers import with_cache, with_log_body, with_prompt_version, with_session, with_user
+from .middleware import Logify360Middleware, install_logify360_middleware
+from .observe import (
+    observe,
+    observe_anthropic,
+    observe_cohere,
+    observe_deepseek,
+    observe_gemini,
+    observe_groq,
+    observe_mistral,
+    observe_ollama,
+    observe_openai,
+    observe_openrouter,
+    observe_xai,
+)
+from .parsers import parse_anthropic_usage, parse_gemini_usage, parse_openai_usage
+from .resilience import Fallback, Resilience, ResilienceError
+from .span import SpanHandle
+from .trace import TraceHandle
+from .transport import Logify360TransportError
+from .trust import (
+    attenuate_warrant,
+    handle_decoy_tool_calls,
+    is_decoy_tool_name,
+    mark_untrusted,
+    sign_warrant_request,
+    with_warrant,
+)
+
+__version__ = "0.11.0"
+
+__all__ = [
+    "EvalsApi",
+    "Fallback",
+    "SpanHandle",
+    "Logify360Client",
+    "Logify360Middleware",
+    "Logify360TransportError",
+    "Resilience",
+    "ResilienceError",
+    "TraceHandle",
+    "__version__",
+    "attenuate_warrant",
+    "handle_decoy_tool_calls",
+    "install_logify360_middleware",
+    "is_decoy_tool_name",
+    "mark_untrusted",
+    "observe",
+    "observe_anthropic",
+    "observe_cohere",
+    "observe_deepseek",
+    "observe_gemini",
+    "observe_groq",
+    "observe_mistral",
+    "observe_ollama",
+    "observe_openai",
+    "observe_openrouter",
+    "observe_xai",
+    "parse_anthropic_usage",
+    "parse_gemini_usage",
+    "parse_openai_usage",
+    "score_confidence_interval",
+    "sign_warrant_request",
+    "with_cache",
+    "with_log_body",
+    "with_prompt_version",
+    "with_session",
+    "with_user",
+    "with_warrant",
+]

logify360/_base_url.py

@@ -0,0 +1,86 @@
+"""Which Logify360 deployment the SDK talks to (SDK-01).
+
+Precedence: explicit argument > ``LOGIFY360_BASE_URL`` > hosted default. The
+CLI wizard writes ``LOGIFY360_BASE_URL`` for self-hosted installs, so every
+factory and the ingest transport must consult it - a helper that hardcodes the
+hosted proxy silently sends a self-hoster's traffic and ``sl_live_*`` key to
+``api.logify360.com``.
+
+The credential resolves the same way (explicit argument > ``LOGIFY360_API_KEY``)
+for every provider factory, through ``_require_api_key``.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Optional
+
+HOSTED_LOGIFY360_BASE_URL = "https://api.logify360.com"
+HOSTED_LOGIFY360_APP_URL = "https://app.logify360.com"
+HOSTED_LOGIFY360_DOCS_URL = "https://docs.logify360.com"
+HOSTED_LOGIFY360_SITE_URL = "https://www.logify360.com"
+DOCS_QUICK_START_URL = f"{HOSTED_LOGIFY360_DOCS_URL}/quick-start"
+HOSTED_CLI_API_URL = "https://www.logify360.com"
+
+
+def logify360_base_url(explicit: Optional[str] = None) -> str:
+    """Deployment root without a trailing slash."""
+    if explicit:
+        return explicit.rstrip("/")
+    configured = os.environ.get("LOGIFY360_BASE_URL", "").strip()
+    return (configured or HOSTED_LOGIFY360_BASE_URL).rstrip("/")
+
+
+def logify360_proxy_url(path: str) -> str:
+    """``logify360_base_url()`` joined with a proxy route such as ``/proxy/openai/v1``."""
+    if not path.startswith("/"):
+        path = f"/{path}"
+    return f"{logify360_base_url()}{path}"
+
+
+_API_KEY_CHARS = re.compile(r"[\x21-\x7e]+")
+
+
+def _api_key_problem(api_key: str, source: str) -> Optional[str]:
+    """Why ``api_key`` cannot be sent, or ``None`` if it is printable ASCII without whitespace.
+
+    Stripping removes padding only; a key with an embedded CR, LF, NUL or space is still an
+    illegal header value, and the error h11 raises for it quotes the key. That text would
+    reach stderr, ``on_error`` hooks, the with-block log, the exception ``close()`` raises
+    and the wizard's screen, so the key is refused first. The message names ``source`` (the
+    argument or variable the key came from) and NEVER the key.
+    """
+    if _API_KEY_CHARS.fullmatch(api_key):
+        return None
+    return f"{source} contains whitespace or control characters"
+
+
+def _checked_api_key(api_key: str, source: str) -> str:
+    """``api_key`` itself, or ``ValueError`` with ``_api_key_problem``'s message."""
+    problem = _api_key_problem(api_key, source)
+    if problem:
+        raise ValueError(f"[logify360] {problem}")
+    return api_key
+
+
+def _require_api_key(api_key: Optional[str], caller: str) -> str:
+    """Explicit ``api_key``, else ``LOGIFY360_API_KEY``; ``ValueError`` naming ``caller``.
+
+    Surrounding whitespace is stripped: a key read from a file or a secret mount
+    carries a trailing newline, and sent as is it is an illegal header value.
+    A blank key (empty or whitespace-only) counts as unset, so a blank explicit
+    ``api_key`` falls through to the environment. What is left must be printable
+    ASCII without whitespace (``_checked_api_key``).
+    """
+    explicit = (api_key or "").strip()
+    resolved_key = explicit or os.environ.get("LOGIFY360_API_KEY", "").strip()
+    if not resolved_key:
+        raise ValueError(
+            "[logify360] LOGIFY360_API_KEY is not set. Pass api_key=... to "
+            f"{caller}() or set the LOGIFY360_API_KEY environment variable."
+        )
+    return _checked_api_key(resolved_key, "api_key" if explicit else "LOGIFY360_API_KEY")
+
+
+__all__ = ["HOSTED_LOGIFY360_BASE_URL", "logify360_base_url", "logify360_proxy_url"]

logify360/cli/__init__.py

@@ -0,0 +1,33 @@
+"""Logify360 onboarding CLI.
+
+Installed as the ``logify360`` console command via ``[project.scripts]``::
+
+    pip install logify360
+    logify360 init
+
+Walks a Python developer through connecting their app to Logify360:
+
+    1. Detect the project type (poetry / pipenv / uv / pip) and LLM libraries
+    2. Validate the pasted Logify360 key against the API and introspect which
+       provider keys are registered
+    3. Write ``LOGIFY360_API_KEY`` into ``.env`` (idempotent, comment-preserving)
+    4. Install the ``logify360`` provider extras into the project
+    5. Patch ``OpenAI(...)`` / ``Anthropic(...)`` / ``genai.configure(...)`` to
+       route through the Logify360 proxy
+
+The CLI uses only the standard library plus ``httpx`` (already a runtime
+dependency of the SDK), so installing the wheel makes ``logify360 init`` work
+out of the box with no extra weight.
+"""
+
+from __future__ import annotations
+
+__all__ = ["main"]
+
+
+def main() -> int:
+    """Console-script entry point. Imported lazily so importing the package
+    does not pull the whole CLI graph for SDK-only users."""
+    from .main import main as _main
+
+    return _main()

logify360/cli/__main__.py

@@ -0,0 +1,10 @@
+"""Allow ``python -m logify360.cli`` as an alias for the ``logify360`` command."""
+
+from __future__ import annotations
+
+import sys
+
+from .main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

logify360/cli/code_patcher.py

@@ -0,0 +1,449 @@
+"""AST-based patcher that routes direct LLM SDK usage through Logify360.
+
+Python counterpart of ``packages/cli/src/code-patcher.ts``. We detect usage
+with the standard-library :mod:`ast` (precise, no third-party parser) and then
+splice targeted edits into the original source by byte offset, so formatting,
+comments, and unrelated code are left untouched.
+
+Supported rewrites::
+
+    from openai import OpenAI                 from logify360.integrations.openai import create_openai
+    client = OpenAI(api_key=KEY)        →     client = create_openai()
+
+    from anthropic import AsyncAnthropic      from logify360.integrations.anthropic import create_async_anthropic
+    client = AsyncAnthropic()           →     client = create_async_anthropic()
+
+    import google.generativeai as genai       import google.generativeai as genai
+    genai.configure(api_key=KEY)        →     from logify360.integrations.gemini import configure_gemini
+                                              configure_gemini()
+
+Scope (MVP, matching the Node CLI): top-level ``from X import Name`` /
+``import X`` plus their call sites. Dynamic imports and re-exports are not
+rewritten. The patch is always *additive-safe*. A patched file still imports
+and runs even in the rare shapes we leave for the user to finish by hand.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+# api_key / base_url are supplied by the Logify360 factory from the environment,
+# so we strip them from the original constructor call.
+_STRIP_KWARGS = frozenset({"api_key", "base_url"})
+
+
+@dataclass(frozen=True)
+class ProviderSpec:
+    provider: str
+    module: str
+    classes: Dict[str, str]  # original class name → Logify360 factory name
+    logify360_module: str
+
+
+CONSTRUCTOR_SPECS: Dict[str, ProviderSpec] = {
+    "openai": ProviderSpec(
+        provider="openai",
+        module="openai",
+        classes={"OpenAI": "create_openai", "AsyncOpenAI": "create_async_openai"},
+        logify360_module="logify360.integrations.openai",
+    ),
+    "anthropic": ProviderSpec(
+        provider="anthropic",
+        module="anthropic",
+        classes={
+            "Anthropic": "create_anthropic",
+            "AsyncAnthropic": "create_async_anthropic",
+        },
+        logify360_module="logify360.integrations.anthropic",
+    ),
+}
+
+_GEMINI_MODULE = "google.generativeai"
+_GEMINI_LOGIFY360_IMPORT = "from logify360.integrations.gemini import configure_gemini"
+
+_EXCLUDE_DIRS = frozenset(
+    {
+        ".venv",
+        "venv",
+        "env",
+        ".env",
+        ".git",
+        "__pycache__",
+        "node_modules",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        "build",
+        "dist",
+        ".tox",
+        ".eggs",
+        "site-packages",
+    }
+)
+
+
+@dataclass(frozen=True)
+class PatchPlan:
+    filepath: str
+    provider: str
+    changes: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class PatchResult:
+    filepath: str
+    provider: str
+    patched: bool
+    reason: Optional[str] = None
+
+
+# ── source-editing primitives ────────────────────────────────────────
+
+
+def _byte_line_starts(encoded: bytes) -> List[int]:
+    starts = [0]
+    for i, byte in enumerate(encoded):
+        if byte == 0x0A:  # newline
+            starts.append(i + 1)
+    return starts
+
+
+def _pos_to_byte(line_starts: List[int], lineno: int, col_offset: int) -> int:
+    # ast col_offset is a UTF-8 byte offset within the line (CPython semantics).
+    return line_starts[lineno - 1] + col_offset
+
+
+def _node_span(line_starts: List[int], node: ast.AST) -> Tuple[int, int]:
+    start = _pos_to_byte(line_starts, node.lineno, node.col_offset)  # type: ignore[attr-defined]
+    end = _pos_to_byte(line_starts, node.end_lineno, node.end_col_offset)  # type: ignore[attr-defined]
+    return start, end
+
+
+def _apply_edits(src: str, edits: List[Tuple[int, int, str]]) -> str:
+    """Apply (start_byte, end_byte, replacement) edits bottom-up on UTF-8 bytes."""
+    encoded = bytearray(src.encode("utf-8"))
+    for start, end, replacement in sorted(edits, key=lambda e: e[0], reverse=True):
+        encoded[start:end] = replacement.encode("utf-8")
+    return encoded.decode("utf-8")
+
+
+def _segment(src: str, node: ast.AST) -> str:
+    seg = ast.get_source_segment(src, node)
+    return seg if seg is not None else ""
+
+
+def _render_kept_args(src: str, call: ast.Call) -> Tuple[Optional[str], Optional[str]]:
+    """Reconstruct a call's argument list minus api_key / base_url.
+
+    Returns ``(kept_args, None)`` when every argument is statically readable,
+    or ``(None, shape)`` naming the argument shape that makes the credential
+    unremovable.
+
+    B#2: this is the ONE place the patcher decides whether the customer's
+    provider credential can be taken out of the call, so the refusal lives
+    here rather than at each call site. It used to copy ``*args`` and
+    ``**kwargs`` through verbatim while stripping only *literal* ``api_key=`` /
+    ``base_url=`` keywords, so ``OpenAI(**cfg)`` became ``create_openai(**cfg)``
+    and integrations/openai.py then resolved ``api_key or env`` /
+    ``base_url or proxy`` - the app kept talking straight to the provider with
+    the raw key while the wizard reported success. A splat's contents are
+    unknowable at AST time, and every ``create_*`` factory is keyword-only
+    (integrations/openai.py), so a positional argument cannot be forwarded
+    either. Refuse both and let the caller report it.
+    """
+    if call.args:
+        starred = any(isinstance(a, ast.Starred) for a in call.args)
+        return None, "*args" if starred else "a positional argument"
+    parts: List[str] = []
+    for kw in call.keywords:
+        if kw.arg is None:  # **kwargs - may carry api_key / base_url
+            return None, "**kwargs"
+        if kw.arg not in _STRIP_KWARGS:
+            parts.append(f"{kw.arg}={_segment(src, kw.value)}")
+    return ", ".join(parts), None
+
+
+def _refusal_message(class_name: str, factory: str, shape: str) -> str:
+    """Wording for a call the patcher will not rewrite (see _render_kept_args)."""
+    return (
+        f"{class_name}(...) forwards {shape}, so api_key / base_url cannot be removed "
+        f"statically - patch this call by hand: call {factory}(...) with the "
+        "non-credential options only (api_key / base_url come from the environment)."
+    )
+
+
+# ── constructor providers (OpenAI / Anthropic) ───────────────────────
+
+
+def _patch_constructor(
+    src: str, spec: ProviderSpec
+) -> Tuple[Optional[str], List[str], Optional[str]]:
+    try:
+        tree = ast.parse(src)
+    except SyntaxError:
+        return None, [], None
+
+    line_starts = _byte_line_starts(src.encode("utf-8"))
+
+    # local class name → original class name (named imports)
+    named_bindings: Dict[str, str] = {}
+    named_import_nodes: List[ast.ImportFrom] = []
+    # local module alias → True (module imports: `import openai` / `import openai as oai`)
+    module_aliases: Dict[str, bool] = {}
+    module_import_nodes: List[ast.Import] = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom) and node.module == spec.module:
+            for alias in node.names:
+                if alias.name in spec.classes:
+                    local = alias.asname or alias.name
+                    named_bindings[local] = alias.name
+                    if node not in named_import_nodes:
+                        named_import_nodes.append(node)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == spec.module:
+                    module_aliases[alias.asname or alias.name] = True
+                    if node not in module_import_nodes:
+                        module_import_nodes.append(node)
+
+    if not named_bindings and not module_aliases:
+        return None, [], None
+
+    edits: List[Tuple[int, int, str]] = []
+    used_factories: List[str] = []
+    call_count = 0
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        class_name: Optional[str] = None
+        if isinstance(func, ast.Name) and func.id in named_bindings:
+            class_name = named_bindings[func.id]
+        elif (
+            isinstance(func, ast.Attribute)
+            and isinstance(func.value, ast.Name)
+            and func.value.id in module_aliases
+            and func.attr in spec.classes
+        ):
+            class_name = func.attr
+        if class_name is None:
+            continue
+
+        factory = spec.classes[class_name]
+        if factory not in used_factories:
+            used_factories.append(factory)
+        kept, opaque = _render_kept_args(src, node)
+        if opaque is not None:
+            # Refuse the whole FILE: a partial rewrite would leave this call
+            # holding the raw key while the report claimed the file was patched.
+            return None, [], _refusal_message(class_name, factory, opaque)
+        start, end = _node_span(line_starts, node)
+        edits.append((start, end, f"{factory}({kept})"))
+        call_count += 1
+
+    if call_count == 0:
+        return None, [], None
+
+    changes: List[str] = []
+    import_line = f"from {spec.logify360_module} import {', '.join(used_factories)}"
+
+    # Prefer replacing a named import that imports ONLY provider classes,
+    # that yields the clean `from openai import OpenAI` → logify360 swap.
+    replaced_import = False
+    for node in named_import_nodes:
+        only_provider = all(a.name in spec.classes for a in node.names)
+        if only_provider and not replaced_import:
+            start, end = _node_span(line_starts, node)
+            edits.append((start, end, import_line))
+            replaced_import = True
+            changes.append(f"import: from {spec.module} → {import_line}")
+            break
+
+    if not replaced_import:
+        # Insert the Logify360 import right after the first provider import we saw.
+        anchor: Optional[ast.AST] = (
+            named_import_nodes[0]
+            if named_import_nodes
+            else (module_import_nodes[0] if module_import_nodes else None)
+        )
+        if anchor is not None:
+            _, end = _node_span(line_starts, anchor)
+            edits.append((end, end, f"\n{import_line}"))
+            changes.append(f"add import: {import_line}")
+
+    changes.append(
+        f"{call_count} × constructor → {', '.join(sorted(used_factories))}(...)"
+    )
+    return _apply_edits(src, edits), changes, None
+
+
+# ── gemini (configure-call style) ────────────────────────────────────
+
+
+def _patch_gemini(src: str) -> Tuple[Optional[str], List[str], Optional[str]]:
+    # genai.configure(...) drops ALL arguments, so there is no credential left
+    # to strip and nothing to refuse.
+    try:
+        tree = ast.parse(src)
+    except SyntaxError:
+        return None, [], None
+
+    line_starts = _byte_line_starts(src.encode("utf-8"))
+
+    module_aliases: Dict[str, bool] = {}
+    import_nodes: List[ast.Import] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == _GEMINI_MODULE:
+                    module_aliases[alias.asname or alias.name.split(".")[0]] = True
+                    if node not in import_nodes:
+                        import_nodes.append(node)
+
+    if not module_aliases:
+        return None, [], None
+
+    edits: List[Tuple[int, int, str]] = []
+    call_count = 0
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Attribute)
+            and node.func.attr == "configure"
+            and isinstance(node.func.value, ast.Name)
+            and node.func.value.id in module_aliases
+        ):
+            start, end = _node_span(line_starts, node)
+            edits.append((start, end, "configure_gemini()"))
+            call_count += 1
+
+    if call_count == 0:
+        return None, [], None
+
+    _, end = _node_span(line_starts, import_nodes[0])
+    edits.append((end, end, f"\n{_GEMINI_LOGIFY360_IMPORT}"))
+
+    changes = [
+        f"add import: {_GEMINI_LOGIFY360_IMPORT}",
+        f"{call_count} × genai.configure(...) → configure_gemini()",
+    ]
+    return _apply_edits(src, edits), changes, None
+
+
+def _patch_source(src: str, provider: str) -> Tuple[Optional[str], List[str], Optional[str]]:
+    """``(new_source, changes, refusal)``. Exactly one of new_source/refusal is set."""
+    if provider == "gemini":
+        return _patch_gemini(src)
+    spec = CONSTRUCTOR_SPECS.get(provider)
+    if spec is None:
+        return None, [], None
+    return _patch_constructor(src, spec)
+
+
+# ── filesystem scanning ──────────────────────────────────────────────
+
+
+def _candidate_files(root: str) -> List[str]:
+    out: List[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _EXCLUDE_DIRS]
+        for name in filenames:
+            if name.endswith(".py"):
+                out.append(os.path.join(dirpath, name))
+    return out
+
+
+def _prefilter(text: str, provider: str) -> bool:
+    if provider == "gemini":
+        return _GEMINI_MODULE in text and "configure" in text
+    spec = CONSTRUCTOR_SPECS.get(provider)
+    if spec is None:
+        return False
+    return spec.module in text and any(cls in text for cls in spec.classes)
+
+
+def plan_patches(cwd: str, providers: List[str]) -> List[PatchPlan]:
+    plans: List[PatchPlan] = []
+    supported = [p for p in providers if p == "gemini" or p in CONSTRUCTOR_SPECS]
+    if not supported:
+        return plans
+
+    for filepath in _candidate_files(cwd):
+        try:
+            with open(filepath, encoding="utf-8") as fh:
+                src = fh.read()
+        except (OSError, UnicodeDecodeError):
+            continue
+        for provider in supported:
+            if not _prefilter(src, provider):
+                continue
+            new_src, changes, refusal = _patch_source(src, provider)
+            if refusal is not None:
+                # Listing it is the useful half of a preview; `changes` must not
+                # advertise a rewrite that apply_patches will refuse (B#2).
+                plans.append(
+                    PatchPlan(
+                        filepath=filepath,
+                        provider=provider,
+                        changes=[f"will NOT be patched - {refusal}"],
+                    )
+                )
+            elif new_src is not None and changes:
+                plans.append(PatchPlan(filepath=filepath, provider=provider, changes=changes))
+    return plans
+
+
+def apply_patches(plans: List[PatchPlan], *, dry_run: bool = False) -> List[PatchResult]:
+    results: List[PatchResult] = []
+    for plan in plans:
+        try:
+            with open(plan.filepath, encoding="utf-8") as fh:
+                src = fh.read()
+        except (OSError, UnicodeDecodeError) as exc:
+            results.append(
+                PatchResult(plan.filepath, plan.provider, patched=False, reason=str(exc))
+            )
+            continue
+        new_src, _changes, refusal = _patch_source(src, plan.provider)
+        if refusal is not None:
+            results.append(
+                PatchResult(plan.filepath, plan.provider, patched=False, reason=refusal)
+            )
+            continue
+        if new_src is None or new_src == src:
+            results.append(
+                PatchResult(plan.filepath, plan.provider, patched=False, reason="no change")
+            )
+            continue
+        if not dry_run:
+            try:
+                with open(plan.filepath, "w", encoding="utf-8") as fh:
+                    fh.write(new_src)
+            except OSError as exc:
+                # Guarded for the same reason the read above is: a read-only
+                # file (EACCES) or one removed between plan and apply must
+                # surface as a REFUSAL - patch_report() then says "setup
+                # INCOMPLETE" and exits 1, mirroring packages/cli/src/index.ts
+                # :461-474 - instead of a PermissionError traceback out of the
+                # wizard (_cmd_init only catches PromptCancelledError).
+                results.append(
+                    PatchResult(plan.filepath, plan.provider, patched=False, reason=str(exc))
+                )
+                continue
+        results.append(PatchResult(plan.filepath, plan.provider, patched=True))
+    return results
+
+
+__all__ = [
+    "CONSTRUCTOR_SPECS",
+    "PatchPlan",
+    "PatchResult",
+    "ProviderSpec",
+    "apply_patches",
+    "plan_patches",
+]