@oneciel-ai/ciel-runtime 0.2.1 → 0.2.2

package/ciel_runtime.py

@@ -4787,6 +4787,7 @@ ollama_preserve_configured_context_cap = (
 ollama_effective_context_limit = _OLLAMA_CONTEXT_POLICY.effective_context_limit
 ollama_num_ctx_for_payload = _OLLAMA_CONTEXT_POLICY.num_ctx_for_payload
 ollama_num_predict_for_payload = _OLLAMA_CONTEXT_POLICY.num_predict_for_payload
+ollama_wire_options = _OLLAMA_CONTEXT_POLICY.wire_options
 ollama_num_ctx_status = _OLLAMA_CONTEXT_POLICY.num_ctx_status
 ollama_extra_options = _OLLAMA_CONTEXT_POLICY.extra_options
 ollama_options_status = _OLLAMA_CONTEXT_POLICY.options_status
@@ -4932,10 +4933,10 @@ def provider_request_builder() -> ProviderRequestBuilder:
         OllamaRequestPorts(
             messages=anthropic_messages_to_ollama,
             tools=anthropic_tools_to_ollama,
-            extra_options=ollama_extra_options,
+            extra_options=ollama_wire_options,
             context_limit=ollama_context_limit_for_budget,
             num_ctx=ollama_num_ctx_for_payload,
-            think_enabled=ollama_request_think_enabled,
+            think_value=ollama_request_think_value,
             num_predict=ollama_num_predict_for_payload,
         ),
         OpenAIRequestPorts(
@@ -4970,11 +4971,32 @@ def normalize_anthropic_model_request_options(provider: str, pcfg: dict[str, Any
         model_id,
     )
 
+def ollama_request_think_value(
+    provider: str,
+    model: str | None,
+    pcfg: dict[str, Any],
+    body: dict[str, Any] | None = None,
+) -> bool | str | None:
+    adapter = configured_provider_adapter(provider, pcfg)
+    return adapter.ollama_think_value(
+        provider_contract_config(provider, pcfg),
+        str(model or pcfg.get("current_model") or ""),
+        body or {},
+    )
+
 def ollama_request_think_enabled(model: str | None, pcfg: dict[str, Any]) -> bool:
-    return bool(pcfg.get("think", False))
+    return bool(ollama_request_think_value("ollama", model, pcfg))
 
 def ollama_think_status(model: str | None, pcfg: dict[str, Any]) -> str:
-    return str(ollama_request_think_enabled(model, pcfg))
+    normalized = str(model or pcfg.get("current_model") or "").lower()
+    provider = (
+        "ollama-cloud"
+        if normalized.startswith(("deepseek-v4-", "gpt-oss", "glm-5.2"))
+        or pcfg.get("ollama_model_architecture")
+        in {"deepseek4", "gptoss", "glm5.2"}
+        else "ollama"
+    )
+    return str(ollama_request_think_value(provider, model, pcfg))
 
 def ollama_chat_request(model: str, body: dict[str, Any], pcfg: dict[str, Any], stream: bool = True, provider: str = "ollama") -> dict[str, Any]:
     return provider_request_builder().ollama_chat(
@@ -5014,10 +5036,10 @@ def advisor_request_builder() -> AdvisorRequestBuilder:
             reserve=context_guard_reserve_tokens,
             compact_messages=compact_ollama_messages_for_budget,
             configured_output=configured_output_tokens,
-            ollama_options=ollama_extra_options,
+            ollama_options=ollama_wire_options,
             positive_int=positive_int,
             ollama_num_ctx=ollama_num_ctx_for_payload,
-            think_enabled=ollama_request_think_enabled,
+            think_value=ollama_request_think_value,
         ),
         AdvisorEndpointPorts(
             join_url=join_url,
@@ -5950,8 +5972,9 @@ def _build_ollama_collection_request(
     *,
     stream: bool,
 ) -> dict[str, Any]:
-    del provider
-    return ollama_chat_request(model, body, pcfg, stream=stream)
+    return ollama_chat_request(
+        model, body, pcfg, stream=stream, provider=provider
+    )
 
 def collect_ollama_message_for_responses(
     handler: BaseHTTPRequestHandler,
@@ -11172,7 +11195,12 @@ def ciel_runtime_restart_user_args() -> list[str]:
 
 def runtime_restart_service() -> RuntimeRestartService:
     return RuntimeRestartService(
-        settings=RuntimeRestartSettings(sys.argv, sys.executable, os.environ),
+        settings=RuntimeRestartSettings(
+            sys.argv,
+            sys.executable,
+            os.environ,
+            platform_name=os.name,
+        ),
         ports=RuntimeRestartPorts(
             current_package_root=current_npm_package_root,
             global_package_root=npm_global_package_root,

package/ciel_runtime_support/advisor_request_builder.py

@@ -40,7 +40,9 @@ class AdvisorBudgetPorts:
     ollama_options: Callable[[dict[str, Any]], dict[str, Any]]
     positive_int: Callable[[Any], int]
     ollama_num_ctx: Callable[..., int]
-    think_enabled: Callable[[str | None, dict[str, Any]], bool]
+    think_value: Callable[
+        [str, str | None, dict[str, Any], dict[str, Any]], bool | str | None
+    ]
 
 
 @dataclass(frozen=True, slots=True)
@@ -205,8 +207,10 @@ class AdvisorRequestBuilder:
             "model": upstream_model,
             "messages": messages,
             "stream": False,
-            "think": self.budget.think_enabled(upstream_model, config),
         }
+        think = self.budget.think_value(provider, upstream_model, config, body)
+        if think is not None:
+            request["think"] = think
         options = self.budget.ollama_options(config)
         options.setdefault(
             "num_predict",

package/ciel_runtime_support/architecture.py

@@ -625,6 +625,14 @@ class ProviderAdapter(ABC):
         del config, model, request
         return None
 
+    def ollama_think_value(
+        self, config: ProviderConfig, model: str, request: Mapping[str, Any]
+    ) -> bool | str | None:
+        """Return the provider-native value for Ollama's ``think`` field."""
+
+        del model, request
+        return bool(config.options.get("think", False))
+
     def allows_sampling_overrides(self, config: ProviderConfig) -> bool:
         """Whether user-provided sampling controls are valid for this provider."""
 

package/ciel_runtime_support/claude_environment.py

@@ -26,6 +26,10 @@ class ClaudeLimitPolicy:
         self._ports = ports
 
     def output_token_limit(self, provider: str, config: dict[str, Any]) -> int | None:
+        if provider in ("ollama", "ollama-cloud") and not config.get(
+            "output_tokens_explicit"
+        ):
+            return None
         configured = self._ports.positive_int(config.get("max_output_tokens"))
         if configured:
             return self._ports.cap_output_tokens(provider, config, configured)

package/ciel_runtime_support/codex_session_selection.py

@@ -81,6 +81,7 @@ class CodexSessionSelectionService:
         include_non_interactive: bool = False,
         passthrough: list[str] | None = None,
         cwd: Path | None = None,
+        select_latest: bool = False,
     ) -> str | None:
         launch_cwd = (cwd or Path.cwd()).resolve()
         show_all = "--all" in (passthrough or [])
@@ -104,6 +105,8 @@ class CodexSessionSelectionService:
                 f"{database}.{hint}"
             )
             return None
+        if select_latest:
+            return str(sessions[0].get("id") or "").strip()
         selected = self.presentation.select(
             "Resume Codex session",
             [self.resume_session_row(session) for session in sessions],

package/ciel_runtime_support/config_migrations.py

@@ -34,6 +34,31 @@ def apply_config_migrations(cfg: dict[str, Any], *, policy: ConfigMigrationPolic
         migrations = {}
         cfg["migrations"] = migrations
 
+    marker = "ollama_cloud_deepseek_v4_flash_0731_20260803"
+    if not migrations.get(marker):
+        pcfg = cfg.get("providers", {}).get("ollama-cloud", {})
+        if isinstance(pcfg, dict):
+            model = strip_claude_context_suffix(
+                str(pcfg.get("current_model") or "")
+            ).lower()
+            if model in {
+                "deepseek-v4-flash:0731",
+                "deepseek-v4-flash:0731-cloud",
+            }:
+                pcfg.setdefault("think", True)
+                pcfg.setdefault("effort_level", "max")
+                pcfg["model_context_max"] = 1_000_000
+                pcfg["model_context_model"] = "deepseek-v4-flash:0731"
+                if positive_int(pcfg.get("num_ctx_max")) in {
+                    0,
+                    131072,
+                    524288,
+                    999424,
+                    1048576,
+                }:
+                    pcfg["num_ctx_max"] = 1_000_000
+        migrations[marker] = True
+
     marker = "ollama_cloud_glm52_thinking_context_20260711"
     if not migrations.get(marker):
         pcfg = cfg.get("providers", {}).get("ollama-cloud", {})

package/ciel_runtime_support/context_setup.py

@@ -192,6 +192,10 @@ class ContextSetupService:
                 32768 if window <= 65536 else 65536,
             )
             config.setdefault("ollama_options", {})["num_predict"] = output
+            config["output_tokens_explicit"] = True
+            explicit = set(config.get("ollama_explicit_options") or [])
+            explicit.add("num_predict")
+            config["ollama_explicit_options"] = sorted(explicit)
         elif strategy == "standard":
             config["context_window"] = window
             config["context_reserve_tokens"] = reserve

package/ciel_runtime_support/kimi_identity.py

@@ -9,12 +9,21 @@ import re
 import shutil
 import socket
 import subprocess
+import tempfile
+import threading
 import time
+import urllib.parse
+import urllib.request
 import uuid
 from pathlib import Path
 from typing import Any
 
 
+KIMI_CODE_OAUTH_CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"
+KIMI_CODE_OAUTH_HOST = "https://auth.kimi.com"
+_OAUTH_REFRESH_LOCK = threading.Lock()
+
+
 def code_home(home: Path, environ: dict[str, str] | None = None) -> Path:
     values = os.environ if environ is None else environ
     return Path(values.get("KIMI_CODE_HOME") or (home / ".kimi-code"))
@@ -41,13 +50,95 @@ def oauth_access_token(home: Path) -> str | None:
         expires_at = float(record.get("expires_at") or 0)
     except (TypeError, ValueError):
         expires_at = 0
-    if not token or (expires_at > 0 and expires_at <= time.time() + 30):
+    if not token:
         return None
+    if expires_at > 0 and expires_at <= time.time() + 30:
+        return refresh_oauth_access_token(home, record)
     return token
 
 
+def refresh_oauth_access_token(
+    home: Path, record: dict[str, Any] | None = None
+) -> str | None:
+    """Refresh an expired official Kimi Code token using its public OAuth contract."""
+
+    with _OAUTH_REFRESH_LOCK:
+        current = oauth_token_record(home)
+        if current is None:
+            return None
+        try:
+            expires_at = float(current.get("expires_at") or 0)
+        except (TypeError, ValueError):
+            expires_at = 0
+        current_token = str(current.get("access_token") or "").strip()
+        if current_token and (expires_at <= 0 or expires_at > time.time() + 30):
+            return current_token
+        refresh_token = str(current.get("refresh_token") or "").strip()
+        if not refresh_token:
+            return None
+        oauth_host = str(
+            os.environ.get("KIMI_CODE_OAUTH_HOST")
+            or os.environ.get("KIMI_OAUTH_HOST")
+            or KIMI_CODE_OAUTH_HOST
+        ).rstrip("/")
+        body = urllib.parse.urlencode(
+            {
+                "client_id": KIMI_CODE_OAUTH_CLIENT_ID,
+                "grant_type": "refresh_token",
+                "refresh_token": refresh_token,
+            }
+        ).encode("utf-8")
+        headers = {
+            **identity_headers(home),
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+        }
+        request = urllib.request.Request(
+            f"{oauth_host}/api/oauth/token", data=body, headers=headers, method="POST"
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=15) as response:
+                payload = json.loads(response.read().decode("utf-8"))
+        except (OSError, TypeError, ValueError):
+            return None
+        if not isinstance(payload, dict):
+            return None
+        access_token = str(payload.get("access_token") or "").strip()
+        try:
+            expires_in = int(payload.get("expires_in") or 0)
+        except (TypeError, ValueError):
+            expires_in = 0
+        if not access_token or expires_in <= 0:
+            return None
+        updated = {
+            **current,
+            **payload,
+            "refresh_token": str(payload.get("refresh_token") or refresh_token),
+            "expires_at": int(time.time()) + expires_in,
+        }
+        path = code_home(home) / "credentials" / "kimi-code.json"
+        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        descriptor, temp_name = tempfile.mkstemp(prefix=".kimi-code.", dir=path.parent)
+        try:
+            with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+                json.dump(updated, stream, separators=(",", ":"))
+                stream.write("\n")
+            os.chmod(temp_name, 0o600)
+            os.replace(temp_name, path)
+        finally:
+            try:
+                os.unlink(temp_name)
+            except FileNotFoundError:
+                pass
+        return access_token
+
+
 def oauth_configured(home: Path) -> bool:
-    if oauth_access_token(home) is None:
+    record = oauth_token_record(home)
+    if record is None or not (
+        str(record.get("access_token") or "").strip()
+        or str(record.get("refresh_token") or "").strip()
+    ):
         return False
     try:
         text = (code_home(home) / "config.toml").read_text(encoding="utf-8")
@@ -120,4 +211,5 @@ __all__ = [
     "oauth_access_token",
     "oauth_configured",
     "oauth_token_record",
+    "refresh_oauth_access_token",
 ]

package/ciel_runtime_support/ollama_context_sync.py

@@ -48,6 +48,16 @@ def sync_ollama_context_limit(
     limit = policy.positive_int(api_specs.get("max_model_len"))
     matched_model = policy.normalize_model_id(provider, model_id) if limit else ""
     source_url = "/api/show" if limit else ""
+    architecture = str(api_specs.get("architecture") or "").strip().lower()
+    capabilities = api_specs.get("capabilities")
+    if architecture or isinstance(capabilities, list):
+        config["ollama_model_metadata_model"] = policy.normalize_model_id(
+            provider, model_id
+        )
+        if architecture:
+            config["ollama_model_architecture"] = architecture
+        if isinstance(capabilities, list):
+            config["ollama_model_capabilities"] = list(capabilities)
     if not limit:
         catalog = sources.load_catalog()
         if sources.catalog_is_stale(catalog):

package/ciel_runtime_support/ollama_thinking.py

@@ -0,0 +1,145 @@
+"""Provider-native Ollama thinking-level policy.
+
+Ollama's structured ``/api/show`` response identifies model capabilities and
+architecture, but does not currently publish the accepted ``think`` levels.
+This policy combines that discovered metadata with small architecture-level
+contracts documented by Ollama. Unknown thinking architectures retain the
+boolean behavior supported by the generic Ollama API.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+INTERNAL_REASONING_EFFORT_KEY = "ciel_runtime_reasoning_effort"
+
+
+def normalized_model_id(model_id: str) -> str:
+    model = str(model_id or "").strip().lower()
+    prefix = "ciel-runtime-ollama-cloud-"
+    if model.startswith(prefix):
+        model = model[len(prefix) :]
+    if model.endswith("[1m]"):
+        model = model[:-4]
+    if model.endswith("-cloud") and ":" in model:
+        model = model[:-6]
+    elif model.endswith(":cloud"):
+        model = model[:-6]
+    return model
+
+
+def request_effort(request: Mapping[str, Any]) -> str:
+    for key in ("thinking", "output_config", "reasoning"):
+        value = request.get(key)
+        if isinstance(value, Mapping) and value.get("effort") is not None:
+            return str(value["effort"]).strip().lower()
+    metadata = request.get("metadata")
+    if isinstance(metadata, Mapping):
+        value = metadata.get(INTERNAL_REASONING_EFFORT_KEY)
+        if value is not None:
+            return str(value).strip().lower()
+    return ""
+
+
+def thinking_disabled(request: Mapping[str, Any]) -> bool:
+    thinking = request.get("thinking")
+    return isinstance(thinking, Mapping) and str(
+        thinking.get("type") or ""
+    ).strip().lower() in {"disabled", "none", "off", "false"}
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaThinkingPolicy:
+    """Resolve Claude/Codex effort into an Ollama model's native mode."""
+
+    def architecture(self, options: Mapping[str, Any], model_id: str) -> str:
+        model = normalized_model_id(model_id)
+        metadata_model = normalized_model_id(
+            str(options.get("ollama_model_metadata_model") or "")
+        )
+        discovered = str(options.get("ollama_model_architecture") or "").lower()
+        if discovered and metadata_model == model:
+            return discovered
+        if model.startswith("deepseek-v4-"):
+            return "deepseek4"
+        if model.startswith("gpt-oss"):
+            return "gptoss"
+        if model in {"glm-5.2", "glm-5.2:cloud"}:
+            return "glm5.2"
+        return ""
+
+    def value(
+        self,
+        options: Mapping[str, Any],
+        model_id: str,
+        request: Mapping[str, Any],
+    ) -> bool | str | None:
+        architecture = self.architecture(options, model_id)
+        effort = request_effort(request)
+
+        if architecture == "gptoss":
+            # Ollama documents that GPT-OSS ignores booleans and cannot fully
+            # disable thinking; only low, medium, and high are accepted.
+            if not effort:
+                effort = str(options.get("effort_level") or "medium").lower()
+            if effort in {"medium"}:
+                return "medium"
+            if effort in {"high", "xhigh", "max", "ultra", "maximum"}:
+                return "high"
+            return "low"
+
+        if architecture == "glm5.2":
+            # The Ollama model card documents two effort levels: High and Max.
+            if not effort:
+                effort = str(options.get("effort_level") or "high").lower()
+            return "max" if effort in {
+                "max",
+                "xhigh",
+                "ultra",
+                "maximum",
+            } else "high"
+
+        if architecture == "deepseek4":
+            if thinking_disabled(request):
+                return False
+            if not effort and not bool(options.get("think", True)):
+                return False
+            if not effort:
+                default = (
+                    "max"
+                    if normalized_model_id(model_id) == "deepseek-v4-flash:0731"
+                    else "high"
+                )
+                effort = str(options.get("effort_level") or default).lower()
+            if effort in {
+                "none",
+                "off",
+                "disabled",
+                "minimal",
+                "minimum",
+                "low",
+                "light",
+            }:
+                return False
+            if effort in {"max", "xhigh", "ultra", "maximum"}:
+                return "max"
+            return "high"
+
+        capabilities = {
+            str(item).strip().lower()
+            for item in options.get("ollama_model_capabilities") or []
+        }
+        if "thinking" in capabilities or options.get("think_explicit"):
+            return bool(options.get("think", False))
+        return None
+
+
+__all__ = [
+    "INTERNAL_REASONING_EFFORT_KEY",
+    "OllamaThinkingPolicy",
+    "normalized_model_id",
+    "request_effort",
+    "thinking_disabled",
+]

package/ciel_runtime_support/protocols/anthropic_thinking_policy.py

@@ -14,6 +14,19 @@ from typing import Any
 
 
 THINKING_BLOCK_TYPES: tuple[str, ...] = ("thinking", "redacted_thinking")
+INTERNAL_REASONING_EFFORT_KEY = "ciel_runtime_reasoning_effort"
+
+
+def preserve_reasoning_effort(body: dict[str, Any], projected: dict[str, Any]) -> dict[str, Any]:
+    """Carry a removed client effort hint without exposing it on provider wires."""
+
+    thinking = body.get("thinking")
+    if not isinstance(thinking, dict) or thinking.get("effort") is None:
+        return projected
+    metadata = projected.get("metadata")
+    projected_metadata = dict(metadata) if isinstance(metadata, dict) else {}
+    projected_metadata[INTERNAL_REASONING_EFFORT_KEY] = str(thinking["effort"])
+    return {**projected, "metadata": projected_metadata}
 
 
 def message_content_blocks(message: dict[str, Any]) -> list[Any]:
@@ -193,6 +206,7 @@ class AnthropicThinkingPolicy:
                 return body
             projected = dict(body)
             projected.pop("thinking", None)
+            projected = preserve_reasoning_effort(body, projected)
             self._ports.log(
                 "INFO",
                 "removed top-level Anthropic thinking request but preserved thinking blocks "
@@ -202,6 +216,7 @@ class AnthropicThinkingPolicy:
             return projected
         projected = dict(strip_thinking_blocks(body))
         projected.pop("thinking", None)
+        projected = preserve_reasoning_effort(body, projected)
         self._ports.log(
             "WARN",
             "removed Anthropic thinking request and thinking content blocks for "

package/ciel_runtime_support/protocols/conversation_turn_policy.py

@@ -550,6 +550,20 @@ class ConversationTurnPolicy:
                     latest = current
         return latest
 
+    def latest_tool_result_message_index(self, body: dict[str, Any]) -> int | None:
+        messages = body.get("messages") or []
+        for index in range(len(messages) - 1, -1, -1):
+            message = messages[index]
+            if not isinstance(message, dict) or message.get("role") != "user":
+                continue
+            content = message.get("content")
+            if isinstance(content, list) and any(
+                isinstance(block, dict) and block.get("type") == "tool_result"
+                for block in content
+            ):
+                return index
+        return None
+
     def latest_user_tool_result_text(self, body: dict[str, Any]) -> str:
         latest = ""
         for message in body.get("messages") or []:
@@ -730,6 +744,18 @@ class ConversationTurnPolicy:
         if "TaskList" in latest_names:
             if not self.tasklist_result_has_active_work(latest_result_text):
                 return False
+            # A synthesized TaskList is a one-shot recovery prompt. If the model
+            # answers that result with visible status prose instead of choosing an
+            # actionable tool, end the turn. Claude Code rewrites tool IDs in its
+            # transcript, so counting synthetic ID prefixes cannot reliably bound
+            # this loop.
+            if latest_names == ["TaskList"] and response_text.strip():
+                intent_index = self.latest_user_intent_message_index(body)
+                result_index = self.latest_tool_result_message_index(body)
+                if result_index is not None and (
+                    intent_index is None or result_index > intent_index
+                ):
+                    return False
             max_keepalive = 6
             intent_index = self.latest_user_intent_message_index(body)
             if (

package/ciel_runtime_support/provider_config_mutations.py

@@ -21,6 +21,24 @@ class ProviderOptionPolicy:
     sampling: ProviderSamplingPolicy
 
 
+def _set_ollama_option_explicit(
+    config: dict[str, Any], key: str, explicit: bool
+) -> None:
+    keys = {
+        str(item)
+        for item in config.get("ollama_explicit_options") or []
+        if str(item).strip()
+    }
+    if explicit:
+        keys.add(key)
+    else:
+        keys.discard(key)
+    if keys:
+        config["ollama_explicit_options"] = sorted(keys)
+    else:
+        config.pop("ollama_explicit_options", None)
+
+
 def apply_ollama_option(
     pcfg: dict[str, Any], token: str, *, policy: ProviderOptionPolicy
 ) -> None:
@@ -42,10 +60,13 @@ def apply_ollama_option(
         elif key in ("max_output_tokens", "max_tokens", "maxtoken", "max_token", "num_predict"):
             pcfg.pop("max_output_tokens", None)
             pcfg.setdefault("ollama_options", {}).pop("num_predict", None)
+            pcfg.pop("output_tokens_explicit", None)
+            _set_ollama_option_explicit(pcfg, "num_predict", False)
         elif key in ("keep_alive", "keepalive"):
             pcfg.pop("keep_alive", None)
         elif key == "think":
             pcfg["think"] = False
+            pcfg.pop("think_explicit", None)
         elif key in ("stream", "stream_enabled"):
             pcfg["stream_enabled"] = True
         elif key in ("stream_word_chunking", "word_chunking", "stream_chunk", "stream_words"):
@@ -59,6 +80,7 @@ def apply_ollama_option(
             pcfg["rate_limit_status"] = False
         else:
             pcfg.setdefault("ollama_options", {}).pop(key, None)
+            _set_ollama_option_explicit(pcfg, key, False)
         return
     if "=" not in token:
         raise SystemExit(f"Expected key=value or unset:key, got: {token}")
@@ -119,9 +141,12 @@ def apply_ollama_option(
             raise SystemExit("max_tokens/num_predict must be a positive integer")
         pcfg["max_output_tokens"] = fixed
         pcfg.setdefault("ollama_options", {})["num_predict"] = fixed
+        pcfg["output_tokens_explicit"] = True
+        _set_ollama_option_explicit(pcfg, "num_predict", True)
         return
     if key == "think":
         pcfg["think"] = bool(value)
+        pcfg["think_explicit"] = True
         return
     if key in ("stream", "stream_enabled"):
         pcfg["stream_enabled"] = parse_bool(value, default=True)
@@ -145,8 +170,10 @@ def apply_ollama_option(
     opts = pcfg.setdefault("ollama_options", {})
     if value is None:
         opts.pop(key, None)
+        _set_ollama_option_explicit(pcfg, key, False)
     else:
         opts[key] = value
+        _set_ollama_option_explicit(pcfg, key, True)
 
 
 def apply_provider_option(
@@ -285,6 +312,7 @@ def apply_provider_option(
         if not fixed:
             raise SystemExit("max_output_tokens must be a positive integer")
         pcfg["max_output_tokens"] = fixed
+        pcfg["output_tokens_explicit"] = True
         return
     if key in ("timeout", "timeout_ms", "request_timeout", "request_timeout_ms"):
         fixed = positive_int(value)

package/ciel_runtime_support/provider_request_builder.py

@@ -28,7 +28,9 @@ class OllamaRequestPorts:
     extra_options: Callable[[dict[str, Any]], dict[str, Any]]
     context_limit: Callable[[dict[str, Any]], int]
     num_ctx: Callable[..., int]
-    think_enabled: Callable[[str | None, dict[str, Any]], bool]
+    think_value: Callable[
+        [str, str | None, dict[str, Any], dict[str, Any]], bool | str | None
+    ]
     # Model-card provenance gate for num_predict: None = omit the parameter
     # entirely so the server default applies (operator 2026-07-29). The
     # default implementation passes the capped value through unchanged.
@@ -177,13 +179,19 @@ class ProviderRequestBuilder:
             "model": model,
             "messages": messages,
             "stream": stream,
-            "think": self.ollama.think_enabled(model, config),
         }
+        think = self.ollama.think_value(provider, model, config, body)
+        if think is not None:
+            request["think"] = think
         if config.get("keep_alive"):
             request["keep_alive"] = str(config["keep_alive"])
         if tools:
             request["tools"] = tools
         options = self.ollama.extra_options(config)
+        # num_predict is governed by the output-budget policy below. Remove a
+        # persisted/default copy so a deliberate provider-default decision can
+        # actually omit it from the wire request.
+        options.pop("num_predict", None)
         token_cache: dict[int, int] = {}
         num_ctx = self.ollama.num_ctx(config, payload, _token_cache=token_cache)
         num_predict = self.budget.cap_output(

package/ciel_runtime_support/providers/ollama.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field, replace
+from typing import Any, Mapping
 
 from ..architecture import (
     ProviderCapabilities,
@@ -16,6 +17,7 @@ from ..architecture import (
 )
 from .base import HttpBearerProviderAdapter, provider_configuration
 from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
+from ..ollama_thinking import OllamaThinkingPolicy, normalized_model_id
 
 
 @dataclass(frozen=True)
@@ -38,12 +40,7 @@ class OllamaProviderAdapter(HttpBearerProviderAdapter):
             request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
             stream_enabled=True,
             stream_word_chunking=False,
-            ollama_options={
-                "temperature": 0.7,
-                "top_p": 0.8,
-                "top_k": 40,
-                "num_predict": 4096,
-            },
+            ollama_options={},
         )
     )
     send_placeholder_key: bool = True
@@ -82,6 +79,11 @@ class OllamaProviderAdapter(HttpBearerProviderAdapter):
         del config
         return "ollama_unslug"
 
+    def ollama_think_value(
+        self, config: ProviderConfig, model: str, request: Mapping[str, Any]
+    ) -> bool | str | None:
+        return OllamaThinkingPolicy().value(config.options, model, request)
+
     def option_presentation_policy(
         self, config: ProviderConfig
     ) -> ProviderOptionPresentationPolicy:
@@ -121,7 +123,7 @@ class OllamaCloudProviderAdapter(OllamaProviderAdapter):
     configuration_defaults_value: dict = field(
         default_factory=lambda: provider_configuration(
             "glm-5.1",
-            custom_models=("glm-5.1",),
+            custom_models=("glm-5.1", "deepseek-v4-flash:0731"),
             rate_limit_rpm=0,
             rate_limit_status=False,
             num_ctx="auto",
@@ -132,12 +134,7 @@ class OllamaCloudProviderAdapter(OllamaProviderAdapter):
             request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
             stream_enabled=True,
             stream_word_chunking=False,
-            ollama_options={
-                "temperature": 0.7,
-                "top_p": 0.8,
-                "top_k": 40,
-                "num_predict": 4096,
-            },
+            ollama_options={},
         )
     )
     capabilities_value: ProviderCapabilities = field(
@@ -159,8 +156,48 @@ class OllamaCloudProviderAdapter(OllamaProviderAdapter):
 
     def normalize_model_id(self, model_id: str) -> str:
         normalized = super().normalize_model_id(model_id)
+        if normalized.endswith("-cloud") and ":" in normalized:
+            return normalized[:-6]
         return normalized[:-6] if normalized.endswith(":cloud") else normalized
 
+    @staticmethod
+    def _is_deepseek_v4_flash_0731(model_id: str) -> bool:
+        return normalized_model_id(model_id) == "deepseek-v4-flash:0731"
+
+    def model_configuration_profile(
+        self, config: ProviderConfig
+    ) -> tuple[Mapping[str, Any], str | None]:
+        if not self._is_deepseek_v4_flash_0731(config.model):
+            return {}, None
+        return (
+            {
+                "context_window": 1_000_000,
+                "max_model_len": 1_000_000,
+                "model_profile": "deepseek-v4-flash-0731-cloud-1m",
+                "claude_code_supported_capabilities": [
+                    "effort",
+                    "max_effort",
+                    "thinking",
+                ],
+            },
+            "DeepSeek V4 Flash 0731 Cloud profile applied: 1M context and "
+            "three-mode reasoning; Max thinking is the default for a new selection.",
+        )
+
+    def model_selection_config_updates(
+        self, config: ProviderConfig, model_id: str
+    ) -> Mapping[str, Any]:
+        if not self._is_deepseek_v4_flash_0731(model_id):
+            return super().model_selection_config_updates(config, model_id)
+        return {
+            "think": True,
+            "effort_level": "max",
+            "haiku_model": model_id,
+            "opus_model": model_id,
+            "sonnet_model": model_id,
+            "subagent_model": model_id,
+        }
+
     def launch_model_strategy(self, config: ProviderConfig) -> str:
         del config
         return "alias"

package/ciel_runtime_support/providers/ollama_context.py

@@ -63,16 +63,9 @@ class OllamaRequestContextPolicy:
             return self.positive_int(override)
         raw = config.get("num_ctx", "auto")
         if isinstance(raw, str) and raw.strip().lower() in {"", "auto", "dynamic"}:
-            provider_limit = self.provider_context_limit(config)
-            if provider_limit:
-                return self.effective_context_limit(config) or provider_limit
-            # No model-card context is available (no /api/show max_model_len, no
-            # catalog/library match, no model-id hint). Do NOT invent a window:
-            # estimating from the payload and clamping to num_ctx_min/max used
-            # to send a guessed num_ctx the model card never advertised
-            # (operator 2026-07-29: if the model card does not provide
-            # num_ctx/num_predict, the parameter must be omitted so the server
-            # default applies — never substituted with our own guess).
+            # Auto means provider-owned. Model-card limits remain available for
+            # local budgeting/status, but are not echoed back as request
+            # overrides. Missing values are omitted rather than sent as null.
             return None
         return self.positive_int(raw)
 
@@ -81,23 +74,15 @@ class OllamaRequestContextPolicy:
         config: dict[str, Any],
         capped: int | None,
     ) -> int | None:
-        """num_predict with model-card provenance gating.
-
-        An explicit user-configured value always passes through. But the
-        adapter-default ollama_options.num_predict (a heuristic, not a model
-        card value) is only sent when a model-card context exists for the
-        current model — otherwise the parameter is omitted and the server
-        default applies (operator 2026-07-29).
-        """
+        """Return a wire output limit only when the user explicitly set one."""
+        if not config.get("output_tokens_explicit") and "num_predict" not in set(
+            config.get("ollama_transient_options") or []
+        ):
+            return None
         value = self.positive_int(capped)
         if not value:
             return None
-        configured = self.positive_int(config.get("ollama_options", {}).get("num_predict") if isinstance(config.get("ollama_options"), dict) else None) or self.positive_int(config.get("max_output_tokens"))
-        if configured:
-            return value
-        if self.provider_context_limit(config):
-            return value
-        return None
+        return value
 
     def num_ctx_status(self, config: dict[str, Any]) -> str:
         raw = config.get("num_ctx", "auto")
@@ -118,6 +103,24 @@ class OllamaRequestContextPolicy:
             return {}
         return {str(key): value for key, value in raw.items() if value is not None}
 
+    @classmethod
+    def wire_options(cls, config: dict[str, Any]) -> dict[str, Any]:
+        """Project only explicit/transient overrides onto an Ollama request."""
+        allowed = {
+            str(key)
+            for source in (
+                config.get("ollama_explicit_options"),
+                config.get("ollama_transient_options"),
+            )
+            for key in (source if isinstance(source, (list, tuple, set)) else [])
+            if str(key).strip()
+        }
+        return {
+            key: value
+            for key, value in cls.extra_options(config).items()
+            if key in allowed and value is not None
+        }
+
     def options_status(self, config: dict[str, Any]) -> str:
         options = self.extra_options(config)
         if not options:
@@ -179,6 +182,7 @@ class OllamaRequestContextPolicy:
         if configured_num_predict:
             options["num_predict"] = min(configured_num_predict, output_cap)
         retry_config["ollama_options"] = options
+        retry_config["ollama_transient_options"] = ["num_predict"]
         return retry_config
 
     def context_limit_for_budget(self, config: dict[str, Any]) -> int:

package/ciel_runtime_support/providers/ollama_runtime.py

@@ -86,6 +86,14 @@ class OllamaRuntimeService:
             output["max_model_len"] = max_context
         if num_predict:
             output["num_predict"] = num_predict
+        capabilities = data.get("capabilities")
+        if isinstance(capabilities, list):
+            output["capabilities"] = [
+                str(item).strip().lower() for item in capabilities if str(item).strip()
+            ]
+        architecture = str(model_info.get("general.architecture") or "").strip().lower()
+        if architecture:
+            output["architecture"] = architecture
         return output
 
     @staticmethod

package/ciel_runtime_support/runtime_constants.py

@@ -93,7 +93,7 @@ OFFICIAL_CHANNEL_PLUGINS = {
 }
 
 APP_NAME = "Ciel Runtime"
-VERSION = "0.2.1"
+VERSION = "0.2.2"
 CREDITS = "Credits: One Ciel LLC"
 PRELAUNCH_CANCEL = 10
 PRELAUNCH_LAUNCH_CODEX = 11
@@ -161,6 +161,8 @@ ROUTED_COMPAT_PROMPT = (
 NON_ANTHROPIC_COMPAT_PROMPT = ROUTED_COMPAT_PROMPT
 LANGUAGES = {"en": "English", "ko": "한국어", "ja": "日本語", "zh": "中文"}
 MODEL_PRESETS: dict[str, dict[str, Any]] = {
+    "deepseek-v4-flash:0731": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},
+    "deepseek-v4-flash:0731-cloud": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},
     "glm-5.2": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},
     "glm-5.2:cloud": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},
     "glm-4.7": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 131072},

package/ciel_runtime_support/runtime_launch.py

@@ -891,16 +891,24 @@ def run_codex(
     use_native_codex = direct_native_codex_enabled(provider, pcfg)
     use_codex_routed = codex_routed_enabled(provider, pcfg)
     launch_cwd = Path.cwd()
-    mapped_continue = any(note.startswith("--continue -> resume --last") for note in codex_passthrough_notes)
-    if not use_native_codex and mapped_continue:
-        try:
-            resume_index = codex_passthrough.index("resume")
-        except ValueError:
-            resume_index = -1
-        if resume_index >= 0 and resume_index + 1 < len(codex_passthrough):
-            if codex_passthrough[resume_index + 1] == "--last":
-                del codex_passthrough[resume_index + 1]
-                codex_passthrough_notes.append("routed --continue -> provider-independent session picker")
+    mapped_continue = "--continue -> resume --last" in codex_passthrough_notes
+    if mapped_continue:
+        codex_passthrough.remove("--last")
+        session_id = select_codex_resume_session(
+            env,
+            include_non_interactive="--include-non-interactive" in codex_passthrough,
+            passthrough=codex_passthrough,
+            cwd=launch_cwd,
+            select_latest=True,
+        )
+        if not session_id:
+            return 0
+        codex_passthrough = codex_resume_with_session_id(
+            codex_passthrough, session_id
+        )
+        codex_passthrough_notes.append(
+            "resume --last -> latest current-directory Codex session ID"
+        )
     if not use_native_codex and codex_resume_picker_requested(codex_passthrough):
         session_id = select_codex_resume_session(
             env,

package/ciel_runtime_support/runtime_restart.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable, MutableMapping, Sequence
 from dataclasses import dataclass
+import os
 from pathlib import Path
 
 
@@ -27,6 +28,7 @@ class RuntimeRestartSettings:
     argv: Sequence[str]
     python_executable: str
     environ: MutableMapping[str, str]
+    platform_name: str = os.name
 
 
 @dataclass(frozen=True, slots=True)
@@ -57,9 +59,25 @@ class RuntimeRestartService:
         )
         package_script = root / "ciel_runtime.py" if root else None
         if package_script and package_script.exists():
+            argv = [
+                self.settings.python_executable,
+                str(package_script),
+                "cli",
+                *user_args,
+            ]
+            if self.settings.platform_name == "nt":
+                # npm replaces the package that contains the currently running
+                # Python script.  Re-execing that process on Windows can retain
+                # the pre-update console/process state and leave the relaunched
+                # menu unable to advance to the selected runtime.  A fresh
+                # Python process matches a manual restart and cleanly loads the
+                # newly installed package before the updater exits.
+                raise SystemExit(
+                    self.ports.call(argv, env=dict(self.settings.environ))
+                )
             self.ports.execv(
                 self.settings.python_executable,
-                [self.settings.python_executable, str(package_script), "cli", *user_args],
+                argv,
             )
             return
         launcher = self.ports.find_executable("ciel-runtime")

package/ciel_runtime_support/streaming_anthropic.py

@@ -722,6 +722,26 @@ def rebatch_anthropic_sse_text(
                     patched_message_delta("end_turn"),
                 )
                 return
+            if (
+                stop_reason == "end_turn"
+                and source_body is not None
+                and should_auto_exit_plan_mode(source_body, text_so_far, tool_calls)
+            ):
+                for index in list(text_buffers.keys()):
+                    flush_buffer(index, force=True)
+                router_log(
+                    "WARN",
+                    "auto-synthesized ExitPlanMode from explicit plan-exit text "
+                    "with Anthropic-compatible end_turn",
+                )
+                emit_exit_plan_mode_tool(next_content_index)
+                next_content_index += 1
+                saw_tool_use = True
+                pending_message_delta = (
+                    event_type,
+                    patched_message_delta("tool_use"),
+                )
+                return
             if emitted_tool_use and stop_reason == "end_turn":
                 patched = dict(event)
                 patched_delta = dict(delta)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oneciel-ai/ciel-runtime",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Universal AI coding-agent runtime and model-routing layer for Claude, Codex, AGY, and compatible runtimes.",
   "license": "MIT",
   "author": "One Ciel LLC",