memleaf 0.2.37__tar.gz → 0.2.39__tar.gz

{memleaf-0.2.37 → memleaf-0.2.39}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to memleaf are documented here.
 
+## 0.2.39 — 2026-09-09
+
+- Make `llm.thinking` a provider-neutral model policy instead of a DeepSeek-only request feature. Gate, summarize and compact continue to request `low` by default for every configured API model stage.
+- Translate that policy through each supported protocol: OpenAI reasoning-capable Chat Completions use `reasoning_effort=low`; DeepSeek keeps its explicit thinking switch plus low effort; current Claude effort-capable Messages models use `output_config.effort=low` with adaptive thinking where the model generation requires it; Gemini 3+ uses the lowest supported thinking level (normally `low`, with documented `minimal` fallbacks where `low` is unavailable), while Gemini 2.5 maps low to the native 1,024-token thinking budget.
+- Keep compatibility fail-safe for older or unknown models: memleaf does not send speculative reasoning fields that the model cannot accept. Per-call telemetry now distinguishes requested thinking mode from effective mode and the fixed provider control used, so unsupported/provider-default execution is visible instead of being mislabeled as low.
+- Omit sampling temperature when an OpenAI reasoning request or current Claude effort request does not safely accept that parameter. Existing Markdown/Vault, extraction, review, retrieval and write semantics are unchanged.
+
+## 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.

{memleaf-0.2.37/src/memleaf.egg-info → memleaf-0.2.39}/PKG-INFO

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

{memleaf-0.2.37 → memleaf-0.2.39}/README.en.md

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

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

{memleaf-0.2.37 → memleaf-0.2.39}/pyproject.toml

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

{memleaf-0.2.37 → memleaf-0.2.39}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.37"
+__version__ = "0.2.39"
 
 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.37 → memleaf-0.2.39}/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.37 → memleaf-0.2.39}/src/memleaf/hermes_provider/plugin.yaml

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

{memleaf-0.2.37 → memleaf-0.2.39}/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.39/src/memleaf/llm/claude_compatible.py

