cisternal 0.1.0a1__py3-none-any.whl

cisternal/__init__.py

@@ -0,0 +1,150 @@
+"""Cisternal: Shared telemetry substrate for praxia tool family.
+
+Public API (spec §3.2 — M1 telemetry + M2 registration surface):
+
+  M1 — Telemetry:
+    init(log_dir, max_bytes, backup_count, exporters): Initialize pipeline
+    emit_event(name, **fields): Emit a telemetry event
+    span(name, **fields): Sync timing context manager
+    aspan(name, **fields): Async timing context manager
+    status(): Get pipeline health status
+
+  M2 — Registration surface (B+G2 hybrid design, challenger-hardened):
+    tool: Pure-metadata decorator for registering MCP tools (A1, A2).
+          @cisternal.tool returns the original fn unchanged (decorated_fn is fn).
+    wire(server, app, *, adapter, registry, expected, validate):
+          Snapshot a registry at call time and register each tool on a FastMCP
+          server (and optionally a Cyclopts App). Returns a WiredRegistry.
+    WiredRegistry: Introspection object returned by wire().
+    CisternalWireError: Raised by wire() when expected tools are missing.
+    clear_registry(name): Test teardown helper; clears a named registry (A7).
+
+Design assumptions (spec §assumptions):
+  A1 — FastMCP v3 uses asyncio.iscoroutinefunction() to decide whether to await
+        the tool callable. The generated MCP callable is always async def.
+  A2 — FastMCP v3 reads inspect.signature(fn) for JSON schema generation.
+        Explicit __signature__ injection (H1) controls what FastMCP sees.
+  A3 — M1 CisternalMiddleware is installed on the FastMCP server before wire()
+        is called. Telemetry and shape adaptation are M1's exclusive responsibility.
+  A4 — Cyclopts 4.18.0+ calls asyncio.run() for async def command functions when
+        no event loop is running; inside a running loop, use app.run_async().
+  A5 — Global registry state is process-scoped; no cross-process sharing.
+  A6 — Python >= 3.11 (asyncio.get_running_loop() is the stable API).
+  A7 — Test environments call cisternal.clear_registry() in teardown to prevent
+        cross-test registry contamination.
+
+HARD INVARIANT (C5/AC-M2-6):
+  The M2 wire-time MCP callable is a PURE PASSTHROUGH — it MUST NOT call any
+  adapter.emit_* or adapter.shape_* methods, or emit ANY telemetry. All
+  telemetry and shaping is exclusively owned by M1 CisternalMiddleware.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from cisternal.telemetry import (
+    init_pipeline,
+    get_pipeline,
+    span,
+    aspan,
+    job_span,
+    status,
+    ExporterBase,
+    _build_record,
+)
+from cisternal.registration.decorator import tool
+from cisternal.registration.errors import CisternalWireError
+from cisternal.registration.registry import clear_registry
+
+# M3 (assets export)
+from cisternal.assets.spec import AssetSpec
+from cisternal.assets.bundle import AssetBundle
+from cisternal.assets.source import registry_assets
+from cisternal.export.base import Emitter
+from cisternal.export.claude import ClaudeEmitter
+from cisternal.export.write import write_bundle
+
+
+def init(
+    log_dir: str | Path | None = None,
+    max_bytes: int = 10_485_760,
+    backup_count: int = 5,
+    exporters: list[ExporterBase] | None = None,
+    heartbeat_interval: float = 30.0,
+) -> None:
+    """Initialize the telemetry pipeline (idempotent).
+
+    Args:
+        log_dir: Directory for JSONL logs. If None, resolves via env vars or defaults to ~/.cisternal/logs.
+        max_bytes: Max file size before rotation (default 10 MB).
+        backup_count: Number of backup files to keep.
+        exporters: Custom exporters. If None, uses JsonlExporter with log_dir.
+        heartbeat_interval: Seconds between liveness heartbeat probes (default 30s).
+    """
+    init_pipeline(
+        log_dir=log_dir,
+        max_bytes=max_bytes,
+        backup_count=backup_count,
+        exporters=exporters,
+        heartbeat_interval=heartbeat_interval,
+    )
+
+
+def emit_event(name: str, **fields: Any) -> None:
+    """Emit a telemetry event.
+
+    Snapshots contextvars on this thread, builds a Record, and enqueues
+    it for non-blocking export. Never raises.
+
+    Args:
+        name: Event name (e.g. 'mcp.call_start').
+        **fields: Event fields (e.g. tool='foo', request_id='xyz').
+    """
+    import time
+
+    pipeline = get_pipeline()
+    if pipeline is None:
+        return
+
+    record = _build_record(name, ts=time.time(), **fields)
+    if record is not None:
+        pipeline.emit(record)
+
+
+def _lazy_import(name: str) -> object:
+    """Lazy re-export for wire and WiredRegistry to defer fastmcp import."""
+    if name == "wire":
+        from cisternal.registration.wired import wire as _wire
+        return _wire
+    if name == "WiredRegistry":
+        from cisternal.registration.wired import WiredRegistry as _WiredRegistry
+        return _WiredRegistry
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __getattr__(name: str) -> object:
+    return _lazy_import(name)
+
+
+__all__ = [
+    # M1 — Telemetry
+    "init",
+    "emit_event",
+    "span",
+    "aspan",
+    "job_span",
+    "status",
+    # M2 — Registration surface
+    "tool",
+    "wire",
+    "WiredRegistry",
+    "CisternalWireError",
+    "clear_registry",
+    # M3 (assets export)
+    "AssetSpec",
+    "AssetBundle",
+    "registry_assets",
+    "Emitter",
+    "ClaudeEmitter",
+    "write_bundle",
+]

cisternal/adapters/__init__.py

@@ -0,0 +1 @@
+"""Consumer adapters: FastMCP v3 middleware, v2 decorator, CLI."""

cisternal/adapters/base.py

@@ -0,0 +1,221 @@
+"""AdapterBase: Consumer-agnostic adapter protocol (spec §3.6, §5.4).
+
+Each adapter owns the event-name set (ALLOWED_NAMES) and the response shape
+for its consumer (shape_ok/shape_error). The MCP wrappers (CisternalMiddleware,
+traced_tool) instantiate an adapter, delegate telemetry emission + shaping to it,
+and never re-raise exceptions (CH-5).
+
+(CH-9) Runtime name guard: emit_start/end/error check that the emitted name is
+in self.ALLOWED_NAMES; on mismatch, calls _swallow_name_error (stderr warn + continue).
+Tests monkeypatch _swallow_name_error to raise AssertionError instead.
+"""
+
+from abc import ABC, abstractmethod
+import json
+import sys
+from typing import Any
+
+from cisternal import emit_event
+
+
+class AdapterBase(ABC):
+    """Abstract base for MCP tool adapters (v3 middleware, v2 decorator, etc.).
+
+    Each subclass defines:
+    - ALLOWED_NAMES: frozenset[str] of event names this adapter may emit.
+    - shape_ok(tool_name, result): Transform success response.
+    - shape_error(tool_name, exc): Transform error response.
+    """
+
+    ALLOWED_NAMES: frozenset[str]
+
+    def emit_start(self, tool_name: str, arg_keys: list[str], request_id: str) -> None:
+        """Emit mcp.call_start event.
+
+        Args:
+            tool_name: Name of the tool being called.
+            arg_keys: Sorted list of argument keys (spec §3.7, §3.8).
+            request_id: Unique request ID for this invocation.
+        """
+        name = "mcp.call_start"
+        if name not in self.ALLOWED_NAMES:
+            self._swallow_name_error(name)
+        emit_event(name, tool=tool_name, arg_keys=arg_keys, request_id=request_id)
+
+    def emit_end(self, tool_name: str, request_id: str, duration_ms: float) -> None:
+        """Emit mcp.call_end event.
+
+        Args:
+            tool_name: Name of the tool that executed.
+            request_id: The request ID from emit_start.
+            duration_ms: Duration of execution in milliseconds.
+        """
+        name = "mcp.call_end"
+        if name not in self.ALLOWED_NAMES:
+            self._swallow_name_error(name)
+        emit_event(name, tool=tool_name, request_id=request_id, duration_ms=duration_ms)
+
+    def emit_error(self, tool_name: str, request_id: str, exc: BaseException) -> None:
+        """Emit mcp.tool_error event.
+
+        Args:
+            tool_name: Name of the tool that raised.
+            request_id: The request ID from emit_start.
+            exc: The exception that was raised.
+        """
+        name = "mcp.tool_error"
+        if name not in self.ALLOWED_NAMES:
+            self._swallow_name_error(name)
+        emit_event(
+            name,
+            tool=tool_name,
+            request_id=request_id,
+            exc_type=type(exc).__name__,
+            exc_msg=str(exc),
+        )
+
+    @abstractmethod
+    def shape_ok(self, tool_name: str, result: Any) -> Any:
+        """Shape a successful tool result for the consumer.
+
+        Args:
+            tool_name: Name of the tool (for context).
+            result: The result returned by the tool.
+
+        Returns:
+            Consumer-specific shaped response (dict, str, or other).
+        """
+        pass
+
+    @abstractmethod
+    def shape_error(self, tool_name: str, exc: BaseException, **fields: Any) -> Any:
+        """Shape an error response for the consumer (never re-raises).
+
+        Args:
+            tool_name: Name of the tool (for context).
+            exc: The exception that was caught.
+            **fields: Optional extra fields for the error envelope.
+
+        Returns:
+            Consumer-specific error shape (dict, str, or other).
+        """
+        pass
+
+    def _swallow_name_error(self, name: str) -> None:
+        """Handle illegal event name: log to stderr and return (warn-and-continue).
+
+        Tests may monkeypatch this to raise AssertionError (AC-NAMEFREEZE-4).
+
+        Args:
+            name: The illegal event name.
+        """
+        print(f"[cisternal] ILLEGAL event name: {name!r}", file=sys.stderr)
+
+
+class BathosAdapter(AdapterBase):
+    """Adapter for bathos v3 middleware.
+
+    Event names (spec §4.2): mcp.call_start, mcp.call_end, mcp.tool_error.
+    Response shape: dict envelope with ok/error_code/error/resolution_hint.
+    """
+
+    ALLOWED_NAMES = frozenset({"mcp.call_start", "mcp.call_end", "mcp.tool_error"})
+
+    def shape_ok(self, tool_name: str, result: Any) -> Any:
+        """Shape success: merge dict results, add envelope fields.
+
+        If result is a dict, spread it and add envelope.
+        Otherwise, return minimal envelope.
+        """
+        if isinstance(result, dict):
+            return {
+                **result,
+                "ok": True,
+                "error_code": None,
+                "error": None,
+                "resolution_hint": None,
+            }
+        return {
+            "ok": True,
+            "error_code": None,
+            "error": None,
+            "resolution_hint": None,
+        }
+
+    def shape_error(self, tool_name: str, exc: BaseException, **fields: Any) -> Any:
+        """Shape error: error envelope with error_code and message."""
+        return {
+            "ok": False,
+            "error_code": "INTERNAL",
+            "error": str(exc),
+            "resolution_hint": "",
+        }
+
+
+class ContemplexAdapter(AdapterBase):
+    """Adapter for contemplex v2 decorator (sync).
+
+    Event names (spec §4.2): mcp.call_start, mcp.call_end, mcp.tool_error.
+    Response shape: passthrough for success; err_envelope for error.
+    """
+
+    ALLOWED_NAMES = frozenset({"mcp.call_start", "mcp.call_end", "mcp.tool_error"})
+
+    def shape_ok(self, tool_name: str, result: Any) -> Any:
+        """Shape success: passthrough result unchanged."""
+        return result
+
+    def shape_error(self, tool_name: str, exc: BaseException, **fields: Any) -> Any:
+        """Shape error: use contemplex err_envelope if available, else fallback.
+
+        Tries to import contemplex.errors; if unavailable, returns basic dict.
+        """
+        try:
+            from contemplex.errors import ErrorCode, err_envelope
+
+            return err_envelope(ErrorCode.INTERNAL, f"{type(exc).__name__}: {exc}")
+        except ImportError:
+            # Fallback if contemplex is not available
+            return {"ok": False, "error_code": "INTERNAL", "error": str(exc)}
+
+
+class XpeririAdapter(AdapterBase):
+    """Adapter for xperiri v2 decorator (sync, JSON-string MCP returns).
+
+    Event names (spec §4.2): mcp.call_start, mcp.call_end, mcp.tool_error.
+    Response shape: JSON string for success and error (xperiri MCP tools return str).
+    """
+
+    ALLOWED_NAMES = frozenset({"mcp.call_start", "mcp.call_end", "mcp.tool_error"})
+
+    def shape_ok(self, tool_name: str, result: Any) -> Any:
+        """Shape success: passthrough str; serialize dict/other to JSON."""
+        if isinstance(result, str):
+            return result
+        return json.dumps(result, sort_keys=True)
+
+    def shape_error(self, tool_name: str, exc: BaseException, **fields: Any) -> Any:
+        """Shape error: JSON string envelope matching xperiri error returns."""
+        payload: dict[str, Any] = {"ok": False, "error": str(exc)}
+        payload.update(fields)
+        return json.dumps(payload, sort_keys=True)
+
+
+class MyxcelAdapter(AdapterBase):
+    """Adapter for myxcel v2 decorator (async MCP tools, dict returns).
+
+    Event names (spec §4.2): mcp.call_start, mcp.call_end, mcp.tool_error.
+    Response shape: dict passthrough; errors use {error, message} per myxcel.mcp_server._tool_error.
+    """
+
+    ALLOWED_NAMES = frozenset({"mcp.call_start", "mcp.call_end", "mcp.tool_error"})
+
+    def shape_ok(self, tool_name: str, result: Any) -> Any:
+        """Shape success: passthrough dict/list results (myxcel in-band errors included)."""
+        if isinstance(result, (dict, list)):
+            return result
+        return {"result": result}
+
+    def shape_error(self, tool_name: str, exc: BaseException, **fields: Any) -> Any:
+        """Shape error: myxcel _tool_error envelope."""
+        return {"error": type(exc).__name__, "message": str(exc)}

cisternal/adapters/cli.py

@@ -0,0 +1,85 @@
+"""Typer CLI timing adapter (spec §4.2, AC-CLI-1).
+
+Provides CliAdapter for Typer CLI commands and timed_command decorator
+to instrument command execution with cli.cmd_start and cli.cmd_end events.
+
+The decorator is CLI-specific: unlike MCP adapters, it re-raises exceptions
+to the CLI, which owns exit codes.
+"""
+
+import functools
+import time
+from typing import Any
+
+from cisternal import emit_event
+from cisternal.adapters.base import AdapterBase
+
+
+class CliAdapter(AdapterBase):
+    """Adapter for Typer CLI commands.
+
+    Event names (spec §4.2): cli.cmd_start, cli.cmd_end.
+    Response shape: passthrough (CLI owns stdout/exit codes).
+    """
+
+    ALLOWED_NAMES = frozenset({"cli.cmd_start", "cli.cmd_end"})
+
+    def shape_ok(self, tool_name: str, result: Any) -> Any:
+        """Shape success: passthrough result (CLI owns output)."""
+        return result
+
+    def shape_error(self, tool_name: str, exc: BaseException, **fields: Any) -> Any:
+        """Shape error: not used by CLI (exceptions re-raise directly)."""
+        return None
+
+
+def timed_command(cmd_name: str | None = None):
+    """Decorator to emit CLI command timing events.
+
+    Emits cli.cmd_start before execution and cli.cmd_end after.
+    On exception: cli.cmd_end with ok=False, exc_type, then re-raises
+    (CLI owns the exit code).
+
+    Args:
+        cmd_name: Optional custom command name. If None, uses function.__name__.
+
+    Returns:
+        Decorator function.
+
+    Example:
+        @timed_command()
+        def my_command(arg1: str):
+            print(f"Running {arg1}")
+            return 0
+
+        @timed_command("custom_name")
+        def another_command():
+            return 0
+    """
+
+    def decorator(fn):
+        name = cmd_name or fn.__name__
+
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            emit_event("cli.cmd_start", cmd=name)
+            t0 = time.monotonic_ns()
+            try:
+                result = fn(*args, **kwargs)
+                duration_ms = (time.monotonic_ns() - t0) / 1e6
+                emit_event("cli.cmd_end", cmd=name, duration_ms=duration_ms, ok=True)
+                return result
+            except Exception as exc:
+                duration_ms = (time.monotonic_ns() - t0) / 1e6
+                emit_event(
+                    "cli.cmd_end",
+                    cmd=name,
+                    duration_ms=duration_ms,
+                    ok=False,
+                    exc_type=type(exc).__name__,
+                )
+                raise
+
+        return wrapper
+
+    return decorator

cisternal/adapters/v2_decorator.py

@@ -0,0 +1,101 @@
+"""traced_tool: FastMCP v2 integration via decorator (spec §3.8).
+
+Double-decorator pattern: outer decorator takes an adapter, inner decorator
+wraps the tool function. On each call, emits telemetry, measures duration,
+and returns a shaped response. Never re-raises exceptions (CH-5).
+
+Sync and async originals are supported: async tools get an ``async def`` wrapper
+that awaits the original (mirrors :func:`cisternal.registration.shim.dispatch`).
+
+(CH-10, AC-MCP-4) Token management: set/reset with ValueError guard.
+"""
+
+import asyncio
+import functools
+import time
+import uuid
+from typing import Any, Callable, TypeVar
+
+from cisternal.telemetry.context import mcp_request_id_var
+from cisternal.adapters.base import AdapterBase
+
+T = TypeVar("T")
+
+
+def _reset_request_token(token: Any) -> None:
+    try:
+        mcp_request_id_var.reset(token)
+    except ValueError:
+        # AC-MCP-4: Token from different context; swallow.
+        pass
+
+
+def traced_tool(
+    adapter: AdapterBase,
+) -> Callable[[Callable[..., T]], Callable[..., Any]]:
+    """Decorator to wrap a FastMCP v2 tool with telemetry.
+
+    Usage:
+        @traced_tool(ContemplexAdapter())
+        def my_tool(arg: str) -> str:
+            return f"result: {arg}"
+
+        @traced_tool(MyxcelAdapter())
+        async def mount_project(remote: str, project: str) -> dict:
+            ...
+
+    Args:
+        adapter: AdapterBase instance (e.g., BathosAdapter(), ContemplexAdapter()).
+
+    Returns:
+        Decorator function that wraps the tool (sync or async).
+    """
+
+    def decorator(fn: Callable[..., T]) -> Callable[..., Any]:
+        if asyncio.iscoroutinefunction(fn):
+
+            @functools.wraps(fn)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                request_id = uuid.uuid4().hex
+                token = mcp_request_id_var.set(request_id)
+                arg_keys = sorted(kwargs.keys())  # CH-6: kwargs only (parity caveat)
+                adapter.emit_start(fn.__name__, arg_keys, request_id)
+                t0 = time.monotonic_ns()
+
+                try:
+                    result = await fn(*args, **kwargs)
+                    adapter.emit_end(
+                        fn.__name__, request_id, (time.monotonic_ns() - t0) / 1e6
+                    )
+                    return adapter.shape_ok(fn.__name__, result)
+                except Exception as exc:
+                    adapter.emit_error(fn.__name__, request_id, exc)
+                    return adapter.shape_error(fn.__name__, exc)
+                finally:
+                    _reset_request_token(token)
+
+            return async_wrapper
+
+        @functools.wraps(fn)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            request_id = uuid.uuid4().hex
+            token = mcp_request_id_var.set(request_id)
+            arg_keys = sorted(kwargs.keys())  # CH-6: kwargs only (parity caveat)
+            adapter.emit_start(fn.__name__, arg_keys, request_id)
+            t0 = time.monotonic_ns()
+
+            try:
+                result = fn(*args, **kwargs)
+                adapter.emit_end(
+                    fn.__name__, request_id, (time.monotonic_ns() - t0) / 1e6
+                )
+                return adapter.shape_ok(fn.__name__, result)
+            except Exception as exc:
+                adapter.emit_error(fn.__name__, request_id, exc)
+                return adapter.shape_error(fn.__name__, exc)
+            finally:
+                _reset_request_token(token)
+
+        return sync_wrapper
+
+    return decorator

cisternal/adapters/v3_middleware.py

@@ -0,0 +1,64 @@
+"""CisternalMiddleware: FastMCP v3 integration via middleware hook (spec §3.7).
+
+Middleware fires on_call_tool for each tool call, wrapping the tool execution
+with telemetry: emit_start, measure duration, emit_end or emit_error, return
+shaped envelope. Never re-raises exceptions to the transport (CH-5).
+
+(CH-10, AC-MCP-4) Token management: set/reset with ValueError guard for
+cross-context token resets (possible in asyncio context copy scenarios).
+"""
+
+import time
+import uuid
+from typing import Any
+
+from fastmcp.server.middleware.middleware import Middleware, MiddlewareContext
+from cisternal.telemetry.context import mcp_request_id_var
+from cisternal.adapters.base import BathosAdapter
+
+
+class CisternalMiddleware(Middleware):
+    """Middleware for FastMCP v3 servers.
+
+    Wires via: server.add_middleware(CisternalMiddleware()).
+    Fires on every tools/call request (spec §3.7).
+    """
+
+    async def on_call_tool(self, context: MiddlewareContext, call_next: Any) -> Any:
+        """Intercept tool call, emit telemetry, and return shaped response.
+
+        Args:
+            context: MiddlewareContext with .message = CallToolRequestParams.
+                    .message.name = tool name (str)
+                    .message.arguments = tool arguments (dict|None)
+            call_next: Async callable to invoke the actual tool.
+
+        Returns:
+            Shaped response (dict envelope with ok/error) per BathosAdapter.
+            Never raises; exceptions caught and returned as error envelopes.
+        """
+        tool_name = context.message.name
+        arguments = context.message.arguments or {}
+        arg_keys = sorted(arguments.keys())  # CH-6: client-supplied keys only
+        request_id = uuid.uuid4().hex
+
+        # Set mcp_request_id in context for this call
+        token = mcp_request_id_var.set(request_id)
+        adapter = BathosAdapter()
+        adapter.emit_start(tool_name, arg_keys, request_id)
+        t0 = time.monotonic_ns()
+
+        try:
+            result = await call_next(context)
+            adapter.emit_end(tool_name, request_id, (time.monotonic_ns() - t0) / 1e6)
+            return adapter.shape_ok(tool_name, result)
+        except Exception as exc:
+            adapter.emit_error(tool_name, request_id, exc)
+            return adapter.shape_error(tool_name, exc)
+        finally:
+            try:
+                mcp_request_id_var.reset(token)
+            except ValueError:
+                # AC-MCP-4: Token was created in a different Context (e.g., via
+                # copy_context().run() in asyncio). Swallow and continue.
+                pass

cisternal/assets/__init__.py

@@ -0,0 +1,51 @@
+"""cisternal.assets — Agent-asset IR (data model) and registry source.
+
+Public API:
+    AssetSpec      — frozen dataclass: one tool's asset metadata.
+    BundleMetadata — frozen dataclass: name/version/description for a bundle.
+    CommandAsset   — frozen dataclass: one command asset.
+    McpAsset       — frozen dataclass: one MCP server entry.
+    SkillAsset     — frozen dataclass: one skill asset (M3.1a).
+    AgentAsset     — frozen dataclass: one agent asset (M3.1a).
+    HookSpecAsset  — frozen dataclass: one hook spec asset (M3.1a).
+    LoadReport     — load result with bundle, warnings, conflicts (M3.1a).
+    AssetBundle    — frozen dataclass: full bundle; sorted collections.
+    registry_assets — Extract AssetSpec tuples from a named registry partition.
+"""
+
+from cisternal.assets.spec import AssetSpec
+from cisternal.assets.bundle import (
+    AgentAsset,
+    AssetBundle,
+    BundleMetadata,
+    CommandAsset,
+    HookSpecAsset,
+    LoadReport,
+    McpAsset,
+    SkillAsset,
+)
+from cisternal.assets.capability import Capability, resolve_model_hint, resolve_tools
+from cisternal.assets.composite import CompositeAssetSource
+from cisternal.assets.manifest import ManifestAssetSource
+from cisternal.assets.protocol import AssetSource
+from cisternal.assets.source import registry_assets, registry_bundle
+
+__all__ = [
+    "AssetSpec",
+    "AgentAsset",
+    "AssetBundle",
+    "AssetSource",
+    "BundleMetadata",
+    "Capability",
+    "CommandAsset",
+    "CompositeAssetSource",
+    "HookSpecAsset",
+    "LoadReport",
+    "ManifestAssetSource",
+    "McpAsset",
+    "SkillAsset",
+    "registry_assets",
+    "registry_bundle",
+    "resolve_model_hint",
+    "resolve_tools",
+]