memleaf 0.2.36__tar.gz → 0.2.38__tar.gz

{memleaf-0.2.36 → memleaf-0.2.38}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.38 — 2026-09-09
+
+- Unify automatic project-Scope grounding: registered and newly named model-selected projects now use the same exact candidate-bound source check. Remove the later registered-name occurrence conflict scan that could misclassify an implementation platform/product mention as ownership and reject the correct new project.
+- Strengthen final CREATE/UPDATE semantic review so a `project:<name>` Scope with `scope_source=model` is itself treated as an affiliation claim; product/platform/system/notification/implementation mentions cannot authorize project ownership, and an explicit contradictory owner defers instead of silently changing Scope.
+- Add safe per-model-call telemetry with fixed operation classes (`gate_primary`, `gate_coverage_repair`, format repair, summarize/review/coordination variants), request duration, input/output size, provider token usage, DeepSeek cache-hit/miss tokens and reasoning-token counts when supplied. Prompt/response text and credentials are never persisted.
+- Add explicit `llm.thinking` configuration for Gate/summarize/compact. The default is `low`, retaining reasoning at the lowest supported effort; users may select `disabled`, `default`, `high`, or `max` explicitly. DeepSeek OpenAI-format calls send the corresponding thinking controls.
+- Reduce Gate input cost by removing a duplicated system-policy tail and replace coverage re-checks with a narrow unresolved-evidence protocol instead of rerunning the full Gate prompt. Deterministic validation does not claim a specific real-provider latency reduction.
+
+## 0.2.37 — 2026-09-09
+
+- Add a dedicated `memleaf-mcpw` GUI entry point for the Hermes public MCP on Windows. The GUI-subsystem launcher does not allocate a console window even when an older Hermes/MCP SDK starts it without `CREATE_NO_WINDOW`; it enters the same `memleaf.mcp_server:main` implementation and keeps the same stdio JSON-RPC protocol.
+- Keep the Hermes MemoryProvider private MCP on `memleaf-mcp.exe` with the v0.2.36 `CREATE_NO_WINDOW` protection, so both Windows launch paths are covered without changing macOS/Linux behavior or the Markdown Vault architecture.
+- Treat `memleaf-mcp.exe` and its sibling `memleaf-mcpw.exe` as the same installed memleaf runtime for preflight/runtime policy while still requiring the GUI launcher for the public Hermes MCP. Existing v0.2.36 direct entries in the same runtime migrate automatically; different-runtime and different-Vault protections remain fail closed.
+- Add Windows acceptance that inspects the installed launcher PE Subsystem, starts `memleaf-mcpw.exe` with `creationflags=0`, performs real MCP initialize and tools/list over redirected stdio, confirms all 13 tools, and verifies clean EOF shutdown.
+
 ## 0.2.36 — 2026-09-08
 
 - Prevent the Hermes MemoryProvider from opening a visible console/Windows Terminal window whenever it starts its private `memleaf-mcp` stdio child on Windows. Provider-owned MCP launches now use `subprocess.CREATE_NO_WINDOW`; stdin/stdout pipes, stderr suppression, timeout handling, process reuse and shutdown semantics are unchanged.

{memleaf-0.2.36/src/memleaf.egg-info → memleaf-0.2.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.36
+Version: 0.2.38
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.36。**
+> **版本：0.2.38。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.36 → memleaf-0.2.38}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.36.**
+> **Version: 0.2.38.**
 > Automatic extraction now uses only the current turn's visible user input and final assistant reply. Raw tool output, attachments, web/file/terminal payloads and legacy tool-evidence bodies are not new source evidence; existing or retrieved memory remains comparison context rather than source authority. Background processing is persisted as a local job and can be checked through the read-only `process_status` MCP tool; failed work remains retryable and fail closed. The release also tightens source/date grounding, target reconciliation, duplicate/no-op handling and semantic review before writes. Markdown remains the sole source of truth with no SQLite runtime dependency. Acceptance covers deterministic regression suites and synthetic inputs; it does not claim real-mail or customer-business acceptance.
 > **The current release supports Hermes and Codex.** Antigravity is not detected, installed, or configured.
 

{memleaf-0.2.36 → memleaf-0.2.38}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.36。**
+> **版本：0.2.38。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.36 → memleaf-0.2.38}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memleaf"
-version = "0.2.36"
+version = "0.2.38"
 description = "A local-first Markdown memory core for AI agents"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -27,6 +27,9 @@ dependencies = []
 memleaf-mcp = "memleaf.mcp_server:main"
 memleaf = "memleaf.cli:main"
 
