memleaf 0.2.44__tar.gz → 0.2.46__tar.gz

{memleaf-0.2.44 → memleaf-0.2.46}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.46 — 2026-09-12
+
+- Restore the host protocol literals that v0.2.45 dropped from the API-route protocol table. `anthropic_messages`, `chat_completions`, `chat`, `google` and `generate_content` resolve again. v0.2.45 replaced the previous tolerant mapping with an exact table that omitted every canonical Hermes `api_mode` value, so a Hermes custom provider that used to resolve to a protocol began resolving to none and was reported as `missing provider, base URL, protocol, or model`. Substring and model-name matching stay removed: only exact host-contract literals are accepted, and an unknown protocol still fails closed.
+- Stop `memleaf install --host hermes` from aborting when model-route discovery finds nothing. Installation now continues and reports `processing_status: model_route_required` with an explicit user action, matching the Codex installer policy. Previously the install returned `stage: model_route` before touching the provider, which left the core package upgraded while the Hermes provider stayed on its previous version. The provider and MCP surface do not need a model route for capture or retrieval, so a missing route is a deferred configuration step rather than an installation failure.
+- Add `install --no-model-discovery` so an upgrade can skip host model discovery while still preserving an existing memleaf route, matching the `init` flag that already existed. Discovery remains enabled by default, so an installation that already succeeds is unaffected.
+- Verification for this release used synthetic Hermes-shaped routes, a temporary Vault and mocked host calls only: 18 focused tests cover the restored protocol literals, rejection of still-unknown protocols, discovery of a Hermes-shaped custom provider, the degraded-install decision, the new CLI flag, and an end-to-end assertion that `install_hermes` walks past a failed model route. No real provider call was made and no production Vault, Hermes configuration or session was read or written. A real Windows Hermes install and a real macOS Hermes install remain unverified by this release, and the manual model-route configuration step is still required on a host whose credentials the host CLI only reports masked.
+
+## 0.2.45 — 2026-09-12
+
+- Repair the `b3-single-pass-v1` automatic extraction contract so model output is constrained by the same CREATE / UPDATE / NO_CHANGE / DEFERRED fields, evidence shapes, no-memory/defer reasons, target rules and lookup-completeness checks that Core validates. Pure ASCII decision-case differences are normalized locally; unknown decisions and missing semantic fields still fail closed.
+- Replace the generic second full-prompt retry with one B3-specific structural repair. The repair receives only the previous untrusted B3 object, the compact protocol and allowlisted structural diagnostics; Core rejects candidate count/order changes, evidence/target/scope/memory drift, or any edit outside the explicitly repairable protocol redundancy. Automatic extraction remains limited to at most two actual model requests and never fabricates a terminal disposition.
+- Separate credential/profile name (`provider`), wire protocol (`protocol`) and capability identity (`provider_family`). DeepSeek capabilities are resolved only from explicit configuration, exact legacy provider IDs, or exact official hostnames; custom aliases, model-name substrings and lookalike domains no longer grant provider-specific JSON/thinking behavior or override an explicit protocol. Unknown OpenAI-compatible services fail closed for single-pass capability.
+- Make DeepSeek single-pass primary and repair requests send explicit `thinking: {type: disabled}` and `response_format: {type: json_object}` from the resolved capability profile, with independently configurable bounded output ceilings. Finish-reason truncation is rejected before commit, repair output is never truncated to fit a budget, and transport success, parser rejection and commit acceptance remain separate metrics.
+- Refine thinking telemetry to distinguish requested, applied and observed state, preserve missing usage as unknown, and report observed reasoning when provider usage or response content proves it. The HTTP transport base no longer grants `single_pass_safe` by inheritance; B3 protocol compatibility and bounded one-request transport semantics are evaluated separately.
+- Validation for this release used the exact v0.2.44 source artifact at `c13c6dedacfdf6206fd8ebdaa04c4d84fdc0b919`: 88 focused tests passed, including temporary-Vault atomicity/idempotency/revision-conflict boundaries, provider request serialization, B3 repair fidelity, request-count limits and the advisory ten-second latency rule. No real provider call or production-session replay was used, so real-model first-pass success rate, repair success rate, reasoning reduction and latency improvement remain unmeasured.
+
 ## 0.2.44 — 2026-09-12
 
 - Correct the extraction latency policy: ten seconds is an advisory performance target, not a cancellation or commit deadline. Remove the fixed six-second primary cap and eight-second shared window; single-pass HTTP requests now honor `llm.request_timeout`, including the one bounded format repair.

