ms-tau-sdk 1.2.7.dev10__tar.gz → 1.2.7.dev11__tar.gz

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 1.2.7.dev10
+Version: 1.2.7.dev11
 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-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/pyproject.toml

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

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/api/a2a.py

@@ -17,6 +17,7 @@ from typing import Annotated, Any
 import structlog
 from fastapi import APIRouter, Depends, Header, HTTPException, Query, Request
 from fastapi.responses import JSONResponse, StreamingResponse
+from structlog.contextvars import bind_contextvars
 from tau_agent.types import JSONValue
 
 from ms_tau_sdk.backend.client import MainSequenceClient
@@ -1054,6 +1055,13 @@ async def _execute_task(
     dispatch_uid: str | None = None,
     claim: _ClaimedTask | None = None,
 ) -> dict[str, Any]:
+    bind_contextvars(
+        a2a_task_id=task.task_id,
+        task_uid=task.uid,
+        a2a_context_id=task.context_id,
+        session_uid=task.context_id,
+        agent_session_uid=task.context_id,
+    )
     if claim is None:
         claim = await _claim_backend_task(
             client,

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/api/models.py

@@ -54,3 +54,10 @@ class CancelRequest(ApiModel):
         )
     )
     message: str | None = None
+
+
+class SessionModelSelection(ApiModel):
+    session_uid: str = Field(validation_alias=AliasChoices("sessionUid", "session_uid"))
+    provider: str
+    model: str
+    thinking_level: str | None = Field(default=None, validation_alias="thinkingLevel")

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/api/sessions.py

@@ -4,14 +4,14 @@ from __future__ import annotations
 
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, HTTPException, Query
 
 from ms_tau_sdk.backend.client import MainSequenceClient
 from ms_tau_sdk.runtime.manager import SessionRuntimeManager
 from ms_tau_sdk.settings import TauSDKSettings
 
 from .dependencies import backend, runtime_manager, settings
-from .models import CancelRequest
+from .models import CancelRequest, SessionModelSelection
 
 router = APIRouter(prefix="/api/chat")
 BackendDep = Annotated[MainSequenceClient, Depends(backend)]
@@ -38,6 +38,39 @@ async def session_model(
     }
 
 