+[project.gui-scripts]
+memleaf-mcpw = "memleaf.mcp_server:main"
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.36"
+__version__ = "0.2.38"
 
 from .config import DEFAULT_CONFIG, default_config, load_config, save_config
 from .frontmatter import FrontmatterError, dump_frontmatter, dump_yaml, load_yaml, parse_frontmatter

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/config.py

@@ -19,6 +19,9 @@ MAX_REQUEST_TIMEOUT = 240
 DEFAULT_MODEL_CONCURRENCY = 3
 MIN_MODEL_CONCURRENCY = 1
 MAX_MODEL_CONCURRENCY = 8
+THINKING_PURPOSES = ("gate", "summarize", "compact")
+THINKING_MODES = frozenset({"default", "disabled", "low", "high", "max"})
+DEFAULT_THINKING = {purpose: "low" for purpose in THINKING_PURPOSES}
 
 
 def _normalize_request_timeout(value: Any) -> int | float:
@@ -41,6 +44,21 @@ def _normalize_model_concurrency(value: Any) -> int:
     return value
 
 
+def _normalize_thinking_settings(value: Any) -> dict[str, str]:
+    if value is None:
+        value = {}
+    if not isinstance(value, Mapping):
+        raise ValueError("invalid memleaf llm.thinking settings")
+    if set(value) - set(THINKING_PURPOSES):
+        raise ValueError("invalid memleaf llm.thinking settings")
+    result = dict(DEFAULT_THINKING)
+    for purpose, mode in value.items():
+        if not isinstance(mode, str) or mode not in THINKING_MODES:
+            raise ValueError("invalid memleaf llm.thinking settings")
+        result[purpose] = mode
+    return result
+
+
 DEFAULT_CONFIG: dict[str, Any] = {
     "vault": "~/.memleaf",
     "agents": {"codex": True, "hermes": True, "antigravity": False},
@@ -75,6 +93,7 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "context_window": 200000,
         "request_timeout": DEFAULT_REQUEST_TIMEOUT,
         "diagnostic_logging": False,
+        "thinking": dict(DEFAULT_THINKING),
     },
 }
 
