code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/meta_oauth/utils.py

@@ -0,0 +1,252 @@
+"""Credential, device-flow, and model-catalog helpers for Meta Muse OAuth."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import requests
+
+from .config import (
+    FALLBACK_MODELS,
+    META_OAUTH_CONFIG,
+    get_muse_auth_path,
+    get_token_storage_path,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _read_json(path: Path) -> dict[str, Any] | None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else None
+    except FileNotFoundError:
+        return None
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Could not read Meta credentials from %s: %s", path, exc)
+        return None
+
+
+def _validate_url(url: str, allowed_host: str) -> str:
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").lower()
+    if parsed.scheme != "https" or host != allowed_host:
+        raise ValueError(f"Unexpected Meta endpoint: {url}")
+    return url.rstrip("/")
+
+
+def validate_api_base_url(url: str) -> str:
+    """Allow only Meta's HTTPS Model API front door."""
+    return _validate_url(url, "api.meta.ai")
+
+
+def validate_verification_url(url: str) -> str:
+    """Allow HTTPS verification pages hosted by Meta."""
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").lower()
+    if parsed.scheme != "https" or not (
+        host == "meta.com" or host.endswith(".meta.com")
+    ):
+        raise ValueError(f"Unexpected Meta verification URL: {url}")
+    return url
+
+
+def _normalize_credentials(data: dict[str, Any], source: str) -> dict[str, Any] | None:
+    api_key = data.get("api_key")
+    if not isinstance(api_key, str) or not api_key:
+        return None
+    try:
+        base_url = validate_api_base_url(
+            str(data.get("api_base_url") or META_OAUTH_CONFIG["api_base_url"])
+        )
+    except ValueError as exc:
+        logger.warning("Ignoring invalid Meta credential endpoint: %s", exc)
+        return None
+    normalized = dict(data)
+    normalized.update({"api_key": api_key, "api_base_url": base_url, "_source": source})
+    return normalized
+
+
+def load_credentials() -> dict[str, Any] | None:
+    """Load Meta credentials using env, Code Puppy, then Muse CLI precedence."""
+    env_key = os.getenv("META_API_KEY")
+    if env_key:
+        return {
+            "api_key": env_key,
+            "api_base_url": META_OAUTH_CONFIG["api_base_url"],
+            "_source": "environment",
+        }
+
+    own = _read_json(get_token_storage_path())
+    if own:
+        normalized = _normalize_credentials(own, "code-puppy")
+        if normalized:
+            return normalized
+
+    muse = _read_json(get_muse_auth_path())
+    providers = muse.get("providers") if muse else None
+    provider = providers.get("meta") if isinstance(providers, dict) else None
+    if isinstance(provider, dict):
+        return _normalize_credentials(provider, "muse")
+    return None
+
+
+def save_credentials(credentials: dict[str, Any]) -> bool:
+    """Atomically save private Meta credentials with mode 0600."""
+    if not credentials.get("api_key"):
+        raise ValueError("Meta credentials require an api_key")
+    destination = get_token_storage_path()
+    payload = {key: value for key, value in credentials.items() if key != "_source"}
+    temporary_path: str | None = None
+    try:
+        fd, temporary_path = tempfile.mkstemp(
+            prefix=".meta_oauth.", dir=destination.parent
+        )
+        os.fchmod(fd, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle, indent=2)
+            handle.write("\n")
+        os.replace(temporary_path, destination)
+        destination.chmod(0o600)
+        return True
+    except Exception as exc:  # noqa: BLE001
+        logger.error("Failed to save Meta OAuth credentials: %s", exc)
+        if temporary_path:
+            Path(temporary_path).unlink(missing_ok=True)
+        return False
+
+
+def _problem(response: requests.Response, fallback: str) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        return fallback
+    if not isinstance(payload, dict):
+        return fallback
+    return str(
+        payload.get("detail")
+        or payload.get("title")
+        or payload.get("error")
+        or fallback
+    )
+
+
+def request_device_authorization() -> dict[str, Any]:
+    """Start Meta's RFC 8628 device authorization flow."""
+    base = _validate_url(str(META_OAUTH_CONFIG["auth_base_url"]), "auth.meta.com")
+    response = requests.post(
+        base + str(META_OAUTH_CONFIG["device_authorization_path"]),
+        data={"client_id": META_OAUTH_CONFIG["client_id"]},
+        headers={"Accept": "application/json", "User-Agent": "code-puppy/meta-oauth"},
+        timeout=META_OAUTH_CONFIG["request_timeout"],
+        allow_redirects=False,
+    )
+    if not response.ok:
+        raise RuntimeError(
+            _problem(response, f"Device authorization failed ({response.status_code})")
+        )
+    payload = response.json()
+    if not isinstance(payload, dict):
+        raise RuntimeError("Meta device authorization returned invalid JSON")
+    verification_url = payload.get("verification_uri_complete") or payload.get(
+        "verification_uri"
+    )
+    if verification_url:
+        validate_verification_url(str(verification_url))
+    return payload
+
+
+def poll_device_token(device_code: str) -> tuple[str, dict[str, Any]]:
+    """Perform one device-token poll and return its OAuth state and payload."""
+    base = _validate_url(str(META_OAUTH_CONFIG["auth_base_url"]), "auth.meta.com")
+    response = requests.post(
+        base + str(META_OAUTH_CONFIG["device_token_path"]),
+        data={
+            "grant_type": META_OAUTH_CONFIG["device_code_grant"],
+            "device_code": device_code,
+            "client_id": META_OAUTH_CONFIG["client_id"],
+        },
+        headers={"Accept": "application/json", "User-Agent": "code-puppy/meta-oauth"},
+        timeout=META_OAUTH_CONFIG["request_timeout"],
+        allow_redirects=False,
+    )
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise RuntimeError("Meta token endpoint returned invalid JSON") from exc
+    if response.ok and isinstance(payload, dict) and payload.get("access_token"):
+        return "authorized", payload
+    if isinstance(payload, dict):
+        return str(payload.get("error") or f"http_{response.status_code}"), payload
+    return f"http_{response.status_code}", {}
+
+
+def mint_api_credentials(access_token: str) -> dict[str, Any]:
+    """Exchange a Meta account token for a Model API credential."""
+    response = requests.post(
+        _validate_url(str(META_OAUTH_CONFIG["mint_url"]), "api.meta.ai"),
+        headers={
+            "Accept": "application/json",
+            "Authorization": f"Bearer {access_token}",
+            "User-Agent": "code-puppy/meta-oauth",
+            "x-api-version": META_OAUTH_CONFIG["api_version"],
+        },
+        timeout=META_OAUTH_CONFIG["request_timeout"],
+        allow_redirects=False,
+    )
+    if not response.ok:
+        raise RuntimeError(
+            _problem(response, f"Meta key mint failed ({response.status_code})")
+        )
+    payload = response.json()
+    if not isinstance(payload, dict) or not payload.get("api_key"):
+        raise RuntimeError("Meta key mint returned no API key")
+    payload["api_base_url"] = validate_api_base_url(
+        str(payload.get("base_url") or payload.get("api_base_url") or "")
+    )
+    payload.pop("base_url", None)
+    return payload
+
+
+def discover_models(credentials: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    """Fetch Meta's Muse catalogue and convert it to Code Puppy model specs."""
+    response = requests.get(
+        _validate_url(str(META_OAUTH_CONFIG["catalog_url"]), "api.meta.ai"),
+        headers={
+            "Accept": "application/json",
+            "Authorization": f"Bearer {credentials['api_key']}",
+            "User-Agent": "code-puppy/meta-oauth",
+            "x-api-version": META_OAUTH_CONFIG["api_version"],
+        },
+        timeout=META_OAUTH_CONFIG["request_timeout"],
+    )
+    if not response.ok:
+        raise RuntimeError(
+            _problem(response, f"Meta model discovery failed ({response.status_code})")
+        )
+
+    payload = response.json()
+    rows = payload.get("data", []) if isinstance(payload, dict) else []
+    models: dict[str, dict[str, Any]] = {}
+    for row in rows:
+        if not isinstance(row, dict) or not isinstance(row.get("id"), str):
+            continue
+        metadata = row.get("metadata")
+        details = metadata.get("muse-code") if isinstance(metadata, dict) else None
+        if not isinstance(details, dict) or details.get("is_hidden") is True:
+            continue
+        raw_limits = details.get("limit")
+        limits = raw_limits if isinstance(raw_limits, dict) else {}
+        models[row["id"]] = {
+            "context_length": int(limits.get("context") or 128_000),
+            "supported_settings": ["reasoning_effort"]
+            if details.get("reasoning")
+            else [],
+        }
+    return models or dict(FALLBACK_MODELS)

code_puppy_core_plugins/namespace_skill_search/README.md

@@ -0,0 +1,118 @@
+# namespace_skill_search
+
+Model-agnostic reimplementation of OpenAI's namespace + `tool_search`
+pattern, applied to Code Puppy's skill catalog.
+
+## Why this exists
+
+Frontier labs converge on one shape for large tool/skill catalogs:
+**one grouping layer + on-demand search**, instead of a flat list of
+every item injected into the system prompt upfront.
+
+- Anthropic's shipped Tool Search Tool: flat on-demand search,
+  `defer_loading: true`, results injected at end of context to preserve
+  prompt caching. ~85% token reduction, measurable accuracy gains on
+  internal MCP evals ([Anthropic engineering blog, Nov 2025](https://www.anthropic.com/engineering/advanced-tool-use)).
+  Note: our `load_prompt` fragment lands earlier in the assembled prompt
+  (layer 2 of `base_agent.py::get_full_system_prompt`) than the built-in
+  flat skill list it replaces did (layer 6, dead last). We prioritized
+  additive-safety (`load_prompt` can't collide with another plugin's
+  fragment; `get_model_system_prompt` can) over exactly matching
+  Anthropic's end-of-context caching position. If cache-hit rate on the
+  namespace block ever matters in practice, moving it later is a
+  follow-up, not a redesign.
+- OpenAI's shipped `tool_search`: same on-demand mechanic, PLUS an
+  explicit **namespace** grouping layer above it
+  (`{"type": "namespace", "name": "crm", "tools": [...]}`), because
+  "our models have primarily been trained to search those surfaces" —
+  namespaces outperform bare deferred functions in their own docs
+  ([OpenAI tool-search guide](https://developers.openai.com/api/docs/guides/tools-tool-search)).
+  They recommend keeping each namespace under 10 functions.
+- Neither ships a deep multi-level tree. One grouping layer is the norm;
+  true hierarchical (server -> tool) routing exists mainly in academic
+  work (e.g. MCP-Zero, arXiv:2506.01056), not shipped production
+  features.
+
+## What we copied, and why
+
+We copied OpenAI's shape (namespace + search) rather than Anthropic's
+(flat search only), because the namespace layer is a genuine win once a
+catalog gets into the hundreds of items. But OpenAI's mechanism depends
+on a model-specific API flag (`defer_loading`) that only exists for
+their own models. This plugin gets the same effect through Code Puppy's
+model-agnostic plugin hooks instead, so it behaves identically on
+Claude, GPT, Gemini, or any custom endpoint wired through
+`ModelFactory` — no provider-specific request fields required.
+
+## How it works
+
+1. **Namespace derivation** (`namespaces.py`) — a skill's namespace is
+   its first `tags:` entry (untagged skills land in `General`). No new
+   frontmatter field, no migration of existing `SKILL.md` files required.
+2. **Compact directory injection** (`load_prompt` hook) — instead of one
+   line per skill (the built-in behavior when
+   `frontmatter_in_system_prompt` is on), the system prompt gets one
+   line per *namespace* with a 3-item preview and a count. `load_prompt`
+   fragments from every plugin are newline-joined by `base_agent.py`, so
+   this is safely additive — it cannot collide with or overwrite another
+   plugin's fragment the way `get_model_system_prompt` callbacks can
+   (see "What we deliberately avoided" below).
+3. **Drill-down tool** (`browse_skill_namespace`) — one tool, three modes:
+   - no args -> namespace directory (same content as the prompt block)
+   - `namespace="X"` -> every skill in that namespace
+   - `query="..."` -> keyword search across all namespaces
+4. **Flat list turned off** — the first time this plugin ever starts up
+   (via a `startup` callback, not an import-time side effect — see
+   "What we deliberately avoided" below), it calls
+   `set_frontmatter_in_system_prompt(False)` via the public config API
+   (`code_puppy_core_plugins.agent_skills.config`) so the built-in per-skill
+   flat list doesn't also render alongside the namespace directory.
+
+   **This is a real, persisted config write, not an in-memory toggle.**
+   Enabling this plugin once permanently sets
+   `frontmatter_in_system_prompt=false` in `puppy.cfg`. A dedicated
+   marker key (`namespace_skill_search_frontmatter_migrated`) records
+   that the flip already happened, so if you re-enable it afterwards
+   with `/skills frontmatter on`, we never touch the flag again — your
+   choice sticks across restarts. But if you disable or remove this
+   plugin entirely, the flag stays `false`; nothing restores the flat
+   list automatically. Run `/skills frontmatter on` yourself if you want
+   it back.
+
+## What we deliberately avoided
+
+- **No config mutation at import time.** The `frontmatter_in_system_prompt`
+  flip runs inside a `register_callback("startup", ...)` handler (matching
+  the same pattern as `code_puppy/plugins/theme`'s
+  `_apply_default_theme_on_first_run`), not as top-level code in
+  `register_callbacks.py`. Import-time disk writes are a landmine: they
+  fire on every import (including test collection), can't be unit-tested
+  without `importlib.reload` gymnastics, and race with plugin load order
+  in ways a callback doesn't. A dedicated migration marker (see above)
+  makes the one-time-ness explicit and testable instead of relying on
+  "only flip it when the shared flag is currently True" as the sole
+  signal.
+- **No `get_model_system_prompt` callback.** That phase is
+  last-write-wins across plugins — `model_utils.prepare_prompt_for_model`
+  threads augmenter results sequentially and the *last* callback
+  processed wins on any key both callbacks set. A second plugin
+  registering on that phase risks silently clobbering the built-in
+  `agent_skills` plugin's contribution. `load_prompt` avoids that
+  failure mode entirely by design (simple concatenation, no merge
+  conflicts possible).
+- **No vector DB / embeddings.** Namespace + substring search is enough
+  at this scale; see Anthropic's own `tool_search_with_embeddings.ipynb`
+  cookbook, which only recommends embeddings above ~100 tools with high
+  semantic overlap between items.
+- **No deep multi-level tree** (namespace -> subnamespace -> skill). No
+  frontier lab ships that in production; one grouping layer is the norm.
+- **No new tool duplicating `list_or_search_skills`.** That tool still
+  exists and still works for flat queries; `browse_skill_namespace` is
+  additive, not a replacement.
+
+## Sizing signal
+
+OpenAI's own docs recommend keeping each namespace under 10 functions
+for best token efficiency. We don't enforce this (skills aren't ours to
+re-tag), but the directory block flags any namespace over that
+threshold as `oversized namespace` so it's visible instead of silent.

code_puppy_core_plugins/namespace_skill_search/__init__.py

@@ -0,0 +1,15 @@
+"""namespace_skill_search — OpenAI-style namespace + on-demand search for skills.
+
+Model-agnostic reimplementation of the pattern OpenAI ships as its
+`tool_search` + namespaces feature. OpenAI's version relies on a
+model-provider-specific `defer_loading` API flag; this plugin gets the same
+effect — one grouping layer + on-demand search instead of a flat, unranked
+skill list baked into every system prompt — using only Code Puppy's
+model-agnostic plugin hooks, so it behaves identically on Claude, GPT,
+Gemini, or any custom endpoint wired through `ModelFactory`.
+
+See README.md in this directory for the full design rationale, including
+what frontier labs (Anthropic, OpenAI, Google) actually ship in production
+vs. what's academic-only, and why this plugin copies OpenAI's shape
+specifically.
+"""

code_puppy_core_plugins/namespace_skill_search/namespaces.py

@@ -0,0 +1,125 @@
+"""Namespace derivation and summary-block rendering.
+
+A "namespace" is a skill's first tag (falling back to "General" for
+untagged skills). No new frontmatter field, no schema migration — every
+skill that already has a `tags:` entry in its SKILL.md slots in for free.
+
+This mirrors OpenAI's namespace grouping (`{"type": "namespace", "name":
+"crm", "tools": [...]}`) as a plain-data structure instead of a
+model-provider-specific request field.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from typing import Dict, List, Optional
+
+from code_puppy_core_plugins.agent_skills.enabled_skills import (
+    list_enabled_skill_metadata,
+)
+from code_puppy_core_plugins.agent_skills.metadata import SkillMetadata
+
+_DEFAULT_NAMESPACE = "General"
+
+# OpenAI recommends fewer than 10 functions per namespace; flag oversized
+# namespaces without re-tagging skills we don't own.
+_RECOMMENDED_MAX_PER_NAMESPACE = 10
+
+
+def _namespace_for(skill: SkillMetadata) -> str:
+    """First tag wins; untagged skills land in the General bucket."""
+    if skill.tags:
+        return skill.tags[0].strip() or _DEFAULT_NAMESPACE
+    return _DEFAULT_NAMESPACE
+
+
+def build_namespaces() -> Dict[str, List[SkillMetadata]]:
+    """Group every enabled skill by namespace.
+
+    Grouping is case-insensitive: skills tagged "finance" and "Finance"
+    land in the same bucket. Without this, the directory would silently
+    fragment into two separate namespace entries that look distinct to
+    the model but are semantically the same category, and a
+    case-sensitive drill-down would only ever surface one of them (see
+    `search_tool.py`'s case-insensitive `namespace=` lookup, which
+    depends on this function never producing two keys that only differ
+    by case). The *first* casing encountered wins for display purposes,
+    which keeps behavior deterministic for a given skill-discovery order.
+
+    Returns an empty dict if skills are globally disabled or none exist —
+    callers should treat that as "nothing to show", not an error.
+    """
+    namespaces: Dict[str, List[SkillMetadata]] = {}
+    display_names: Dict[str, str] = {}
+    for skill in list_enabled_skill_metadata():
+        raw_ns = _namespace_for(skill)
+        key = raw_ns.lower()
+        display = display_names.setdefault(key, raw_ns)
+        namespaces.setdefault(display, []).append(skill)
+    return namespaces
+
+
+def _duplicate_skill_names(namespaces: Dict[str, List[SkillMetadata]]) -> List[str]:
+    """Names shared by 2+ skills, regardless of namespace.
+
+    Nothing in `agent_skills` enforces globally-unique skill names, and
+    grouping by namespace makes a collision more visible (two entries
+    with the same name can now show up side-by-side across namespace
+    listings), not less. We can't resolve the ambiguity here -- that's an
+    `agent_skills`-level concern -- but we can at least flag it instead
+    of silently presenting the model with two indistinguishable
+    `activate_skill(name)` targets.
+    """
+    counts = Counter(s.name for skills in namespaces.values() for s in skills)
+    return sorted(name for name, count in counts.items() if count > 1)
+
+
+def build_namespace_summary() -> Optional[str]:
+    """Render the compact `load_prompt` block replacing the flat skill list.
+
+    Format is intentionally terse — this is the ONE thing that always
+    lands in the system prompt, so every line here is context budget spent
+    on every single turn.
+    """
+    namespaces = build_namespaces()
+    if not namespaces:
+        return None
+
+    total = sum(len(v) for v in namespaces.values())
+    lines = [
+        "## Skill Namespaces",
+        f"{total} skills available across {len(namespaces)} namespaces. "
+        "Individual skills are NOT listed here — browse or search instead.",
+        "",
+    ]
+
+    for ns, skills in sorted(namespaces.items(), key=lambda kv: -len(kv[1])):
+        preview = ", ".join(s.name for s in skills[:3])
+        remainder = len(skills) - 3
+        if remainder > 0:
+            preview += f", +{remainder} more"
+        flag = (
+            "  oversized namespace"
+            if len(skills) > _RECOMMENDED_MAX_PER_NAMESPACE
+            else ""
+        )
+        lines.append(f"- **{ns}** ({len(skills)}){flag}: {preview}")
+
+    lines.append("")
+    lines.append(
+        "Call `browse_skill_namespace()` with no arguments to see this same "
+        "directory again, `browse_skill_namespace(namespace=...)` to list "
+        "every skill in one namespace, or `browse_skill_namespace(query=...)` "
+        "to keyword-search across all namespaces. Then `activate_skill(name)` "
+        "to load full instructions."
+    )
+
+    duplicates = _duplicate_skill_names(namespaces)
+    if duplicates:
+        lines.append(
+            "Note: these skill names appear more than once across "
+            f"namespaces, so `activate_skill(name)` may be ambiguous: "
+            f"{', '.join(duplicates)}."
+        )
+
+    return "\n".join(lines)

code_puppy_core_plugins/namespace_skill_search/register_callbacks.py

@@ -0,0 +1,99 @@
+"""Entry point: registers all hooks for the namespace_skill_search plugin.
+
+Three hooks:
+
+1. `startup`        -> one-time migration that turns off the built-in flat
+                       skill list (see `_maybe_disable_frontmatter` below).
+2. `load_prompt`    -> injects the compact namespace directory (a few lines
+                       per namespace instead of one line per skill).
+                       Fragments from every plugin are simply
+                       newline-joined by base_agent.py, so this coexists
+                       safely with any other plugin's fragment.
+3. `register_tools` -> adds `browse_skill_namespace` as a real tool, wired
+                       to every agent automatically via
+                       `register_agent_tools`.
+
+We deliberately do NOT touch `get_model_system_prompt` (that's where the
+built-in flat skill list gets injected, and where a *second* callback on
+that same phase would silently clobber the first one's output — see
+`model_utils.prepare_prompt_for_model`: augmenter results are threaded
+through sequentially and the *last* one processed wins on any key they
+both set). Instead we turn the flat list off via the public config API
+and let our `load_prompt` fragment be the only skills-summary content in
+the prompt.
+"""
+
+import logging
+
+from code_puppy.callbacks import register_callback
+from code_puppy.config import get_value, set_config_value
+from code_puppy_core_plugins.agent_skills.config import (
+    get_frontmatter_in_system_prompt,
+    set_frontmatter_in_system_prompt,
+)
+
+from .namespaces import build_namespace_summary
+from .search_tool import register_browse_skill_namespace
+
+logger = logging.getLogger(__name__)
+
+# Own marker distinguishes this plugin's one-time migration from a user's later
+# `/skills frontmatter on`; flip the shared flag once, then never override it.
+_MIGRATION_MARKER_KEY = "namespace_skill_search_frontmatter_migrated"
+
+
+def _maybe_disable_frontmatter() -> None:
+    """One-time migration: turn off the built-in flat per-skill list.
+
+    Runs on the `startup` callback (not at import time) so it is:
+    - testable in isolation (call this function directly with mocked
+      config, same pattern as `theme._apply_default_theme_on_first_run`);
+    - not repeated on every module import (`startup` callbacks fire once
+      per process, same as any other plugin);
+    - a single, auditable point of config mutation rather than an
+      import-time side effect.
+
+    Only ever flips the shared `frontmatter_in_system_prompt` flag from
+    True -> False, and only the first time this plugin ever starts up. A
+    user who runs `/skills frontmatter on` afterwards keeps that choice
+    forever — the marker means we never re-evaluate `get_value` for this
+    decision again.
+    """
+    if get_value(_MIGRATION_MARKER_KEY):
+        return
+
+    if get_frontmatter_in_system_prompt():
+        set_frontmatter_in_system_prompt(False)
+        logger.info(
+            "namespace_skill_search: disabled flat skill-list frontmatter "
+            "(one-time migration); namespace directory + "
+            "browse_skill_namespace tool take over. Run `/skills "
+            "frontmatter on` to restore the flat list."
+        )
+
+    set_config_value(_MIGRATION_MARKER_KEY, "true")
+
+
+def _on_load_prompt():
+    return build_namespace_summary()
+
+
+def _register_tools():
+    return [
+        {
+            "name": "browse_skill_namespace",
+            "register_func": register_browse_skill_namespace,
+        }
+    ]
+
+
+def _advertise_to_all_agents(agent_name=None):
+    return ["browse_skill_namespace"]
+
+
+register_callback("startup", _maybe_disable_frontmatter)
+register_callback("load_prompt", _on_load_prompt)
+register_callback("register_tools", _register_tools)
+register_callback("register_agent_tools", _advertise_to_all_agents)
+
+logger.info("namespace_skill_search plugin loaded")