+@router.get("/model-providers")
+async def model_providers(client: BackendDep, config: SettingsDep) -> dict[str, object]:
+    if not config.local_mode:
+        raise HTTPException(status_code=409, detail="Provider catalog is local-mode only")
+    return await client.list_model_providers()
+
+
+@router.put("/session-model")
+async def select_session_model(
+    body: SessionModelSelection,
+    manager: RuntimeManagerDep,
+    config: SettingsDep,
+) -> dict[str, object]:
+    if not config.local_mode:
+        raise HTTPException(status_code=409, detail="Model selection is local-mode only")
+    session_uid = config.local_session_uid(body.session_uid)
+    await manager.change_session_model(
+        session_uid,
+        provider=body.provider,
+        model=body.model,
+        thinking_level=body.thinking_level,
+    )
+    session = await manager.backend.get_session(session_uid)
+    return {
+        "sessionUid": session_uid,
+        "model": {
+            "provider": session.active_provider,
+            "model": session.active_model,
+            "thinkingLevel": session.active_thinking,
+        },
+    }
+
+
 @router.post("/session/cancel")
 async def cancel_session(
     body: CancelRequest,

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/backend/client.py

@@ -50,6 +50,7 @@ from .models import (
 )
 from .routes import (
     AGENT_TASKS,
+    MODEL_PROVIDERS,
     agent_session,
     agent_session_agent_card,
     agent_session_entries,
@@ -283,6 +284,13 @@ class MainSequenceClient:
                 detail=error.errors(include_input=False),
             ) from error
 
+    async def list_model_providers(self) -> dict[str, Any]:
+        """Read the authenticated user's safe provider catalog from Main Sequence."""
+        data = await self._request("GET", MODEL_PROVIDERS, idempotent=True)
+        if not isinstance(data, dict) or not isinstance(data.get("providers"), list):
+            raise BackendError("Backend model-provider catalog response is invalid")
+        return data
+
     async def update_session_config(
         self,
         session_uid: str,

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/backend/local.py

@@ -109,6 +109,9 @@ class LocalDevelopmentBackend(MainSequenceClient):
     async def aclose(self) -> None:
         await self._services.aclose()
 
+    async def list_model_providers(self) -> dict[str, Any]:
+        return await self._services.list_model_providers()
+
     async def _ensure_initialized(self) -> None:
         if self._initialized:
             return
@@ -269,8 +272,8 @@ class LocalDevelopmentBackend(MainSequenceClient):
             raise BackendConflictError("Local provider/model selection is not configured")
         return provider, model, self.settings.local_thinking
 
-    def _runtime_config_sha256(self) -> str:
-        provider, model, thinking = self._selection()
+    def _runtime_config_sha256(self, selection: tuple[str, str, str | None] | None = None) -> str:
+        provider, model, thinking = selection or self._selection()
         payload = json.dumps(
             {"provider": provider, "model": model, "thinking": thinking},
             sort_keys=True,
@@ -278,8 +281,10 @@ class LocalDevelopmentBackend(MainSequenceClient):
         ).encode("utf-8")
         return "sha256:" + hashlib.sha256(payload).hexdigest()
 
-    async def _hydrate_evidence(self, *, holder_id: str) -> ProviderExecutionEvidence:
-        provider, model, thinking = self._selection()
+    async def _hydrate_evidence(
+        self, *, holder_id: str, selection: tuple[str, str, str | None] | None = None
+    ) -> ProviderExecutionEvidence:
+        provider, model, thinking = selection or self._selection()
         evidence = await self._services.hydrate_local_provider_credential(
             provider,
             model=model,
@@ -342,16 +347,24 @@ class LocalDevelopmentBackend(MainSequenceClient):
         holder_id: str,
     ) -> ProviderExecutionEvidence:
         del agent_uid
-        selected_provider, selected_model, _thinking = self._selection()
+        selected_provider, selected_model, selected_thinking = self._selection()
+        if session_uid is not None:
+            session = await self.get_session(session_uid)
+            selected_provider = session.active_provider or ""
+            selected_model = session.active_model or ""
+            selected_thinking = session.active_thinking
         if provider != selected_provider or model != selected_model:
             raise BackendConflictError(
-                "Local provider refresh does not match the configured selection"
+                "Local provider refresh does not match the session selection"
             )
         if session_uid is not None:
             canonical = self.settings.local_session_uid(session_uid)
             if canonical != session_uid:
                 raise SessionNotFoundError("Local session identifier is invalid")
-        return await self._hydrate_evidence(holder_id=holder_id)
+        return await self._hydrate_evidence(
+            holder_id=holder_id,
+            selection=(selected_provider, selected_model, selected_thinking),
+        )
 
     async def get_session(self, session_uid: str) -> AgentSession:
         def operation() -> AgentSession:
@@ -374,11 +387,35 @@ class LocalDevelopmentBackend(MainSequenceClient):
         model: str,
         thinking_level: str | None,
     ) -> AgentSession:
-        selected = self._selection()
-        if (provider, model, thinking_level) != selected:
-            raise BackendConflictError(
-                "Local session selection is fixed by TAU_LOCAL_PROVIDER and TAU_LOCAL_MODEL"
-            )
+        if not provider or not model:
+            raise BackendConflictError("A provider and model are required")
+        selection = (provider, model, thinking_level)
+        await self._hydrate_evidence(
+            holder_id=f"local-selection-{self.settings.workspace_digest}",
+            selection=selection,
+        )
+
+        def operation() -> None:
+            with closing(self._connect()) as connection, connection:
+                row = connection.execute(
+                    "SELECT runtime_activity FROM sessions WHERE uid = ?", (session_uid,)
+                ).fetchone()
+                if row is None:
+                    raise SessionNotFoundError(f"Local session not found: {session_uid}")
+                if row["runtime_activity"] == "working":
+                    raise BackendConflictError("Cannot change a model while the session is working")
+                connection.execute(
+                    "UPDATE sessions SET provider = ?, model = ?, thinking = ?, "
+                    "runtime_config_sha256 = ?, updated_at = ? WHERE uid = ?",
+                    (
+                        *selection,
+                        self._runtime_config_sha256(selection),
+                        _iso(_utcnow()),
+                        session_uid,
+                    ),
+                )
+
+        await self._run(operation)
         return await self.get_session(session_uid)
 
     async def get_agent_card(self, session_uid: str) -> AgentCardEnvelope:
@@ -669,13 +706,23 @@ class LocalDevelopmentBackend(MainSequenceClient):
         session_uid: str,
         request: TauRuntimeBootstrapRequest,
     ) -> TauRuntimeBootstrap:
-        provider, model, thinking = self._selection()
-        evidence = await self._hydrate_evidence(holder_id=request.holder_id)
+        def stored_selection() -> tuple[str, str, str | None]:
+            with closing(self._connect()) as connection:
+                row = connection.execute(
+                    "SELECT provider, model, thinking FROM sessions WHERE uid = ?", (session_uid,)
+                ).fetchone()
+                if row is None:
+                    return self._selection()
+                return str(row["provider"]), str(row["model"]), row["thinking"]
+
+        selection = await self._run(stored_selection)
+        provider, model, thinking = selection
+        evidence = await self._hydrate_evidence(holder_id=request.holder_id, selection=selection)
 
         def operation() -> TauRuntimeBootstrap:
             now = _utcnow()
             expires = now + timedelta(seconds=request.ttl_seconds)
