@maudecode/talaria-web 0.0.0

package/sidecar/talaria_sidecar/methods/providers.py

@@ -0,0 +1,241 @@
+"""``providers.*`` and ``models.*``: the Agent's provider registry, credentials,
+runtime resolution, model catalogs, and model metadata.
+
+The WebUI's provider catalog logic (static tables, picker labels, caches)
+moves to the TypeScript server; this namespace exposes the Agent primitives it
+composes: ``hermes_cli.auth``, ``hermes_cli.models``, ``hermes_cli.runtime_provider``,
+``agent.credential_pool``, ``agent.model_metadata``, ``agent.models_dev``.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import logging
+from typing import Any
+
+from ..errors import InvalidParams, RpcError
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+
+log = logging.getLogger("talaria_sidecar.providers")
+
+
+def _plain(value: Any) -> Any:
+    """JSON-safe projection of registry objects (dataclasses, namespaces, sets)."""
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        return {k: _plain(v) for k, v in dataclasses.asdict(value).items()}
+    if isinstance(value, dict):
+        return {str(k): _plain(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple, set, frozenset)):
+        return [_plain(v) for v in value]
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    if hasattr(value, "__dict__"):
+        return {k: _plain(v) for k, v in vars(value).items() if not k.startswith("_")}
+    return str(value)
+
+
+def registry() -> dict[str, dict]:
+    try:
+        from hermes_cli.auth import PROVIDER_REGISTRY
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"provider registry unavailable: {exc}", condition="providers_unavailable") from exc
+    out = {}
+    for pid, cfg in PROVIDER_REGISTRY.items():
+        row = _plain(cfg)
+        if isinstance(row, dict):
+            out[str(pid)] = row
+    return out
+
+
+def auth_status(provider_id: str | None) -> dict:
+    try:
+        from hermes_cli.auth import get_auth_status
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"auth status unavailable: {exc}", condition="providers_unavailable") from exc
+    try:
+        status = get_auth_status(provider_id or None)
+    except Exception as exc:  # noqa: BLE001
+        log.debug("get_auth_status(%r) failed", provider_id, exc_info=True)
+        return {"logged_in": False, "error": f"{type(exc).__name__}: {exc}"}
+    return _plain(status) if isinstance(status, dict) else {"logged_in": bool(status)}
+
+
+def model_ids(provider_id: str, *, force_refresh: bool) -> list[str]:
+    try:
+        from hermes_cli.models import provider_model_ids
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"model catalog unavailable: {exc}", condition="providers_unavailable") from exc
+    try:
+        ids = provider_model_ids(provider_id, force_refresh=force_refresh)
+    except TypeError:
+        ids = provider_model_ids(provider_id)
+    except Exception:  # noqa: BLE001
+        log.debug("provider_model_ids(%r) failed", provider_id, exc_info=True)
+        return []
+    return [str(m) for m in (ids or []) if m]
+
+
+def resolve_runtime(*, requested: str | None, api_key: str | None, base_url: str | None, target_model: str | None) -> dict:
+    try:
+        from hermes_cli.runtime_provider import format_runtime_provider_error, resolve_runtime_provider
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"runtime provider unavailable: {exc}", condition="providers_unavailable") from exc
+    try:
+        runtime = resolve_runtime_provider(requested=requested or None, explicit_api_key=api_key or None, explicit_base_url=base_url or None, target_model=target_model or None)
+    except Exception as exc:  # noqa: BLE001
+        try:
+            message = format_runtime_provider_error(exc)
+        except Exception:  # noqa: BLE001
+            message = str(exc)
+        raise RpcError(message, condition="credential_missing", data={"error_type": type(exc).__name__})
+    return _plain(runtime) if isinstance(runtime, dict) else {"runtime": _plain(runtime)}
+
+
+def credential_pool(provider_id: str) -> dict:
+    """Credential-pool entries for the profile, secrets stripped (api/config.py::_pool_entry_payloads)."""
+    try:
+        from agent.credential_pool import load_pool
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"credential pool unavailable: {exc}", condition="providers_unavailable") from exc
+    try:
+        pool = load_pool(provider_id)
+    except Exception:  # noqa: BLE001
+        log.debug("load_pool(%r) failed", provider_id, exc_info=True)
+        return {"available": False, "strategy": "", "entries": []}
+    if pool is None:
+        return {"available": False, "strategy": "", "entries": []}
+    entries_fn = getattr(pool, "entries", None)
+    try:
+        raw_entries = list(entries_fn()) if callable(entries_fn) else list(entries_fn or [])
+    except Exception:  # noqa: BLE001
+        raw_entries = []
+    entries = []
+    for entry in raw_entries:
+        if hasattr(entry, "to_dict") and callable(entry.to_dict):
+            payload = entry.to_dict()
+        elif isinstance(entry, dict):
+            payload = dict(entry)
+        else:
+            try:
+                payload = dict(vars(entry))
+            except TypeError:
+                payload = {}
+        payload = _plain(payload) if isinstance(payload, dict) else {}
+        payload.setdefault("source", str(getattr(entry, "source", "") or ""))
+        payload.setdefault("label", str(getattr(entry, "label", "") or ""))
+        payload.setdefault("key_source", str(getattr(entry, "key_source", "") or ""))
+        for attr in ("base_url", "inference_base_url"):
+            value = getattr(entry, attr, None)
+            if value:
+                payload[attr] = value
+        for secret in ("api_key", "runtime_api_key", "token", "secret", "refresh_token", "access_token", "id_token"):
+            if payload.get(secret):
+                payload[secret + "_present"] = True
+            payload.pop(secret, None)
+        entries.append(payload)
+    strategy = getattr(pool, "strategy", "")
+    return {"available": True, "strategy": str(strategy() if callable(strategy) else strategy or ""), "entries": entries}
+
+
+def context_length(model: str, *, base_url: str, api_key: str, provider: str, config_context_length: int | None) -> int | None:
+    try:
+        from agent.model_metadata import get_model_context_length
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"model metadata unavailable: {exc}", condition="providers_unavailable") from exc
+    try:
+        value = get_model_context_length(model, base_url=base_url or "", api_key=api_key or "", config_context_length=config_context_length, provider=provider or "")
+    except TypeError:
+        value = get_model_context_length(model, base_url=base_url or "", api_key=api_key or "")
+    except Exception:  # noqa: BLE001
+        log.debug("get_model_context_length(%r) failed", model, exc_info=True)
+        return None
+    try:
+        return int(value) if value else None
+    except (TypeError, ValueError):
+        return None
+
+
+def estimate_tokens(messages: list) -> int:
+    try:
+        from agent.model_metadata import estimate_messages_tokens_rough
+    except Exception as exc:  # noqa: BLE001
+        raise RpcError(f"model metadata unavailable: {exc}", condition="providers_unavailable") from exc
+    try:
+        return int(estimate_messages_tokens_rough(list(messages or [])) or 0)
+    except Exception:  # noqa: BLE001
+        log.debug("estimate_messages_tokens_rough failed", exc_info=True)
+        return 0
+
+
+def capabilities(provider: str, model: str) -> dict | None:
+    try:
+        from agent.models_dev import get_model_capabilities
+    except Exception:  # noqa: BLE001
+        return None
+    try:
+        caps = get_model_capabilities(provider, model)
+    except TypeError:
+        try:
+            caps = get_model_capabilities(model)
+        except Exception:  # noqa: BLE001
+            return None
+    except Exception:  # noqa: BLE001
+        return None
+    row = _plain(caps)
+    return row if isinstance(row, dict) else None
+
+
+def register(reg) -> None:
+    @reg.method("providers.registry")
+    def registry_(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"providers": registry()}
+
+    @reg.method("providers.auth_status")
+    def auth(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"status": auth_status(params.get("provider"))}
+
+    @reg.method("providers.model_ids")
+    def ids(ctx: CallContext, params: dict) -> dict:
+        provider = str(params.get("provider") or "").strip()
+        if not provider:
+            raise InvalidParams("provider is required")
+        with scoped_home(profile_home_param(params)):
+            return {"provider": provider, "model_ids": model_ids(provider, force_refresh=bool(params.get("force_refresh", False)))}
+
+    @reg.method("providers.resolve_runtime")
+    def runtime(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"runtime": resolve_runtime(requested=params.get("requested"), api_key=params.get("api_key"), base_url=params.get("base_url"), target_model=params.get("target_model"))}
+
+    @reg.method("providers.credential_pool")
+    def pool(ctx: CallContext, params: dict) -> dict:
+        provider = str(params.get("provider") or "").strip()
+        if not provider:
+            raise InvalidParams("provider is required")
+        with scoped_home(profile_home_param(params)):
+            return credential_pool(provider)
+
+    @reg.method("models.context_length")
+    def ctx_len(ctx: CallContext, params: dict) -> dict:
+        model = str(params.get("model") or "").strip()
+        if not model:
+            raise InvalidParams("model is required")
+        with scoped_home(profile_home_param(params)):
+            value = context_length(model, base_url=str(params.get("base_url") or ""), api_key=str(params.get("api_key") or ""), provider=str(params.get("provider") or ""),
+                                   config_context_length=params.get("config_context_length"))
+        return {"model": model, "context_length": value}
+
+    @reg.method("models.estimate_tokens", requires_agent=True)
+    def estimate(ctx: CallContext, params: dict) -> dict:
+        messages = params.get("messages")
+        if not isinstance(messages, list):
+            raise InvalidParams("messages must be a list")
+        return {"tokens": estimate_tokens(messages)}
+
+    @reg.method("models.capabilities")
+    def caps(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return {"capabilities": capabilities(str(params.get("provider") or ""), str(params.get("model") or ""))}

package/sidecar/talaria_sidecar/methods/runtime.py

@@ -0,0 +1,68 @@
+"""``runtime.*``: handshake, status, environment, shutdown."""
+
+from __future__ import annotations
+
+import os
+import re
+
+from .. import SIDECAR_RPC_VERSION
+from ..errors import InvalidParams, RpcError
+from ..rpc import CallContext
+
+
+def register(registry) -> None:
+    runtime = registry.runtime
+
+    @registry.method("runtime.handshake", requires_agent=False)
+    def handshake(ctx: CallContext, params: dict) -> dict:
+        requested = params.get("rpc_version")
+        if requested != SIDECAR_RPC_VERSION:
+            ctx.server.request_shutdown(exit_code=3)
+            raise RpcError(
+                f"sidecar RPC version mismatch: server speaks {requested!r}, sidecar speaks {SIDECAR_RPC_VERSION}",
+                condition="sidecar_rpc_version_mismatch",
+                data={"server_rpc_version": requested, "sidecar_rpc_version": SIDECAR_RPC_VERSION},
+            )
+        try:
+            runtime.load()
+        except RpcError:
+            # Report the failed import in the handshake payload; the server
+            # decides whether to keep the process for non-Agent methods.
+            return runtime.describe()
+        return runtime.describe()
+
+    @registry.method("runtime.status", requires_agent=False)
+    def status(ctx: CallContext, params: dict) -> dict:
+        return runtime.describe()
+
+    @registry.method("runtime.ensure_current", requires_agent=True)
+    def ensure_current(ctx: CallContext, params: dict) -> dict:
+        return {"current": True, "agent_revision": runtime.revision}
+
+    @registry.method("runtime.env", requires_agent=False)
+    def env(ctx: CallContext, params: dict) -> dict:
+        """Apply Web-owned ``.env`` edits to this process so Agent calls stop (or start) seeing a credential without a restart."""
+        names = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+        to_set = params.get("set") or {}
+        to_unset = params.get("unset") or []
+        if not isinstance(to_set, dict) or not all(isinstance(k, str) and names.match(k) and isinstance(v, str) for k, v in to_set.items()):
+            raise InvalidParams("set must map variable names to strings")
+        if not isinstance(to_unset, list) or not all(isinstance(k, str) and names.match(k) for k in to_unset):
+            raise InvalidParams("unset must list variable names")
+        for name in to_unset:
+            os.environ.pop(name, None)
+        for name, value in to_set.items():
+            os.environ[name] = value
+        # Cached agents bound the credentials they were built with; none of them may outlive a credential change.
+        from .chat import evict_all_agents
+
+        evict_all_agents()
+        return {"ok": True}
+
+    @registry.method("runtime.shutdown", requires_agent=False)
+    def shutdown(ctx: CallContext, params: dict) -> dict:
+        code = params.get("exit_code", 0)
+        if not isinstance(code, int):
+            raise InvalidParams("exit_code must be an integer")
+        ctx.server.request_shutdown(exit_code=code)
+        return {"ok": True}

package/sidecar/talaria_sidecar/methods/skills.py

@@ -0,0 +1,262 @@
+"""``skills.*``: skill discovery and parsing through the Agent's skill utilities.
+
+File writes (save, delete, toggle) live in the server; this namespace only
+parses SKILL.md trees the way ``tools.skills_tool`` does so the WebUI list
+matches what the Agent loads.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+from ..errors import InvalidParams
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+from .profiles import disabled_skill_names
+
+log = logging.getLogger("talaria_sidecar.skills")
+
+
+def _within(base: Path, candidate: Path) -> bool:
+    try:
+        candidate.resolve().relative_to(base.resolve())
+        return True
+    except (OSError, ValueError):
+        return False
+
+
+def search_dirs(skills_dir: Path) -> list[Path]:
+    dirs = [skills_dir]
+    try:
+        from agent.skill_utils import get_external_skills_dirs
+
+        dirs.extend(Path(p) for p in get_external_skills_dirs())
+    except Exception:  # noqa: BLE001
+        pass
+    return [p for p in dirs if p.exists()]
+
+
+def _category(skill_md: Path, dirs: list[Path], local: Path) -> str | None:
+    for skills_dir in dirs:
+        try:
+            rel = skill_md.relative_to(skills_dir)
+        except ValueError:
+            continue
+        parts = rel.parts[:-1]  # drop SKILL.md
+        if len(parts) >= 2:
+            return parts[0]
+        if len(parts) == 1 and skills_dir.resolve() != local.resolve():
+            return skills_dir.name
+        return None
+    return None
+
+
+def list_skills(profile_home: Path, category: str | None = None) -> dict:
+    skills_dir = profile_home / "skills"
+    try:
+        from agent.skill_utils import iter_skill_index_files
+        from tools.skills_tool import MAX_DESCRIPTION_LENGTH, _EXCLUDED_SKILL_DIRS, _parse_frontmatter, _sort_skills, skill_matches_platform
+    except ImportError:
+        return {"skills": [], "categories": [], "count": 0}
+    if not skills_dir.exists():
+        skills_dir.mkdir(parents=True, exist_ok=True)
+        return {"success": True, "skills": [], "categories": [], "count": 0, "message": f"No skills found. Skills directory created at {skills_dir}/"}
+    disabled = disabled_skill_names(profile_home)
+    dirs = search_dirs(skills_dir)
+    seen: set[str] = set()
+    out = []
+    for scan in dirs:
+        for skill_md in iter_skill_index_files(scan, "SKILL.md"):
+            if any(part in _EXCLUDED_SKILL_DIRS for part in skill_md.parts):
+                continue
+            try:
+                frontmatter, body = _parse_frontmatter(skill_md.read_text(encoding="utf-8")[:4000])
+                if not skill_matches_platform(frontmatter):
+                    continue
+                name = frontmatter.get("name", skill_md.parent.name)[:64]
+                if name in seen:
+                    continue
+                description = frontmatter.get("description", "")
+                if not description:
+                    for line in body.strip().split("\n"):
+                        line = line.strip()
+                        if line and not line.startswith("#"):
+                            description = line
+                            break
+                if len(description) > MAX_DESCRIPTION_LENGTH:
+                    description = description[: MAX_DESCRIPTION_LENGTH - 3] + "..."
+                seen.add(name)
+                out.append({"name": name, "description": description, "category": _category(skill_md, dirs, skills_dir), "disabled": name in disabled})
+            except Exception:  # noqa: BLE001
+                log.debug("Skipping skill at %s", skill_md, exc_info=True)
+    if category:
+        out = [s for s in out if s.get("category") == category]
+    out = _sort_skills(out)
+    categories = sorted({s["category"] for s in out if s.get("category")})
+    return {"success": True, "skills": out, "categories": categories, "count": len(out)}
+
+
+def find_skill(name: str, dirs: list[Path]) -> tuple[Path | None, Path | None]:
+    from agent.skill_utils import iter_skill_index_files
+    from tools.skills_tool import _EXCLUDED_SKILL_DIRS, _parse_frontmatter
+
+    raw = str(name or "").strip().strip("/")
+    if not raw:
+        return None, None
+    candidates = [raw]
+    if ":" in raw:
+        namespace, bare = raw.split(":", 1)
+        if namespace and bare:
+            candidates.append(f"{namespace}/{bare}")
+    for skills_dir in dirs:
+        if not skills_dir.exists():
+            continue
+        for candidate in candidates:
+            direct = skills_dir / candidate
+            if not _within(skills_dir, direct):
+                continue
+            if direct.is_dir() and (direct / "SKILL.md").exists():
+                return direct, direct / "SKILL.md"
+            legacy = direct.with_suffix(".md")
+            if legacy.exists() and _within(skills_dir, legacy):
+                return legacy.parent, legacy
+        for skill_md in iter_skill_index_files(skills_dir, "SKILL.md"):
+            if any(part in _EXCLUDED_SKILL_DIRS for part in skill_md.parts):
+                continue
+            if skill_md.parent.name == raw:
+                return skill_md.parent, skill_md
+            try:
+                frontmatter, _ = _parse_frontmatter(skill_md.read_text(encoding="utf-8")[:4000])
+                if frontmatter.get("name") == raw:
+                    return skill_md.parent, skill_md
+            except Exception:  # noqa: BLE001
+                continue
+        for legacy_md in _legacy_markdown(skills_dir):
+            if legacy_md.stem == raw and _within(skills_dir, legacy_md):
+                return legacy_md.parent, legacy_md
+    return None, None
+
+
+def _legacy_markdown(skills_dir: Path):
+    """Pruned walk for legacy ``<name>.md`` skills (never rglob)."""
+    import os
+
+    try:
+        from agent.skill_utils import EXCLUDED_SKILL_DIRS
+    except Exception:  # noqa: BLE001
+        EXCLUDED_SKILL_DIRS = frozenset({".git", ".venv", "node_modules", "site-packages"})
+    for root, dirnames, filenames in os.walk(skills_dir, followlinks=True):
+        dirnames[:] = [d for d in dirnames if d not in EXCLUDED_SKILL_DIRS]
+        for filename in filenames:
+            if filename != "SKILL.md" and filename.endswith(".md"):
+                yield Path(root) / filename
+
+
+def _linked_files(skill_dir: Path | None) -> dict:
+    if not skill_dir or not (skill_dir / "SKILL.md").exists():
+        return {}
+    linked: dict[str, list[str]] = {}
+    refs = skill_dir / "references"
+    if refs.exists():
+        items = sorted(str(f.relative_to(skill_dir)) for f in refs.glob("*.md"))
+        if items:
+            linked["references"] = items
+    templates = skill_dir / "templates"
+    if templates.exists():
+        items = set()
+        for ext in ("*.md", "*.py", "*.yaml", "*.yml", "*.json", "*.tex", "*.sh"):
+            items.update(str(f.relative_to(skill_dir)) for f in templates.rglob(ext))
+        if items:
+            linked["templates"] = sorted(items)
+    assets = skill_dir / "assets"
+    if assets.exists():
+        items = sorted(str(f.relative_to(skill_dir)) for f in assets.rglob("*") if f.is_file())
+        if items:
+            linked["assets"] = items
+    scripts = skill_dir / "scripts"
+    if scripts.exists():
+        items = set()
+        for ext in ("*.py", "*.sh", "*.bash", "*.js", "*.ts", "*.rb"):
+            items.update(str(f.relative_to(skill_dir)) for f in scripts.glob(ext))
+        if items:
+            linked["scripts"] = sorted(items)
+    return linked
+
+
+def view_from_file(skill_dir: Path | None, skill_md: Path) -> dict:
+    from tools.skills_tool import _parse_frontmatter, _parse_tags, skill_matches_platform
+
+    content = skill_md.read_text(encoding="utf-8")
+    frontmatter, _ = _parse_frontmatter(content)
+    if not skill_matches_platform(frontmatter):
+        return {"success": False, "error": "Skill is not available on this platform."}
+    metadata = frontmatter.get("metadata")
+    hermes_meta = metadata.get("hermes", {}) if isinstance(metadata, dict) else {}
+    try:
+        path = str(skill_md.relative_to((skill_dir or skill_md.parent).parent))
+    except ValueError:
+        path = str(skill_md)
+    return {
+        "success": True, "name": frontmatter.get("name", skill_md.stem if not skill_dir else skill_dir.name), "description": frontmatter.get("description", ""),
+        "tags": _parse_tags(hermes_meta.get("tags") or frontmatter.get("tags", "")), "related_skills": _parse_tags(hermes_meta.get("related_skills") or frontmatter.get("related_skills", "")),
+        "content": content, "path": path, "skill_dir": str(skill_dir) if skill_dir else None, "linked_files": _linked_files(skill_dir),
+    }
+
+
+def view_skill(profile_home: Path, name: str) -> dict:
+    skills_dir = profile_home / "skills"
+    dirs = search_dirs(skills_dir)
+    skill_dir, skill_md = find_skill(name, dirs)
+    if skill_md:
+        return view_from_file(skill_dir, skill_md)
+    if ":" in str(name or ""):
+        try:
+            from agent.skill_utils import is_valid_namespace, parse_qualified_name
+            from hermes_cli.plugins import discover_plugins, get_plugin_manager
+            from tools.skills_tool import skill_view
+
+            namespace, _ = parse_qualified_name(name)
+            if is_valid_namespace(namespace):
+                discover_plugins()
+                pm = get_plugin_manager()
+                if pm.find_plugin_skill(name) is not None or pm.list_plugin_skills(namespace):
+                    raw = skill_view(name)
+                    return json.loads(raw) if isinstance(raw, str) else raw
+        except Exception:  # noqa: BLE001
+            pass
+    names = [s["name"] for s in list_skills(profile_home).get("skills", [])]
+    available = names[:20]
+    truncated = len(names) > len(available)
+    hint = "Use skills_list to see all available skills"
+    if truncated:
+        hint = f"Showing {len(available)} of {len(names)} skills. {hint}"
+    return {"success": False, "error": f"Skill '{name}' not found.", "available_skills": available, "available_skills_truncated": truncated, "total_skills": len(names), "hint": hint}
+
+
+def register(registry) -> None:
+    @registry.method("skills.list")
+    def list_(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        with scoped_home(home):
+            return list_skills(home, params.get("category") or None)
+
+    @registry.method("skills.view")
+    def view(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        name = str(params.get("name") or "").strip()
+        if not name:
+            raise InvalidParams("name is required")
+        with scoped_home(home):
+            return view_skill(home, name)
+
+    @registry.method("skills.find")
+    def find(ctx: CallContext, params: dict) -> dict:
+        home = profile_home_param(params)
+        name = str(params.get("name") or "").strip()
+        if not name:
+            raise InvalidParams("name is required")
+        with scoped_home(home):
+            skill_dir, skill_md = find_skill(name, search_dirs(home / "skills"))
+        return {"found": skill_md is not None, "skill_dir": str(skill_dir) if skill_dir else None, "skill_md": str(skill_md) if skill_md else None}