@@ -0,0 +1,67 @@
+"""Claude-compatible messages adapter."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Mapping, Optional
+
+from .base import DEFAULT_REQUEST_TIMEOUT, HTTPModelBackend
+from .thinking import claude_messages_controls, requested_thinking_mode
+
+
+class ClaudeCompatibleBackend(HTTPModelBackend):
+    provider = "claude"
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        model: str,
+        timeout: float = DEFAULT_REQUEST_TIMEOUT,
+        opener: Optional[Callable[..., Any]] = None,
+        thinking: Mapping[str, Any] | None = None,
+    ):
+        super().__init__(base_url=base_url, api_key=api_key, model=model, timeout=timeout, opener=opener)
+        self.thinking = dict(thinking) if isinstance(thinking, Mapping) else {}
+
+    @staticmethod
+    def _usage_metrics(value: Mapping[str, Any], thinking_metrics: Mapping[str, Any]) -> dict[str, Any]:
+        result: dict[str, Any] = dict(thinking_metrics)
+        usage = value.get("usage")
+        if not isinstance(usage, Mapping):
+            return result
+        input_tokens = usage.get("input_tokens")
+        output_tokens = usage.get("output_tokens")
+        if isinstance(input_tokens, int) and not isinstance(input_tokens, bool) and 0 <= input_tokens <= 10_000_000:
+            result["prompt_tokens"] = input_tokens
+        if isinstance(output_tokens, int) and not isinstance(output_tokens, bool) and 0 <= output_tokens <= 10_000_000:
+            result["completion_tokens"] = output_tokens
+        if "prompt_tokens" in result and "completion_tokens" in result:
+            result["total_tokens"] = result["prompt_tokens"] + result["completion_tokens"]
+        cache_read = usage.get("cache_read_input_tokens")
+        if isinstance(cache_read, int) and not isinstance(cache_read, bool) and 0 <= cache_read <= 10_000_000:
+            result["prompt_cache_hit_tokens"] = cache_read
+        return result
+
+    def complete(self, prompt: str, *, system: str = "", purpose: str = "", temperature: float = 0.0) -> str:
+        self._set_call_metrics({})
+        requested = requested_thinking_mode(self.thinking, purpose)
+        controls, thinking_metrics, omit_temperature = claude_messages_controls(self.model, requested)
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": 4096,
+            "messages": [{"role": "user", "content": prompt}],
+        }
+        if not omit_temperature:
+            payload["temperature"] = temperature
+        if system:
+            payload["system"] = system
+        payload.update(controls)
+        value = self._post_json(
+            self.base_url + "/v1/messages",
+            payload,
+            {"x-api-key": self.api_key, "anthropic-version": "2023-06-01"},
+            stage=purpose,
+        )
+        self._set_call_metrics(self._usage_metrics(value, thinking_metrics))
+        return self._text(value.get("content"), stage=purpose)

memleaf-0.2.39/src/memleaf/llm/gemini.py

@@ -0,0 +1,73 @@
+"""Gemini generateContent adapter."""
+
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any, Callable, Mapping, Optional
+
+from .base import DEFAULT_REQUEST_TIMEOUT, HTTPModelBackend, ModelError
+from .thinking import gemini_generate_controls, requested_thinking_mode
+
+
+class GeminiBackend(HTTPModelBackend):
+    provider = "gemini"
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        model: str,
+        timeout: float = DEFAULT_REQUEST_TIMEOUT,
+        opener: Optional[Callable[..., Any]] = None,
+        thinking: Mapping[str, Any] | None = None,
+    ):
+        super().__init__(base_url=base_url, api_key=api_key, model=model, timeout=timeout, opener=opener)
+        self.thinking = dict(thinking) if isinstance(thinking, Mapping) else {}
+
+    @staticmethod
+    def _usage_metrics(value: Mapping[str, Any], thinking_metrics: Mapping[str, Any]) -> dict[str, Any]:
+        result: dict[str, Any] = dict(thinking_metrics)
+        usage = value.get("usageMetadata")
+        if not isinstance(usage, Mapping):
+            return result
+        fields = {
+            "promptTokenCount": "prompt_tokens",
+            "candidatesTokenCount": "completion_tokens",
+            "totalTokenCount": "total_tokens",
+            "cachedContentTokenCount": "prompt_cache_hit_tokens",
+            "thoughtsTokenCount": "reasoning_tokens",
+        }
+        for source, target in fields.items():
+            item = usage.get(source)
+            if isinstance(item, int) and not isinstance(item, bool) and 0 <= item <= 10_000_000:
+                result[target] = item
+        return result
+
+    def complete(self, prompt: str, *, system: str = "", purpose: str = "", temperature: float = 0.0) -> str:
+        self._set_call_metrics({})
+        text = f"{system}\n\n{prompt}" if system else prompt
+        requested = requested_thinking_mode(self.thinking, purpose)
+        thinking_config, thinking_metrics, omit_temperature = gemini_generate_controls(self.model, requested)
+        generation_config: dict[str, Any] = {}
+        if not omit_temperature:
+            generation_config["temperature"] = temperature
+        generation_config.update(thinking_config)
+        payload = {
+            "contents": [{"role": "user", "parts": [{"text": text}]}],
+            "generationConfig": generation_config,
+        }
+        endpoint = "/v1beta/models/" + urllib.parse.quote(self.model, safe="") + ":generateContent"
+        url = self.base_url + endpoint + "?key=" + urllib.parse.quote(self.api_key, safe="")
+        value = self._post_json(url, payload, {}, stage=purpose)
+        self._set_call_metrics(self._usage_metrics(value, thinking_metrics))
+        candidates = value.get("candidates")
+        if not isinstance(candidates, list) or not candidates or not isinstance(candidates[0], Mapping):
+            raise ModelError("model response has no candidates", code="model_invalid_response", stage=purpose)
+        content = candidates[0].get("content")
+        if not isinstance(content, Mapping):
+            raise ModelError("model response has no content", code="model_invalid_response", stage=purpose)
+        parts = content.get("parts")
+        if not isinstance(parts, list):
+            raise ModelError("model response has no parts", code="model_invalid_response", stage=purpose)
+        return self._text(parts, stage=purpose)

{memleaf-0.2.37 → memleaf-0.2.39}/src/memleaf/llm/openai_compatible.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Callable, Mapping, Optional
 
 from .base import DEFAULT_REQUEST_TIMEOUT, HTTPModelBackend, ModelError
+from .thinking import openai_chat_controls, requested_thinking_mode
 
 
 class OpenAICompatibleBackend(HTTPModelBackend):
@@ -20,10 +21,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:
@@ -52,12 +55,8 @@ class OpenAICompatibleBackend(HTTPModelBackend):
         else:
             finish_reason = finish_reason.casefold()
             if finish_reason not in {
-                "stop",
-                "length",
-                "tool_calls",
-                "function_call",
-                "content_filter",
-                "insufficient_system_resource",
+                "stop", "length", "tool_calls", "function_call",
+                "content_filter", "insufficient_system_resource",
             }:
                 finish_reason = "unknown"
         usage = value.get("usage")
@@ -83,16 +82,47 @@ class OpenAICompatibleBackend(HTTPModelBackend):
             "reasoning_chars": reasoning_chars,
         }
 
+    @staticmethod
+    def _usage_metrics(
+        value: Mapping[str, Any],
+        *,
+        thinking_metrics: Mapping[str, Any],
+    ) -> dict[str, Any]:
+        usage = value.get("usage")
+        result: dict[str, Any] = dict(thinking_metrics)
+        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
+        prompt_details = usage.get("prompt_tokens_details")
+        cached = prompt_details.get("cached_tokens") if isinstance(prompt_details, Mapping) else None
+        if "prompt_cache_hit_tokens" not in result and isinstance(cached, int) and not isinstance(cached, bool) and 0 <= cached <= 10_000_000:
+            result["prompt_cache_hit_tokens"] = cached
+        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})
         messages.append({"role": "user", "content": prompt})
-        payload: dict[str, Any] = {
-            "model": self.model,
-            "messages": messages,
-            "temperature": temperature,
-        }
+        requested = requested_thinking_mode(self.thinking, purpose)
+        controls, thinking_metrics, omit_temperature = openai_chat_controls(
+            self.provider_name, self.model, requested
+        )
+        payload: dict[str, Any] = {"model": self.model, "messages": messages}
+        if not omit_temperature:
+            payload["temperature"] = temperature
+        payload.update(controls)
         if self.json_mode and purpose in {"gate", "summarize", "compact"}:
             payload["response_format"] = {"type": "json_object"}
         value = self._post_json(
@@ -101,6 +131,7 @@ class OpenAICompatibleBackend(HTTPModelBackend):
             {"Authorization": f"Bearer {self.api_key}"},
             stage=purpose,
         )
+        self._set_call_metrics(self._usage_metrics(value, thinking_metrics=thinking_metrics))
         choices = value.get("choices")
         if not isinstance(choices, list) or not choices or not isinstance(choices[0], Mapping):
             raise ModelError(

{memleaf-0.2.37 → memleaf-0.2.39}/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":
@@ -111,6 +113,7 @@ class ModelRouter:
             "api_key": api_key,
             "model": model,
             "timeout": request_timeout,
+            "thinking": config.get("thinking") if isinstance(config.get("thinking"), Mapping) else None,
         }
         try:
             if protocol in ("claude", "anthropic") or "claude" in provider or "anthropic" in provider:
@@ -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")