-            runtime_config_sha256 = self._runtime_config_sha256()
+            runtime_config_sha256 = self._runtime_config_sha256(selection)
             with closing(self._connect()) as connection, connection:
                 connection.execute("BEGIN IMMEDIATE")
                 row = connection.execute(

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/backend/routes.py

@@ -9,6 +9,7 @@ API_V1_PREFIX = "/api/v1"
 RUNTIME_CREDENTIAL_TOKEN = f"{API_V1_PREFIX}/runtime-credentials/token/"
 AGENT_SESSIONS = f"{API_V1_PREFIX}/agent-sessions/"
 MODEL_PROVIDER_CREDENTIALS = f"{API_V1_PREFIX}/model-provider-credentials/"
+MODEL_PROVIDERS = f"{API_V1_PREFIX}/model-providers/"
 AGENT_TASKS = f"{API_V1_PREFIX}/agent-tasks/"
 
 type RuntimeLeaseOperation = Literal["acquire", "renew", "release"]

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/runtime/manager.py

@@ -970,6 +970,9 @@ class SessionRuntimeManager:
                 "principal_type",
                 "coding_agent_service_uid",
                 "agent_session_uid",
+                "a2a_task_id",
+                "a2a_context_id",
+                "task_uid",
                 "agent_uid",
                 "agent_run_uid",
                 "turn_uid",
@@ -1168,9 +1171,71 @@ class SessionRuntimeManager:
         with bound_contextvars(session_uid=session_uid):
             await self._evict_with_context(session_uid)
 
-    async def _evict_with_context(self, session_uid: str) -> None:
+    async def change_session_model(
+        self,
+        session_uid: str,
+        *,
+        provider: str,
+        model: str,
+        thinking_level: str | None,
+    ) -> None:
+        """Switch an idle session and reload it with backend-authorized evidence."""
+        if not self.settings.local_mode:
+            raise BackendConflictError("Board model selection requires local mode")
+        async with self._registry_lock:
+            load_lock = self._load_locks.setdefault(session_uid, asyncio.Lock())
+        async with load_lock:
+            runtime = self._runtimes.get(session_uid)
+            if runtime is None:
+                runtime = await self._load(session_uid)
+            async with runtime.lock:
+                if runtime.coding_session.is_running or runtime.runtime_activity == "working":
+                    raise BackendConflictError("Cannot change a model while the session is working")
+                if runtime.persistence_task is not None:
+                    await asyncio.shield(runtime.persistence_task)
+                previous = await self.backend.get_session(session_uid)
+                if previous.active_provider is None or previous.active_model is None:
+                    raise BackendConflictError("Session has no model to restore")
+                runtime.evicting = True
+                try:
+                    await self.backend.update_session_config(
+                        session_uid,
+                        provider=provider,
+                        model=model,
+                        thinking_level=thinking_level,
+                    )
+                except BaseException:
+                    runtime.evicting = False
+                    raise
+            await self._evict_with_context(session_uid, force=True)
+            try:
+                await self._load(session_uid)
+            except Exception:
+                try:
+                    await self.backend.update_session_config(
+                        session_uid,
+                        provider=previous.active_provider,
+                        model=previous.active_model,
+                        thinking_level=previous.active_thinking,
+                    )
+                    await self._load(session_uid)
+                except Exception:
+                    logger.exception(
+                        "runtime.session.model_change_rollback_failed",
+                        session_uid=session_uid,
+                    )
+                raise
+            logger.info(
+                "runtime.session.model_changed",
+                session_uid=session_uid,
+                provider=provider,
+                model=model,
+                thinking_level=thinking_level,
+            )
+
+    async def _evict_with_context(self, session_uid: str, *, force: bool = False) -> None:
         runtime = self._runtimes.get(session_uid)
-        if runtime is None or runtime.evicting:
+        if runtime is None or (runtime.evicting and not force):
             return
         runtime.evicting = True
         if runtime.lock.locked():

{ms_tau_sdk-1.2.7.dev10 → ms_tau_sdk-1.2.7.dev11}/src/ms_tau_sdk/runtime/session.py

@@ -62,6 +62,8 @@ class ActiveSessionRuntime:
         if self.persistence_task is not None:
             await asyncio.shield(self.persistence_task)
         async with self.lock:
+            if self.evicting:
+                raise RuntimeError("Session runtime is being reconfigured")
             self.last_used_at = time.monotonic()
             settled_event: TauRuntimeEvent | None = None
             if provenance: