ms-tau-sdk 1.2.7.dev7__tar.gz → 1.2.7.dev8__tar.gz

{ms_tau_sdk-1.2.7.dev7 → ms_tau_sdk-1.2.7.dev8}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+- Stopped discarding the only diagnostic a message-less provider failure carries. When Tau ends a
+  turn with `stopReason: "error"` and no `errorMessage`, the status code from the `provider_error`
+  diagnostic is composed into the message the user sees (`Provider error (HTTP 402)`) instead of
+  the bare `Provider error` constant, `agent.model.failed` now emits `status_code`, and the
+  assistant-ui `error` frame carries `status` and `error_code`. An unpaid account and a
+  misconfigured credential are distinguishable again, in the stream and in the logs. The
+  message/body split is unchanged: the provider's message is still forwarded verbatim and its raw
+  response body still never leaves the process.
+
 ## 1.2.6 — 2026-09-21
 
 - Made `pyproject.toml` the only source of the version. `development` declares the release being

{ms_tau_sdk-1.2.7.dev7 → ms_tau_sdk-1.2.7.dev8}/PKG-INFO

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

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

{ms_tau_sdk-1.2.7.dev7 → ms_tau_sdk-1.2.7.dev8}/src/ms_tau_sdk/protocols/assistant_ui.py

@@ -8,7 +8,9 @@ Chunk vocabulary (what a ``ui-message-stream`` consumer receives):
 - ``tool-call-start`` / ``tool-call-delta`` (``argsText``) / ``tool-call-end``
   when the model has finished a tool call, then ``tool-result`` (``result``,
   ``isError``) when the tool has run;
-- ``data-runtime-lifecycle``, ``error`` and ``finish``.
+- ``data-runtime-lifecycle``, ``error`` and ``finish``. An ``error`` chunk
+  carries ``errorText`` plus, when the runtime diagnosed them, the ``status``
+  and ``error_code`` fields the Command Center stream consumer reads.
 
 The tool chunk names are the ones assistant-stream's ``UIMessageStreamDecoder``
 understands; the earlier ``tool-input-available`` / ``tool-output-available``
@@ -34,6 +36,8 @@ class AssistantUiEncoder:
     tool_names: dict[str, str] = field(default_factory=dict)
     finished: bool = False
     terminal_error_text: str | None = None