@@ -188,6 +207,7 @@ def load_config(path: Path | str, *, vault: Path | str | None = None) -> dict[st
         raise ValueError("invalid memleaf llm settings")
     llm = dict(llm)
     llm["request_timeout"] = _normalize_request_timeout(llm.get("request_timeout", DEFAULT_REQUEST_TIMEOUT))
+    llm["thinking"] = _normalize_thinking_settings(llm.get("thinking"))
     if type(llm.get("diagnostic_logging", False)) is not bool:
         raise ValueError("invalid memleaf llm.diagnostic_logging")
     merged["llm"] = llm
@@ -231,6 +251,7 @@ def save_config(path: Path | str, config: Mapping[str, Any]) -> None:
     normalized_llm["request_timeout"] = _normalize_request_timeout(
         normalized_llm.get("request_timeout", DEFAULT_REQUEST_TIMEOUT)
     )
+    normalized_llm["thinking"] = _normalize_thinking_settings(normalized_llm.get("thinking"))
     diagnostic_logging = normalized_llm.get("diagnostic_logging", False)
     if type(diagnostic_logging) is not bool:
         raise ValueError("invalid memleaf llm.diagnostic_logging")

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/hermes_provider/plugin.yaml

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.36
+version: 0.2.38
 description: "Hermes-native external MemoryProvider for local-first Markdown memory shared with the memleaf MCP server."
 hooks:
   - prefetch

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/hermes_runtime.py

@@ -18,7 +18,7 @@ from typing import Any, Mapping, Sequence
 from .adapters.hermes import _parse_json_or_yaml_mcp
 
 
-_MEMLEAF_COMMAND_NAMES = frozenset({"memleaf-mcp", "memleaf-mcp.exe"})
+_MEMLEAF_COMMAND_NAMES = frozenset({"memleaf-mcp", "memleaf-mcp.exe", "memleaf-mcpw", "memleaf-mcpw.exe"})
 _TRUE_VALUES = frozenset({"true", "1", "yes", "on"})
 _FALSE_VALUES = frozenset({"false", "0", "no", "off"})
 
@@ -111,6 +111,27 @@ def is_absolute_memleaf_command(
     return Path(text).is_absolute()
 
 
+def memleaf_commands_same_runtime(
+    left: Path | str,
+    right: Path | str,
+    *,
+    platform: str | None = None,
+) -> bool:
+    """Return whether two absolute memleaf launchers belong to one runtime."""
+
+    if host_paths_equivalent(left, right, platform=platform):
+        return True
+    if _platform_name(platform) != "nt":
+        return False
+    left_text = _path_text(left).replace("/", "\\")
+    right_text = _path_text(right).replace("/", "\\")
+    if not is_absolute_memleaf_command(left_text, platform="nt"):
+        return False
+    if not is_absolute_memleaf_command(right_text, platform="nt"):
+        return False
+    return ntpath.normcase(ntpath.dirname(left_text)) == ntpath.normcase(ntpath.dirname(right_text))
+
+
 def _is_bare_memleaf_command(command: str, *, platform: str | None = None) -> bool:
     text = command.strip()
     return (
@@ -172,6 +193,7 @@ def inspect_hermes_mcp(
     expected_command: Path | str,
     *,
     platform: str | None = None,
+    allow_same_runtime: bool = False,
 ) -> HermesMcpInspection:
     """Inspect ``mcp_servers.memleaf`` without executing configured commands.
 
@@ -313,6 +335,17 @@ def inspect_hermes_mcp(
             configured_command=command,
             configured_vault=configured_vault,
         )
+    if allow_same_runtime and memleaf_commands_same_runtime(
+        command, expected_command, platform=platform
+    ):
+        return _result(
+            "correct",
+            "the existing memleaf MCP entry uses a sibling launcher from this runtime and Vault",
+            config_path=path,
+            expected_command=expected_command,
+            configured_command=command,
+            configured_vault=configured_vault,
+        )
     if _is_bare_memleaf_command(command, platform=platform):
         return _result(
             "legacy",
@@ -346,4 +379,5 @@ __all__ = [
     "host_paths_equivalent",
     "inspect_hermes_mcp",
     "is_absolute_memleaf_command",
+    "memleaf_commands_same_runtime",
 ]

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/installer.py

@@ -38,6 +38,7 @@ from .hermes_runtime import (
     HermesMcpInspection,
     inspect_hermes_mcp,
     is_absolute_memleaf_command,
+    memleaf_commands_same_runtime,
 )
 from .locking import atomic_write_json
 from .native_registration import ensure_hermes_native_sources
@@ -226,6 +227,33 @@ def _memleaf_mcp_command() -> Path:
     raise RuntimeError("memleaf-mcp console entry point was not found after package installation")
 
 
+def _provider_mcp_command(runtime_command: Path | str) -> Path:
+    """Return the console entry point used by the copied MemoryProvider."""
+
+    runtime = Path(runtime_command).expanduser().resolve()
+    if os.name != "nt":
+        return runtime
+    if runtime.name.casefold() == "memleaf-mcp.exe":
+        return runtime
+    if runtime.name.casefold() == "memleaf-mcpw.exe":
+        console = runtime.with_name("memleaf-mcp.exe")
+        if console.is_file():
+            return console.resolve()
+    raise RuntimeError("the selected memleaf runtime has no memleaf-mcp.exe console entry point")
+
+
+def _hermes_public_mcp_command(runtime_command: Path | str) -> Path:
+    """Return the no-console public MCP launcher for the selected runtime."""
+
+    provider_command = _provider_mcp_command(runtime_command)
+    if os.name != "nt":
+        return provider_command
+    gui = provider_command.with_name("memleaf-mcpw.exe")
+    if not gui.is_file():
+        raise RuntimeError("the selected memleaf runtime has no memleaf-mcpw.exe GUI entry point")
+    return gui.resolve()
+
+
 def _copy_provider(hermes_home: Path) -> Path:
     plugins = hermes_home / "plugins"
     target = plugins / "memleaf"
@@ -481,6 +509,15 @@ def _configure_hermes_mcp_entry(
             command=[detection.executable, "mcp", "list"],
         )
     allowed = inspection.status in {"absent", "legacy"}
+    same_runtime_launcher_migration = bool(
+        inspection.status == "runtime_conflict"
+        and inspection.configured_command
+        and memleaf_commands_same_runtime(
+            inspection.configured_command, command, platform=platform
+        )
+    )
+    if same_runtime_launcher_migration:
+        allowed = True
     if inspection.status == "runtime_conflict" and allow_runtime_migration:
         allowed = True
     if not allowed:
@@ -779,6 +816,7 @@ def install_hermes(
         selected_vault,
         current_command,
         platform=platform,
+        allow_same_runtime=True,
     )
     selected_command, runtime_details = _choose_hermes_mcp_command(
         preflight,
@@ -806,6 +844,26 @@ def install_hermes(
             user_action=action,
         )
 
+    try:
+        provider_command = _provider_mcp_command(selected_command)
+        public_command = _hermes_public_mcp_command(selected_command)
+    except RuntimeError as error:
+        return _failure_result(
+            stage="runtime_launcher",
+            reason=str(error),
+            core_version=core_version,
+            vault=selected_vault,
+            vault_source=vault_source,
+            mcp_runtime=runtime_details,
+        )
+    runtime_details = dict(runtime_details)
+    runtime_details.update(
+        {
+            "provider_command": str(provider_command),
+            "public_command": str(public_command),
+        }
+    )
+
     vault = Vault.initialize(selected_vault)
     model = _prepare_model_route(
         vault.root,
@@ -872,7 +930,7 @@ def install_hermes(
                 adapter,
                 detection,
                 vault.root,
-                selected_command,
+                str(public_command),
                 allow_runtime_migration=(
                     mcp_runtime == "current" and preflight.status == "runtime_conflict"
                 ),
@@ -888,7 +946,7 @@ def install_hermes(
                     ),
                     recovery_commands=_mcp_recovery_commands(
                         detection.executable,
-                        selected_command,
+                        str(public_command),
                         vault.root,
                     ),
                 )
@@ -899,7 +957,7 @@ def install_hermes(
                     mcp=configured.to_dict(),
                     recovery_commands=_mcp_recovery_commands(
                         detection.executable,
-                        selected_command,
+                        str(public_command),
                         vault.root,
                     ),
                 )
@@ -933,7 +991,7 @@ def install_hermes(
                     ),
                 )
             try:
-                _write_provider_config(provider_config, Path(selected_command), vault.root)
+                _write_provider_config(provider_config, provider_command, vault.root)
             except Exception as error:
                 raise _HermesInstallFailure(
                     "provider_config",
@@ -1015,7 +1073,8 @@ def install_hermes(
         "vault": str(vault.root),
         "vault_source": vault_source,
         "provider": str(provider_path),
-        "mcp_command": selected_command,
+        "mcp_command": str(public_command),
+        "provider_mcp_command": str(provider_command),
         "mcp_runtime": runtime_details,
         "model": model,
         "native_sources": native_registration,

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/llm/base.py

@@ -6,6 +6,7 @@ import json
 import inspect
 import math
 import socket
+import threading
 import urllib.error
 import urllib.request
 from typing import Any, Callable, Mapping, Optional, Protocol
@@ -246,10 +247,19 @@ class HTTPModelBackend:
         self.model = model
         self.timeout = normalize_request_timeout(timeout)
         self._opener = opener or urllib.request.urlopen
+        self._call_metrics_local = threading.local()
         # The built-in stateless urllib transport can be used concurrently.
         # An injected opener is caller-owned and therefore defaults to serial.
         self.parallel_safe = opener is None
 
+    def _set_call_metrics(self, value: Mapping[str, Any] | None) -> None:
+        self._call_metrics_local.value = dict(value) if isinstance(value, Mapping) else {}
+
+    def consume_call_metrics(self) -> dict[str, Any]:
+        value = getattr(self._call_metrics_local, "value", {})
+        self._call_metrics_local.value = {}
+        return dict(value) if isinstance(value, Mapping) else {}
+
     @staticmethod
     def _is_timeout_reason(value: Any) -> bool:
         if isinstance(value, (TimeoutError, socket.timeout)):

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/llm/openai_compatible.py

@@ -20,10 +20,12 @@ class OpenAICompatibleBackend(HTTPModelBackend):
         opener: Optional[Callable[..., Any]] = None,
         json_mode: bool = False,
         provider_name: str = "openai",
+        thinking: Mapping[str, Any] | None = None,
     ):
         super().__init__(base_url=base_url, api_key=api_key, model=model, timeout=timeout, opener=opener)
         self.json_mode = bool(json_mode)
         self.provider_name = provider_name.casefold() if isinstance(provider_name, str) else "openai"
+        self.thinking = dict(thinking) if isinstance(thinking, Mapping) else {}
 
     @staticmethod
     def _response_text_chars(value: Any) -> int:
@@ -83,7 +85,33 @@ class OpenAICompatibleBackend(HTTPModelBackend):
             "reasoning_chars": reasoning_chars,
         }
 
+    def _thinking_mode(self, purpose: str) -> str:
+        if purpose not in {"gate", "summarize", "compact"}:
+            return "default"
+        value = self.thinking.get(purpose, "low")
+        return value if value in {"default", "disabled", "low", "high", "max"} else "low"
+
+    @staticmethod
+    def _usage_metrics(value: Mapping[str, Any], *, thinking_mode: str) -> dict[str, Any]:
+        usage = value.get("usage")
+        result: dict[str, Any] = {"thinking_mode": thinking_mode}
+        if not isinstance(usage, Mapping):
+            return result
+        for key in (
+            "prompt_tokens", "completion_tokens", "total_tokens",
+            "prompt_cache_hit_tokens", "prompt_cache_miss_tokens",
+        ):
+            item = usage.get(key)
+            if isinstance(item, int) and not isinstance(item, bool) and 0 <= item <= 10_000_000:
+                result[key] = item
+        details = usage.get("completion_tokens_details")
+        reasoning = details.get("reasoning_tokens") if isinstance(details, Mapping) else None
+        if isinstance(reasoning, int) and not isinstance(reasoning, bool) and 0 <= reasoning <= 10_000_000:
+            result["reasoning_tokens"] = reasoning
+        return result
+
     def complete(self, prompt: str, *, system: str = "", purpose: str = "", temperature: float = 0.0) -> str:
+        self._set_call_metrics({})
         messages = []
         if system:
             messages.append({"role": "system", "content": system})
@@ -93,6 +121,13 @@ class OpenAICompatibleBackend(HTTPModelBackend):
             "messages": messages,
             "temperature": temperature,
         }
+        thinking_mode = self._thinking_mode(purpose)
+        if self.provider_name == "deepseek" and thinking_mode != "default":
+            if thinking_mode == "disabled":
+                payload["thinking"] = {"type": "disabled"}
+            else:
+                payload["thinking"] = {"type": "enabled"}
+                payload["reasoning_effort"] = thinking_mode
         if self.json_mode and purpose in {"gate", "summarize", "compact"}:
             payload["response_format"] = {"type": "json_object"}
         value = self._post_json(
@@ -117,6 +152,7 @@ class OpenAICompatibleBackend(HTTPModelBackend):
                 stage=purpose,
                 validation_reason="response_shape",
             )
+        self._set_call_metrics(self._usage_metrics(value, thinking_mode=thinking_mode))
         try:
             return self._text(message.get("content"), stage=purpose)
         except ModelError as error:

{memleaf-0.2.36 → memleaf-0.2.38}/src/memleaf/llm/router.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 import os
+import threading
 from typing import Any, Callable, Mapping, Optional
 
 from .base import (
@@ -44,6 +45,7 @@ class ModelRouter:
         self.host = self._coerce_host(host)
         self.api = self._coerce_api(api) if api is not None else self._build_api()
         self.diagnostics: list[dict[str, str]] = []
+        self._call_metrics_local = threading.local()
 
     @classmethod
     def from_config(cls, config: Mapping[str, Any], **kwargs: Any) -> "ModelRouter":
@@ -122,6 +124,7 @@ class ModelRouter:
                     **kwargs,
                     json_mode=provider in _JSON_MODE_PROVIDERS,
                     provider_name=provider or "openai",
+                    thinking=config.get("thinking") if isinstance(config.get("thinking"), Mapping) else None,
                 )
         except (ModelError, ValueError, TypeError):
             return None
@@ -142,6 +145,7 @@ class ModelRouter:
         return str(getattr(backend, "provider", "unknown")), str(getattr(backend, "model", "unknown"))
 
     def _call(self, backend: ModelBackend, prompt: str, *, system: str, purpose: str, temperature: float) -> str:
+        self._call_metrics_local.value = {}
         try:
             value = backend.complete(prompt, system=system, purpose=purpose, temperature=temperature)
         except ModelError as error:
@@ -149,10 +153,23 @@ class ModelRouter:
             raise
         except Exception as error:
             raise ModelError("model backend failed", stage=purpose) from error
+        finally:
+            consume = getattr(backend, "consume_call_metrics", None)
+            if callable(consume):
+                try:
+                    metrics = consume()
+                except Exception:
+                    metrics = {}
+                self._call_metrics_local.value = dict(metrics) if isinstance(metrics, Mapping) else {}
         if not isinstance(value, str):
             raise ModelError("model backend returned non-text output", code="model_invalid_response", stage=purpose)
         return value
 
+    def consume_call_metrics(self) -> dict[str, Any]:
+        value = getattr(self._call_metrics_local, "value", {})
+        self._call_metrics_local.value = {}
+        return dict(value) if isinstance(value, Mapping) else {}
+
     def complete(self, prompt: str, *, system: str = "", purpose: str = "", temperature: float = 0.0) -> str:
         if not isinstance(prompt, str):
             raise TypeError("model prompt must be text")