{memleaf-0.2.44/src/memleaf.egg-info → memleaf-0.2.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.44
+Version: 0.2.46
 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.44。**
+> **版本：0.2.46。**
 > 记忆只从用户与 Agent 的可见对话提炼。Agent 已在回复中整理的事实、项目进展和明确待办可作为来源；邮件、附件、网页和终端等工具原文不进入记忆提炼。模型负责保留原话中的不确定性，现有记忆仅用于比较、去重和更新。Markdown 仍是唯一事实源。
 > **当前版本支持 Hermes 和 Codex。** Antigravity（反重力）不检测、不安装、不配置。
 

{memleaf-0.2.44 → memleaf-0.2.46}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.44.**
+> **Version: 0.2.46.**
 > 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.44 → memleaf-0.2.46}/README.md

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

{memleaf-0.2.44 → memleaf-0.2.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memleaf"
-version = "0.2.44"
+version = "0.2.46"
 description = "A local-first Markdown memory core for AI agents"
 readme = "README.md"
 requires-python = ">=3.11"

{memleaf-0.2.44 → memleaf-0.2.46}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.44"
+__version__ = "0.2.46"
 
 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.44 → memleaf-0.2.46}/src/memleaf/cli.py

@@ -22,6 +22,7 @@ from .adapters.base import (
 from .adapters.hermes import HermesAdapter
 from .credentials import credential_text
 from .config import load_config
+from .model_capabilities import resolve_provider_capabilities
 from .model_discovery import ModelCandidate, discover_models, manual_candidate, write_model_config
 from .vault import Vault
 
@@ -76,6 +77,14 @@ def build_parser() -> argparse.ArgumentParser:
             "this installation (current), or retain a version-matched configured runtime (existing)"
         ),
     )
+    install.add_argument(
+        "--no-model-discovery",
+        action="store_true",
+        help=(
+            "Hermes only: skip host model discovery; an existing memleaf route is "
+            "still preserved and the install continues either way"
+        ),
+    )
     install.add_argument("--json", action="store_true", help="emit one JSON result")
     audit = commands.add_parser("audit", help="inspect an existing Vault without changing it")
     audit.add_argument("--vault", type=Path, default=None)
@@ -231,6 +240,8 @@ def main(argv: Sequence[str] | None = None) -> int:
                 install_kwargs = {"vault_path": args.vault}
                 if args.mcp_runtime != "auto":
                     install_kwargs["mcp_runtime"] = args.mcp_runtime
+                if args.no_model_discovery:
+                    install_kwargs["skip_model_discovery"] = True
                 output = install_hermes(**install_kwargs)
         elif args.command in {"audit", "process"}:
             from .inspection import audit_vault, existing_root, preview_process
@@ -301,8 +312,12 @@ def main(argv: Sequence[str] | None = None) -> int:
                 print("Restart Hermes to use memleaf.")
             elif output.get("user_action_required"):
                 print(f"Codex action required: {output.get('user_action')}")
-            if output.get("model", {}).get("status") == "not_configured":
-                print("Configure a memleaf model route before using automatic processing.")
+            if output.get("processing_status") == "model_route_required":
+                print(
+                    "Automatic memory extraction needs a memleaf model route before it can run. "
+                    "Set llm.provider/family/protocol/base_url/model/key in the Vault config.yaml, "
+                    "or rerun `memleaf init` from an interactive terminal."
+                )
         else:
             _print_install_failure(output, host=args.host)
         return 0 if output.get("status") in {"configured", "already_configured"} else 2
