ms-tau-sdk 2.0.8.dev46__tar.gz → 2.0.8.dev47__tar.gz

{ms_tau_sdk-2.0.8.dev46 → ms_tau_sdk-2.0.8.dev47}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+- **A thinking level the model cannot run no longer stops the turn
+  ([#82](https://github.com/mainsequence-sdk/ms-tau-sdk/issues/82)).** The platform can offer
+  levels this Tau release cannot run, such as `max` for the GPT-5.6 Codex models; every turn of
+  those models failed with "thinking levels exceed Tau execution support". Tau now uses only the
+  levels both support. A selected level outside them runs at the provider's default (`medium` for
+  Codex), else Tau's default, else the first shared level, and logs
+  `providers.thinking_level_unavailable`. `GET` and `PUT /api/chat/session-model` report the level
+  a loaded session runs at, and Tau Board's picker follows it.
 - **A new local chat reports and accepts its model before the first message
   ([#50](https://github.com/mainsequence-sdk/ms-tau-sdk/issues/50)).** In local mode,
   `GET /api/chat/session-model` for a session that has not had a turn returns the model it would

{ms_tau_sdk-2.0.8.dev46 → ms_tau_sdk-2.0.8.dev47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 2.0.8.dev46
+Version: 2.0.8.dev47
 Summary: Workspace-bound Tau application primitives for Main Sequence projects
 Project-URL: Changelog, https://github.com/mainsequence-sdk/ms-tau-sdk/blob/development/CHANGELOG.md
 Project-URL: Documentation, https://github.com/mainsequence-sdk/ms-tau-sdk/tree/development/docs

{ms_tau_sdk-2.0.8.dev46 → ms_tau_sdk-2.0.8.dev47}/packages/tau-board/src/ms_tau_board/static/app.js

@@ -465,6 +465,9 @@ async function applyModelSelection(kind, sessionUid) {
     }
   } else if (current.status !== 404) throw new Error(errorMessage(await current.json().catch(() => ({})), current.status));
   const data = await json("/tau/api/chat/session-model", { method: "PUT", headers: tauHeaders(kind, { "Content-Type": "application/json" }), body: JSON.stringify({ sessionUid, provider: choice.provider, model: choice.model, thinkingLevel: choice.thinking || null }) });
+  // A level the model cannot run falls back to another; the picker follows what Tau runs.
+  choice.thinking = data.model.thinkingLevel || "";
+  $(`${kind}-thinking`).value = choice.thinking;
   $(`${kind}-effective`).textContent = `Tau confirmed ${data.model.provider} / ${data.model.model} / ${data.model.thinkingLevel || "default"}`;
   return data.sessionUid || sessionUid;
 }

{ms_tau_sdk-2.0.8.dev46 → ms_tau_sdk-2.0.8.dev47}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ms-tau-sdk"
-version = "2.0.8.dev46"
+version = "2.0.8.dev47"
 description = "Workspace-bound Tau application primitives for Main Sequence projects"
 readme = "README.md"
 requires-python = ">=3.13"

{ms_tau_sdk-2.0.8.dev46 → ms_tau_sdk-2.0.8.dev47}/src/ms_tau_sdk/api/sessions.py

@@ -40,9 +40,21 @@ def _session_model(
     }
 
 
+def _thinking_level(
+    manager: SessionRuntimeManager,
+    session_uid: str,
+    selected: str | None,
+) -> str | None:
+    # A loaded session runs a selected level its model cannot run at a fallback level instead.
+    if selected is None:
+        return None
+    return manager.running_thinking_level(session_uid) or selected
+
+
 @router.get("/session-model")
 async def session_model(
     client: BackendDep,
+    manager: RuntimeManagerDep,
     config: SettingsDep,
     session_uid: str = Query(alias="sessionUid"),
 ) -> dict[str, object]:
@@ -68,7 +80,7 @@ async def session_model(
         session_uid,
         provider=session.active_provider,
         model=session.active_model,
-        thinking_level=session.active_thinking,
+        thinking_level=_thinking_level(manager, session_uid, session.active_thinking),
         custom_id=session.custom_id,
     )
 
@@ -107,7 +119,7 @@ async def select_session_model(
         session_uid,
         provider=session.active_provider,
         model=session.active_model,
-        thinking_level=session.active_thinking,
+        thinking_level=_thinking_level(manager, session_uid, session.active_thinking),
         custom_id=session.custom_id,
     )
 

{ms_tau_sdk-2.0.8.dev46 → ms_tau_sdk-2.0.8.dev47}/src/ms_tau_sdk/providers/factory.py

@@ -9,6 +9,7 @@ from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 from urllib.parse import urlsplit
 
+import structlog
 from tau_agent.provider import ModelProvider
 from tau_ai.anthropic import AnthropicProvider
 from tau_ai.env import AnthropicConfig, OpenAICompatibleConfig
@@ -69,6 +70,27 @@ BLOCKED_CUSTOM_PROVIDER_HOSTS = frozenset(
     }
 )
 
+logger = structlog.get_logger(__name__)
+
+
+def _fall_back(
+    level: ThinkingLevel,
+    *,
+    selected: ThinkingLevel | None,
+    provider_name: str,
+    model: str,
+) -> ThinkingLevel:
+    """Use ``level`` in place of a selected level the model cannot run, and say so."""
+    if selected is not None:
+        logger.warning(
+            "providers.thinking_level_unavailable",
+            provider=provider_name,
+            model=model,
+            selected=selected,
+            used=level,
+        )
+    return level
+
 
 @dataclass(frozen=True, slots=True)
 class ProviderRuntime:
@@ -185,25 +207,26 @@ class ProviderFactory:
                     "Platform provider-control thinking levels contradict the "
                     "custom model reasoning capability"
                 )
-            if thinking_level and normalized_thinking not in projected_thinking:
-                supported = ", ".join(sorted(projected_thinking)) or "none"
-                raise ConfigurationError(
-                    f"Thinking level {normalized_thinking!r} is not supported by "
-                    f"{provider_name}:{model}; available levels: {supported}"
-                )
             self.validate_input_media(
                 provider_control,
                 media_types=media_types or set(),
             )
-            if thinking_level:
+            if thinking_level and normalized_thinking in projected_thinking:
                 return normalized_thinking
             if not projected_thinking or not provider_control.model.reasoning:
-                return DEFAULT_THINKING_LEVEL
-            if DEFAULT_THINKING_LEVEL in projected_thinking:
-                return DEFAULT_THINKING_LEVEL
-            if "off" in projected_thinking:
-                return "off"
-            return provider_control.model.thinking_levels[0]
+                default = DEFAULT_THINKING_LEVEL
+            elif DEFAULT_THINKING_LEVEL in projected_thinking:
+                default = DEFAULT_THINKING_LEVEL
+            elif "off" in projected_thinking:
+                default = "off"
+            else:
+                default = provider_control.model.thinking_levels[0]
+            return _fall_back(
+                default,
+                selected=normalized_thinking if thinking_level else None,
+                provider_name=provider_name,
+                model=model,
+            )
         if model not in provider.models:
             raise ConfigurationError(
                 f"Model is not configured for provider {provider_name}: {model}"
@@ -229,30 +252,32 @@ class ProviderFactory:
                 "Platform provider-control input capabilities exceed Tau execution support"
             )
         tau_thinking = set(self._thinking_levels(provider, model))
-        projected_thinking = set(provider_control.model.thinking_levels)
-        if not projected_thinking.issubset(tau_thinking):
-            raise ConfigurationError(
-                "Platform provider-control thinking levels exceed Tau execution support"
-            )
         if provider_control.model.reasoning and not tau_thinking:
             raise ConfigurationError(
                 "Platform provider-control reasoning capability exceeds Tau execution support"
             )
-        available = tau_thinking.intersection(projected_thinking)
-        if thinking_level and normalized_thinking not in available:
-            supported = ", ".join(sorted(available)) or "none"
-            raise ConfigurationError(
-                f"Thinking level {normalized_thinking!r} is not supported by "
-                f"{provider_name}:{model}; available levels: {supported}"
-            )
+        # The platform may offer levels this Tau release cannot run; only shared ones are used.
+        available = [
+            level for level in provider_control.model.thinking_levels if level in tau_thinking
+        ]
         self.validate_input_media(
             provider_control,
             media_types=media_types or set(),
         )
-        if thinking_level:
+        if thinking_level and normalized_thinking in available:
             return normalized_thinking
-        default = provider.thinking_default
-        return default if default in available else DEFAULT_THINKING_LEVEL
+        if provider.thinking_default is not None and provider.thinking_default in available:
+            default = provider.thinking_default
+        elif DEFAULT_THINKING_LEVEL in available or not available:
+            default = DEFAULT_THINKING_LEVEL
+        else:
+            default = available[0]
+        return _fall_back(
+            default,
+            selected=normalized_thinking if thinking_level else None,
+            provider_name=provider_name,
+            model=model,
+        )
 
     def validate_input_media(
         self,

{ms_tau_sdk-2.0.8.dev46 → ms_tau_sdk-2.0.8.dev47}/src/ms_tau_sdk/runtime/manager.py

@@ -2205,6 +2205,11 @@ class SessionRuntimeManager:
         with bound_contextvars(session_uid=session_uid):
             await self._evict_with_context(session_uid)
 
+    def running_thinking_level(self, session_uid: str) -> str | None:
+        """The thinking level a loaded session runs at, which may differ from its selection."""
+        runtime = self._runtimes.get(session_uid)
+        return runtime.coding_session.thinking_level if runtime is not None else None
+
     async def change_session_model(
         self,
         session_uid: str,