+    terminal_error_status: int | None = None
+    terminal_error_code: str | None = None
 
     def _tool_call_chunks(
         self,
@@ -161,15 +165,25 @@ class AssistantUiEncoder:
         if event_type == "message_end":
             failure = terminal_assistant_failure(data)
             if failure is not None:
-                self.terminal_error_text = failure.message
+                self._set_terminal_error(
+                    failure.message,
+                    status_code=failure.status_code,
+                    error_code=failure.error_type,
+                )
             elif is_terminal_assistant_message(data):
                 # A later successful terminal message means Tau recovered from
                 # an earlier error, for example through overflow compaction.
-                self.terminal_error_text = None
+                self._set_terminal_error(None)
             return []
         if event_type == "error":
             if self.terminal_error_text is None:
-                self.terminal_error_text = _assistant_error_message(data)
+                error = data.get("error")
+                error = error if isinstance(error, dict) else {}
+                self._set_terminal_error(
+                    _assistant_error_message(data),
+                    status_code=_error_status_code(error),
+                    error_code=_error_code(error),
+                )
             return []
         if event_type == "agent_settled" and not self.finished:
             if self.terminal_error_text is not None:
@@ -178,13 +192,29 @@ class AssistantUiEncoder:
             return [{"type": "finish", "finishReason": "stop"}]
         return []
 
+    def _set_terminal_error(
+        self,
+        text: str | None,
+        *,
+        status_code: int | None = None,
+        error_code: str | None = None,
+    ) -> None:
+        self.terminal_error_text = text
+        self.terminal_error_status = status_code if text is not None else None
+        self.terminal_error_code = error_code if text is not None else None
+
     def finalize(self) -> list[dict[str, Any]]:
         """Emit the one terminal frame after the runtime has finished settling."""
         if self.finished:
             return []
         self.finished = True
         if self.terminal_error_text is not None:
-            return [{"type": "error", "errorText": self.terminal_error_text}]
+            frame: dict[str, Any] = {"type": "error", "errorText": self.terminal_error_text}
+            if self.terminal_error_status is not None:
+                frame["status"] = self.terminal_error_status
+            if self.terminal_error_code is not None:
+                frame["error_code"] = self.terminal_error_code
+            return [frame]
         return [{"type": "finish", "finishReason": "stop"}]
 
     @staticmethod
@@ -211,6 +241,20 @@ def _step_finish_reason(data: dict[str, Any]) -> str:
     return _STEP_FINISH_REASONS.get(str(stop_reason or ""), "stop")
 
 
+def _error_status_code(error: dict[str, Any]) -> int | None:
+    candidate = error.get("status_code", error.get("statusCode", error.get("status")))
+    if isinstance(candidate, bool) or not isinstance(candidate, int):
+        return None
+    return candidate
+
+
+def _error_code(error: dict[str, Any]) -> str | None:
+    candidate = error.get("errorType", error.get("error_type"))
+    if not isinstance(candidate, str) or not candidate.strip():
+        return None
+    return candidate
+
+
 def _assistant_error_message(data: dict[str, Any]) -> str:
     error = data.get("error", {})
     if isinstance(error, dict):

{ms_tau_sdk-1.2.7.dev7 → ms_tau_sdk-1.2.7.dev8}/src/ms_tau_sdk/runtime/failures.py

@@ -30,24 +30,14 @@ def terminal_assistant_failure(
     if reason not in {"error", "aborted"}:
         return None
 
+    provider_error, status_code = _provider_error(message.get("diagnostics"))
+
     error_message = _nonempty_text(message.get("errorMessage", message.get("error_message")))
     if error_message is None:
-        error_message = "Agent turn was aborted" if reason == "aborted" else "Provider error"
-
-    status_code = None
-    provider_error = False
-    diagnostics = message.get("diagnostics")
-    if isinstance(diagnostics, list):
-        for diagnostic in diagnostics:
-            if not isinstance(diagnostic, Mapping) or diagnostic.get("type") != "provider_error":
-                continue
-            provider_error = True
-            details = diagnostic.get("details")
-            if isinstance(details, Mapping):
-                candidate = details.get("status_code")
-                if isinstance(candidate, int) and not isinstance(candidate, bool):
-                    status_code = candidate
-            break
+        # Tau can end a turn with ``stopReason: "error"`` and no message at all.
+        # Returning the bare constant would discard the only diagnostic left, so
+        # the status code is composed into the message the caller sees.
+        error_message = _composed_message(reason=reason, status_code=status_code)
 
     return TerminalAssistantFailure(
         reason=reason,
@@ -72,6 +62,33 @@ def is_terminal_assistant_message(data: Mapping[str, Any]) -> bool:
     return isinstance(reason, str) and bool(reason)
 
 
+def _provider_error(diagnostics: object) -> tuple[bool, int | None]:
+    """Return whether a provider error was diagnosed, and its status code.
+
+    Only the status code is read out of ``details``; the raw provider response
+    body that sits beside it never leaves this function.
+    """
+    if not isinstance(diagnostics, list):
+        return False, None
+    for diagnostic in diagnostics:
+        if not isinstance(diagnostic, Mapping) or diagnostic.get("type") != "provider_error":
+            continue
+        details = diagnostic.get("details")
+        if isinstance(details, Mapping):
+            candidate = details.get("status_code")
+            if isinstance(candidate, int) and not isinstance(candidate, bool):
+                return True, candidate
+        return True, None
+    return False, None
+
+
+def _composed_message(*, reason: str, status_code: int | None) -> str:
+    fallback = "Agent turn was aborted" if reason == "aborted" else "Provider error"
+    if status_code is None:
+        return fallback
+    return f"{fallback} (HTTP {status_code})"
+
+
 def _nonempty_text(value: object) -> str | None:
     if not isinstance(value, str) or not value.strip():
         return None

{ms_tau_sdk-1.2.7.dev7 → ms_tau_sdk-1.2.7.dev8}/src/ms_tau_sdk/runtime/observability.py

@@ -229,6 +229,7 @@ class TauTurnObserver:
             model_attempt=attempt,
             model_duration_ms=round((time.monotonic() - started) * 1000, 3),
             model_error_type=error_type,
+            status_code=status_code,
             provider_request_id=_bounded(_first(data, "provider_request_id", "response_id")),
             rate_limited=rate_limited,
             retryable=retryable,