@@ -531,6 +546,11 @@ def _existing_memleaf_route(path: Path) -> ModelCandidate | None:
     if key is None:
         return None
     try:
+        capabilities = resolve_provider_capabilities(
+            provider=llm.get("provider"),
+            provider_family=llm.get("provider_family"),
+            base_url=llm.get("base_url"),
+        )
         return ModelCandidate(
             source="memleaf",
             provider=str(llm.get("provider", "")),
@@ -540,6 +560,8 @@ def _existing_memleaf_route(path: Path) -> ModelCandidate | None:
             api_key=key,
             context_window=int(llm.get("context_window", 200000)),
             source_detail="existing memleaf route",
+            provider_family=capabilities.provider_family,
+            provider_family_source=capabilities.source,
         )
     except (TypeError, ValueError):
         return None
@@ -547,13 +569,17 @@ def _existing_memleaf_route(path: Path) -> ModelCandidate | None:
 
 def _prompt_for_model() -> ModelCandidate:
     print("memleaf: no complete callable chat model was found; configure one for processing.", file=sys.stderr)
-    provider = input("Provider (openai/claude/gemini): ").strip()
+    provider = input("Provider / credential profile name: ").strip()
+    provider_family = input(
+        "Provider family (openai/deepseek/anthropic/gemini/generic, blank=auto): "
+    ).strip()
     protocol = input("Protocol (openai/claude/gemini): ").strip()
     base_url = input("Base URL: ").strip()
     model = input("Model: ").strip()
     api_key = getpass.getpass("API key (input hidden): ")
     return manual_candidate(
         provider=provider,
+        provider_family=provider_family,
         protocol=protocol,
         base_url=base_url,
         model=model,

{memleaf-0.2.44 → memleaf-0.2.46}/src/memleaf/config.py

@@ -9,6 +9,9 @@ from typing import Any, Mapping
 
 from .frontmatter import FrontmatterError, dump_yaml, load_yaml
 from .locking import atomic_write_text
+from .model_capabilities import (
+    legacy_protocol_for_provider, normalize_protocol, normalize_provider_family,
+)
 from .native_index import NativeConfigError, validate_native_sources
 from .scope_state import ScopeError, validate_scope_registry
 
@@ -19,6 +22,10 @@ MAX_REQUEST_TIMEOUT = 240
 DEFAULT_MODEL_CONCURRENCY = 3
 MIN_MODEL_CONCURRENCY = 1
 MAX_MODEL_CONCURRENCY = 8
+DEFAULT_SINGLE_PASS_PRIMARY_MAX_TOKENS = 8192
+DEFAULT_SINGLE_PASS_REPAIR_MAX_TOKENS = 8192
+MIN_SINGLE_PASS_MAX_TOKENS = 2048
+MAX_SINGLE_PASS_MAX_TOKENS = 32768
 THINKING_PURPOSES = ("gate", "summarize", "compact", "single_pass")
 THINKING_MODES = frozenset({"default", "disabled", "low", "high", "max"})
 DEFAULT_THINKING = {purpose: "low" for purpose in THINKING_PURPOSES}
@@ -40,6 +47,16 @@ def _normalize_request_timeout(value: Any) -> int | float:
     return int(parsed) if parsed.is_integer() else parsed
 
 
+def _normalize_single_pass_token_limit(value: Any, *, field: str, default: int) -> int:
+    if value is None or value == "":
+        return default
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(f"invalid memleaf llm.{field}")
+    if not MIN_SINGLE_PASS_MAX_TOKENS <= value <= MAX_SINGLE_PASS_MAX_TOKENS:
+        raise ValueError(f"invalid memleaf llm.{field}")
+    return value
+
+
 def _normalize_model_concurrency(value: Any) -> int:
     if isinstance(value, bool) or not isinstance(value, int):
         raise ValueError("invalid memleaf process.model_concurrency")
@@ -89,6 +106,7 @@ DEFAULT_CONFIG: dict[str, Any] = {
     "llm": {
         "mode": "auto",
         "provider": "",
+        "provider_family": "",
         "protocol": "openai",
         "base_url": "",
         "api_key": "",
@@ -96,6 +114,8 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "model": "",
         "context_window": 200000,
         "request_timeout": DEFAULT_REQUEST_TIMEOUT,
+        "single_pass_primary_max_tokens": DEFAULT_SINGLE_PASS_PRIMARY_MAX_TOKENS,
+        "single_pass_repair_max_tokens": DEFAULT_SINGLE_PASS_REPAIR_MAX_TOKENS,
         "diagnostic_logging": False,
         "thinking": dict(DEFAULT_THINKING),
     },
@@ -148,6 +168,19 @@ def _normalize_legacy_config(value: Mapping[str, Any]) -> dict[str, Any]:
             # the current default restore normal bounded evidence capture.
             current["tool_evidence_mode"] = "off"
         normalized["capture"] = current
+    llm = normalized.get("llm")
+    if llm is not None and not isinstance(llm, Mapping):
+        raise ValueError("invalid memleaf llm settings")
+    if isinstance(llm, Mapping):
+        current_llm = dict(llm)
+        # Old configs often omitted protocol and relied on the provider name.
+        # Preserve only exact built-in identifiers; custom aliases never
+        # override an explicitly configured protocol.
+        if not isinstance(current_llm.get("protocol"), str) or not current_llm.get("protocol", "").strip():
+            legacy_protocol = legacy_protocol_for_provider(current_llm.get("provider"))
+            if legacy_protocol is not None:
+                current_llm["protocol"] = legacy_protocol
+        normalized["llm"] = current_llm
     return normalized
 
 
@@ -210,7 +243,17 @@ def load_config(path: Path | str, *, vault: Path | str | None = None) -> dict[st
     if not isinstance(llm, Mapping):
         raise ValueError("invalid memleaf llm settings")
     llm = dict(llm)
+    llm["provider_family"] = normalize_provider_family(llm.get("provider_family"))
+    llm["protocol"] = normalize_protocol(llm.get("protocol"), provider=llm.get("provider"))
     llm["request_timeout"] = _normalize_request_timeout(llm.get("request_timeout", DEFAULT_REQUEST_TIMEOUT))
+    llm["single_pass_primary_max_tokens"] = _normalize_single_pass_token_limit(
+        llm.get("single_pass_primary_max_tokens"),
+        field="single_pass_primary_max_tokens", default=DEFAULT_SINGLE_PASS_PRIMARY_MAX_TOKENS,
+    )
+    llm["single_pass_repair_max_tokens"] = _normalize_single_pass_token_limit(
+        llm.get("single_pass_repair_max_tokens"),
+        field="single_pass_repair_max_tokens", default=DEFAULT_SINGLE_PASS_REPAIR_MAX_TOKENS,
+    )
     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")
@@ -252,9 +295,21 @@ def save_config(path: Path | str, config: Mapping[str, Any]) -> None:
     if not isinstance(llm, Mapping):
         raise ValueError("invalid memleaf llm settings")
     normalized_llm = dict(llm)
+    normalized_llm["provider_family"] = normalize_provider_family(normalized_llm.get("provider_family"))
+    normalized_llm["protocol"] = normalize_protocol(
+        normalized_llm.get("protocol"), provider=normalized_llm.get("provider")
+    )
     normalized_llm["request_timeout"] = _normalize_request_timeout(
         normalized_llm.get("request_timeout", DEFAULT_REQUEST_TIMEOUT)
     )
+    normalized_llm["single_pass_primary_max_tokens"] = _normalize_single_pass_token_limit(
+        normalized_llm.get("single_pass_primary_max_tokens"),
+        field="single_pass_primary_max_tokens", default=DEFAULT_SINGLE_PASS_PRIMARY_MAX_TOKENS,
+    )
+    normalized_llm["single_pass_repair_max_tokens"] = _normalize_single_pass_token_limit(
+        normalized_llm.get("single_pass_repair_max_tokens"),
+        field="single_pass_repair_max_tokens", default=DEFAULT_SINGLE_PASS_REPAIR_MAX_TOKENS,
+    )
     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:

{memleaf-0.2.44 → memleaf-0.2.46}/src/memleaf/extraction_budget.py

@@ -26,8 +26,6 @@ class SinglePassBudgetBackend:
     its repair overrides the transport's configured ``llm.request_timeout``.
     """
 
-    single_pass_safe = True
-
     def __init__(
         self,
         backend: Any,
@@ -50,6 +48,18 @@ class SinglePassBudgetBackend:
     def model(self) -> str:
         return str(getattr(self._backend, "model", "unknown"))
 
+    @property
+    def single_pass_safe(self) -> bool:
+        """Preserve the underlying adapter/route request-boundary guarantee."""
+
+        return getattr(self._backend, "single_pass_safe", False) is True
+
+    @property
+    def single_pass_protocol(self) -> bool:
+        """Preserve protocol identity while this wrapper enforces request count."""
+
+        return getattr(self._backend, "single_pass_protocol", False) is True
+
     @property
     def parallel_safe(self) -> bool:
         return getattr(self._backend, "parallel_safe", False) is True
@@ -144,6 +154,7 @@ class ExtractionTiming:
             "failed_turn_count": int(failed),
             "over_target_turn_count": int(seconds > TARGET_TOTAL_SECONDS),
             "successful_within_target_count": int(not failed and seconds <= TARGET_TOTAL_SECONDS),
+            "commit_accepted_count": int(not failed and commit_started is not None),
             "total_duration_ms": int(seconds * 1000),
             "max_turn_duration_ms": int(seconds * 1000),
             "planning_duration_ms": int(max(0.0, planning_end - self._started) * 1000),
@@ -156,7 +167,7 @@ def aggregate_extraction_metrics(values: Iterable[Mapping[str, Any]]) -> dict[st
 
     summed = (
         "turn_count", "failed_turn_count", "over_target_turn_count",
-        "successful_within_target_count", "total_duration_ms",
+        "successful_within_target_count", "commit_accepted_count", "total_duration_ms",
         "planning_duration_ms", "commit_duration_ms",
     )
     result = {key: 0 for key in summed}

{memleaf-0.2.44 → memleaf-0.2.46}/src/memleaf/extraction_capability.py

@@ -32,20 +32,20 @@ def _direct_protocol_capable(backend: Any) -> bool:
 
     if backend is None:
         return False
-    if getattr(backend, "single_pass_safe", False) is True:
-        return True
-    declared = getattr(backend, "single_pass_protocol", None)
-    if isinstance(declared, bool):
-        return declared
+    # Raw Python callbacks are adapted by ModelExecutor into CallableBackend.
+    # Preserve their established prompt-level B3 compatibility without
+    # claiming any transport boundary inside caller-owned code.  An explicit
+    # callback override can still opt out.
     if isinstance(backend, CallableBackend):
         override = _callable_protocol_override(backend)
         if override is not None:
             return override
-        # Raw Python callbacks are adapted by ModelExecutor into
-        # CallableBackend. They can consume memleaf's B3 prompt, but are not
-        # transport-timeout safe because caller-owned code may ignore
-        # timeout/cancellation entirely.
         return True
+    # Protocol support is independent of request-boundary safety.  A backend
+    # must not gain B3 merely because complete() happens to be bounded.
+    declared = getattr(backend, "single_pass_protocol", None)
+    if isinstance(declared, bool):
+        return declared
     return False
 
 

{memleaf-0.2.44 → memleaf-0.2.46}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.44 → memleaf-0.2.46}/src/memleaf/installer.py

@@ -15,7 +15,7 @@ import subprocess
 import sys
 import sysconfig
 import tempfile
-from typing import Any
+from typing import Any, Mapping
 
 from . import __version__
 from .adapters.base import (
@@ -754,10 +754,33 @@ def _failure_result(
     return result
 
 
+def _model_route_outcome(model: Any) -> tuple[bool, str, str | None]:
+    """Decide how one host installation reports its model route.
+
+    A missing model route must never block installing the host integration.
+    The provider/MCP surface still serves capture and retrieval without one,
+    so installation continues and reports ``model_route_required`` until a
+    route is configured.  This is the documented Codex policy, and applying it
+    to Hermes keeps the two hosts consistent instead of aborting the install
+    and leaving core and provider versions out of step.
+    """
+
+    if isinstance(model, Mapping) and model.get("status") in {"configured", "already_configured"}:
+        return True, "ready", None
+    return (
+        False,
+        "model_route_required",
+        "Configure an independent memleaf Model Route for this Vault before relying on "
+        "automatic memory extraction. Host model/provider settings are intentionally "
+        "not used or modified.",
+    )
+
+
 def install_hermes(
     *,
     vault_path: Path | None = None,
     mcp_runtime: str = "auto",
+    skip_model_discovery: bool = False,
 ) -> dict[str, Any]:
     """Install memleaf for Hermes with runtime preflight and host rollback.
 
@@ -870,18 +893,14 @@ def install_hermes(
         home=home,
         dry_run=False,
         non_interactive=not sys.stdin.isatty(),
-        skip_discovery=False,
+        skip_discovery=skip_model_discovery,
     )
-    if model.get("status") == "failure":
-        return _failure_result(
-            stage="model_route",
-            reason="model route is not configured",
-            core_version=core_version,
-            vault=vault.root,
-            vault_source=vault_source,
-            model=model,
-            mcp_runtime=runtime_details,
-        )
+    # A missing route degrades the installation instead of aborting it: the
+    # Hermes provider and MCP surface do not need a model route, and stopping
+    # here used to leave core and provider versions out of step.
+    model_ready, processing_status, model_action = _model_route_outcome(model)
+    # ``model_ready`` is reported through ``processing_status`` below; the host
+    # integration itself is configured either way.
 
     provider_target = hermes_home / "plugins" / "memleaf"
     provider_config = hermes_home / "memleaf.json"
@@ -1079,6 +1098,9 @@ def install_hermes(
         "model": model,
         "native_sources": native_registration,
         "capture": capture_policy_status(vault.config()),
+        "processing_status": processing_status,
+        "user_action_required": bool(model_action),
+        "user_action": model_action,
     }
 
 

{memleaf-0.2.44 → memleaf-0.2.46}/src/memleaf/llm/base.py

@@ -146,6 +146,7 @@ class ModelBackend(Protocol):
     parallel_safe: bool
     structured_batch_safe: bool
     single_pass_safe: bool
+    single_pass_protocol: bool
 
     def complete(
         self,
@@ -167,7 +168,6 @@ class CallableBackend:
     parallel_safe = False
     structured_batch_safe = False
     single_pass_safe = False
-
     def __init__(self, callback: Callable[..., str], *, model: str = "host"):
         if not callable(callback):
             raise TypeError("model callback must be callable")
@@ -231,7 +231,10 @@ class HTTPModelBackend:
     provider = "api"
     parallel_safe = False
     structured_batch_safe = True
-    single_pass_safe = True
+    # Protocol compatibility is provider-specific.  Generic HTTP transports
+    # must not authorize B3 merely because one complete() maps to one request.
+    single_pass_safe = False
+    single_pass_protocol = False
 
     def __init__(
         self,