memleaf 0.2.38__tar.gz → 0.2.39__tar.gz

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

@@ -2,6 +2,13 @@
 
 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.

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.38
+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.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.38 → 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):
@@ -54,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")
@@ -85,16 +82,14 @@ 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]:
+    def _usage_metrics(
+        value: Mapping[str, Any],
+        *,
+        thinking_metrics: Mapping[str, Any],
+    ) -> dict[str, Any]:
         usage = value.get("usage")
-        result: dict[str, Any] = {"thinking_mode": thinking_mode}
+        result: dict[str, Any] = dict(thinking_metrics)
         if not isinstance(usage, Mapping):
             return result
         for key in (
@@ -104,6 +99,10 @@ class OpenAICompatibleBackend(HTTPModelBackend):
             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:
@@ -116,18 +115,14 @@ class OpenAICompatibleBackend(HTTPModelBackend):
         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,
-        }
-        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
+        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(
@@ -136,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(
@@ -152,7 +148,6 @@ 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.38 → memleaf-0.2.39}/src/memleaf/llm/router.py

@@ -113,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:
@@ -124,7 +125,6 @@ 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

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

@@ -0,0 +1,259 @@
+"""Provider-neutral thinking policy and protocol capability mapping."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Mapping
+
+
+THINKING_PURPOSES = frozenset({"gate", "summarize", "compact"})
+THINKING_MODES = frozenset({"default", "disabled", "low", "high", "max"})
+THINKING_EFFECTIVE_MODES = frozenset(
+    {"provider_default", "unsupported", "disabled", "minimal", "low", "high", "max"}
+)
+THINKING_CONTROLS = frozenset(
+    {
+        "provider_default",
+        "unsupported",
+        "openai_reasoning_effort",
+        "deepseek_thinking_effort",
+        "anthropic_effort",
+        "anthropic_adaptive_effort",
+        "gemini_thinking_level",
+        "gemini_thinking_budget",
+    }
+)
+
+
+def requested_thinking_mode(settings: Any, purpose: str) -> str:
+    """Return memleaf's requested stage policy, defaulting every model stage to low."""
+
+    if purpose not in THINKING_PURPOSES:
+        return "default"
+    value = settings.get(purpose, "low") if isinstance(settings, Mapping) else "low"
+    return value if isinstance(value, str) and value in THINKING_MODES else "low"
+
+
+def thinking_metrics(requested: str, effective: str, control: str) -> dict[str, str]:
+    requested = requested if requested in THINKING_MODES else "low"
+    effective = effective if effective in THINKING_EFFECTIVE_MODES else "unsupported"
+    control = control if control in THINKING_CONTROLS else "unsupported"
+    return {
+        "thinking_mode": requested,
+        "thinking_effective": effective,
+        "thinking_control": control,
+    }
+
+
+def _model_leaf(model: Any) -> str:
+    if not isinstance(model, str):
+        return ""
+    return model.casefold().strip().replace("_", "-").rsplit("/", 1)[-1]
+
+
+def _openai_reasoning_model(model: Any) -> bool:
+    leaf = _model_leaf(model)
+    return leaf.startswith(("gpt-5", "gpt-6", "o1", "o3", "o4", "gpt-oss"))
+
+
+def _openai_none_supported(model: Any) -> bool:
+    leaf = _model_leaf(model)
+    return leaf.startswith(("gpt-5.1", "gpt-5.2", "gpt-5.3", "gpt-5.4", "gpt-5.5", "gpt-5.6"))
+
+
+def _openai_max_supported(model: Any) -> bool:
+    leaf = _model_leaf(model)
+    return leaf.startswith(("gpt-6", "gpt-5.6"))
+
+
+def openai_chat_controls(
+    provider_name: Any,
+    model: Any,
+    requested: str,
+) -> tuple[dict[str, Any], dict[str, str], bool]:
+    """Map one policy request to an OpenAI-format Chat Completions payload.
+
+    The final bool says that sampling temperature must be omitted because the
+    selected reasoning mode/model does not accept or use it safely.
+    """
+
+    provider = provider_name.casefold().strip() if isinstance(provider_name, str) else ""
+    if requested == "default":
+        return {}, thinking_metrics(requested, "provider_default", "provider_default"), False
+
+    if provider == "deepseek":
+        if requested == "disabled":
+            return (
+                {"thinking": {"type": "disabled"}},
+                thinking_metrics(requested, "disabled", "deepseek_thinking_effort"),
+                False,
+            )
+        effort = requested if requested in {"low", "high", "max"} else "low"
+        return (
+            {"thinking": {"type": "enabled"}, "reasoning_effort": effort},
+            thinking_metrics(requested, effort, "deepseek_thinking_effort"),
+            True,
+        )
+
+    # Unknown OpenAI-compatible services are deliberately not assumed to
+    # accept reasoning_effort merely because they implement Chat Completions.
+    if "openai" not in provider or not _openai_reasoning_model(model):
+        return {}, thinking_metrics(requested, "unsupported", "unsupported"), False
+
+    if requested == "disabled":
+        if not _openai_none_supported(model):
+            return {}, thinking_metrics(requested, "unsupported", "unsupported"), True
+        return (
+            {"reasoning_effort": "none"},
+            thinking_metrics(requested, "disabled", "openai_reasoning_effort"),
+            True,
+        )
+    if requested == "max" and not _openai_max_supported(model):
+        return (
+            {"reasoning_effort": "high"},
+            thinking_metrics(requested, "high", "openai_reasoning_effort"),
+            True,
+        )
+    effort = requested if requested in {"low", "high", "max"} else "low"
+    return (
+        {"reasoning_effort": effort},
+        thinking_metrics(requested, effort, "openai_reasoning_effort"),
+        True,
+    )
+
+
+def _claude_profile(model: Any) -> str:
+    """Return only capabilities documented for a recognizable Claude family."""
+
+    leaf = _model_leaf(model)
+    if not leaf.startswith("claude-"):
+        return "unsupported"
+    if any(name in leaf for name in ("fable-5", "mythos-5", "mythos-preview")):
+        return "always_adaptive"
+    if re.match(r"claude-(?:opus|sonnet)-5(?:-|$)", leaf):
+        return "default_adaptive"
+    if re.match(r"claude-(?:opus|sonnet)-4-(?:6|7|8|9)(?:-|$)", leaf):
+        return "explicit_adaptive"
+    if re.match(r"claude-opus-4-5(?:-|$)", leaf):
+        return "effort_only"
+    return "unsupported"
+
+
+def claude_messages_controls(
+    model: Any,
+    requested: str,
+) -> tuple[dict[str, Any], dict[str, str], bool]:
+    """Map policy effort to current Claude Messages capabilities."""
+
+    profile = _claude_profile(model)
+    if profile == "unsupported":
+        return {}, thinking_metrics(requested, "unsupported", "unsupported"), False
+
+    # Claude 4.7+ and adaptive-thinking requests require the default sampling
+    # temperature. Opus 4.5 can use effort without enabling extended thinking.
+    omit_temperature = profile != "effort_only"
+    if requested == "default":
+        return {}, thinking_metrics(requested, "provider_default", "provider_default"), omit_temperature
+
+    if requested == "disabled":
+        if profile == "always_adaptive":
+            return (
+                {"output_config": {"effort": "low"}},
+                thinking_metrics(requested, "low", "anthropic_effort"),
+                omit_temperature,
+            )
+        if profile == "effort_only":
+            return (
+                {"output_config": {"effort": "low"}},
+                thinking_metrics(requested, "disabled", "anthropic_effort"),
+                omit_temperature,
+            )
+        return (
+            {"thinking": {"type": "disabled"}, "output_config": {"effort": "low"}},
+            thinking_metrics(requested, "disabled", "anthropic_effort"),
+            omit_temperature,
+        )
+
+    effort = requested if requested in {"low", "high", "max"} else "low"
+    if profile in {"explicit_adaptive", "effort_only"} and effort == "max":
+        # Low is the default requested path. For legacy effort-capable families,
+        # avoid sending a higher enum unless the current family documents it.
+        effort = "high"
+    payload: dict[str, Any] = {"output_config": {"effort": effort}}
+    control = "anthropic_effort"
+    if profile == "explicit_adaptive":
+        payload["thinking"] = {"type": "adaptive"}
+        control = "anthropic_adaptive_effort"
+    return payload, thinking_metrics(requested, effort, control), omit_temperature
+
+
+def _gemini_version(model: Any) -> tuple[int, int] | None:
+    leaf = _model_leaf(model)
+    match = re.match(r"gemini-(\d+)(?:\.(\d+))?", leaf)
+    if match is None:
+        return None
+    return int(match.group(1)), int(match.group(2) or 0)
+
+
+def _gemini3_low_level(model: Any) -> tuple[str, str]:
+    """Return the lowest safe Gemini 3.x level for a recognized exception."""
+
+    leaf = _model_leaf(model)
+    # Gemini 3.1 Flash-Lite Image documents minimal/high but not low. Minimal
+    # is lower than the requested low policy and therefore the safe latency
+    # preserving fallback instead of an invalid low value.
+    if leaf.startswith("gemini-3.1-flash-lite-image"):
+        return "minimal", "minimal"
+    return "low", "low"
+
+
+def gemini_generate_controls(
+    model: Any,
+    requested: str,
+) -> tuple[dict[str, Any], dict[str, str], bool]:
+    """Map policy effort to native Gemini generateContent thinkingConfig.
+
+    The final bool asks the adapter to omit explicit temperature for Gemini 3.x,
+    following the current API guidance for thinking models.
+    """
+
+    version = _gemini_version(model)
+    if requested == "default":
+        omit_temperature = bool(version and version[0] >= 3)
+        return {}, thinking_metrics(requested, "provider_default", "provider_default"), omit_temperature
+    if version is None:
+        return {}, thinking_metrics(requested, "unsupported", "unsupported"), False
+
+    major, minor = version
+    leaf = _model_leaf(model)
+    if major >= 3:
+        if requested in {"disabled", "low"}:
+            level, effective = _gemini3_low_level(model)
+        else:
+            level, effective = "high", "high"
+        return (
+            {"thinkingConfig": {"thinkingLevel": level}},
+            thinking_metrics(requested, effective, "gemini_thinking_level"),
+            True,
+        )
+
+    if major == 2 and minor == 5:
+        if requested == "disabled":
+            if "pro" in leaf:
+                budget = 1024
+                effective = "low"
+            else:
+                budget = 0
+                effective = "disabled"
+        elif requested == "low":
+            budget = 1024
+            effective = "low"
+        else:
+            budget = 24576
+            effective = "high"
+        return (
+            {"thinkingConfig": {"thinkingBudget": budget}},
+            thinking_metrics(requested, effective, "gemini_thinking_budget"),
+            False,
+        )
+    return {}, thinking_metrics(requested, "unsupported", "unsupported"), False

{memleaf-0.2.38 → memleaf-0.2.39}/src/memleaf/model_execution.py

@@ -30,6 +30,12 @@ _PROVIDER_METRIC_FIELDS = (
 )
 _METRIC_OPERATION_SUFFIXES = ("primary", "format_repair")
 _MAX_METRIC_CALLS = 256
+_THINKING_EFFECTIVE_MODES = frozenset({"provider_default", "unsupported", "disabled", "minimal", "low", "high", "max"})
+_THINKING_CONTROLS = frozenset({
+    "provider_default", "unsupported", "openai_reasoning_effort",
+    "deepseek_thinking_effort", "anthropic_effort", "anthropic_adaptive_effort",
+    "gemini_thinking_level", "gemini_thinking_budget",
+})
 
 
 def _metric_bucket() -> dict[str, Any]:
@@ -124,6 +130,12 @@ class ModelExecutor:
         mode = value.get("thinking_mode")
         if mode in {"default", "disabled", "low", "high", "max"}:
             result["thinking_mode"] = mode
+        effective = value.get("thinking_effective")
+        if effective in _THINKING_EFFECTIVE_MODES:
+            result["thinking_effective"] = effective
+        control = value.get("thinking_control")
+        if control in _THINKING_CONTROLS:
+            result["thinking_control"] = control
         return result
 
     @staticmethod

{memleaf-0.2.38 → memleaf-0.2.39}/src/memleaf/process_jobs.py

@@ -69,6 +69,12 @@ _MODEL_CALL_INT_FIELDS = frozenset({
     "reasoning_tokens",
 })
 _MAX_MODEL_CALL_ROWS = 256
+_THINKING_EFFECTIVE_MODES = frozenset({"provider_default", "unsupported", "disabled", "minimal", "low", "high", "max"})
+_THINKING_CONTROLS = frozenset({
+    "provider_default", "unsupported", "openai_reasoning_effort",
+    "deepseek_thinking_effort", "anthropic_effort", "anthropic_adaptive_effort",
+    "gemini_thinking_level", "gemini_thinking_budget",
+})
 
 
 def _now() -> str:
@@ -232,6 +238,12 @@ def _safe_model_metrics(value: Any) -> dict[str, Any]:
             mode = raw.get("thinking_mode")
             if mode in {"default", "disabled", "low", "high", "max"}:
                 row["thinking_mode"] = mode
+            effective = raw.get("thinking_effective")
+            if effective in _THINKING_EFFECTIVE_MODES:
+                row["thinking_effective"] = effective
+            control = raw.get("thinking_control")
+            if control in _THINKING_CONTROLS:
+                row["thinking_control"] = control
             bounded_calls.append(row)
         if bounded_calls:
             result["calls"] = bounded_calls