ms-tau-sdk 1.2.6.dev6__tar.gz → 1.2.7.dev8__tar.gz

{ms_tau_sdk-1.2.6.dev6 → ms_tau_sdk-1.2.7.dev8}/.gitignore

@@ -1,5 +1,6 @@
 # Python cache and virtualenvs
 __pycache__/
+.pytest_cache/
 *.py[cod]
 .venv/
 venv/
@@ -10,6 +11,7 @@ venv/
 !.env.example
 .astro/
 release-dist/
+board-dist/
 
 # OS files
 .DS_Store

{ms_tau_sdk-1.2.6.dev6 → 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.6.dev6 → ms_tau_sdk-1.2.7.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 1.2.6.dev6
+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
@@ -24,6 +24,8 @@ Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: structlog<27,>=26.1
 Requires-Dist: tau-ai==0.4.2
 Requires-Dist: uvicorn[standard]>=0.35
+Provides-Extra: tau-board
+Requires-Dist: ms-tau-board<0.2,>=0.1; extra == 'tau-board'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -148,6 +150,20 @@ Local mode also appends privacy-filtered, structured JSON Lines to
 and log move under `TAU_LOCAL_STATE_ROOT` when set; neither is written to the project `.tau` or
 uploaded to a platform AgentSession. Console logging remains available.
 
+For a small browser view of a local run, install the optional, separately running
+[Tau Board](packages/tau-board/README.md):
+
+```bash
+uv add 'ms-tau-sdk[tau-board]'
+uv run tau-board --tau-url http://127.0.0.1:8010
+```
+
+Open `http://127.0.0.1:8788` to chat, send A2A Messages and Tasks, inspect local SQLite state,
+and read logs. The board serves packaged Bulma CSS with no frontend build or CDN. It can select
+another loopback Tau endpoint and local state directory in its Connect view. Its Settings tab shows
+the board process's safe environment values and edits named non-secret variables in a local `.env`
+file; Tau or the board must restart before saved startup values take effect.
+
 Platform discovery of the unregistered process, internal backend dispatch/caller-delivery hooks,
 push notifications, and `resume_caller` remain unavailable. Outbound A2A through Main Sequence MCP
 supports Messages and Tasks with polling under authenticated-user semantics. Local mode binds to

{ms_tau_sdk-1.2.6.dev6 → ms_tau_sdk-1.2.7.dev8}/README.md

@@ -120,6 +120,20 @@ Local mode also appends privacy-filtered, structured JSON Lines to
 and log move under `TAU_LOCAL_STATE_ROOT` when set; neither is written to the project `.tau` or
 uploaded to a platform AgentSession. Console logging remains available.
 
+For a small browser view of a local run, install the optional, separately running
+[Tau Board](packages/tau-board/README.md):
+
+```bash
+uv add 'ms-tau-sdk[tau-board]'
+uv run tau-board --tau-url http://127.0.0.1:8010
+```
+
+Open `http://127.0.0.1:8788` to chat, send A2A Messages and Tasks, inspect local SQLite state,
+and read logs. The board serves packaged Bulma CSS with no frontend build or CDN. It can select
+another loopback Tau endpoint and local state directory in its Connect view. Its Settings tab shows
+the board process's safe environment values and edits named non-secret variables in a local `.env`
+file; Tau or the board must restart before saved startup values take effect.
+
 Platform discovery of the unregistered process, internal backend dispatch/caller-delivery hooks,
 push notifications, and `resume_caller` remain unavailable. Outbound A2A through Main Sequence MCP
 supports Messages and Tasks with polling under authenticated-user semantics. Local mode binds to

{ms_tau_sdk-1.2.6.dev6 → 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.6.dev6"
+version = "1.2.7.dev8"
 description = "Workspace-bound Tau application primitives for Main Sequence projects"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -30,6 +30,9 @@ dependencies = [
   "uvicorn[standard]>=0.35",
 ]
 
+[project.optional-dependencies]
+tau-board = ["ms-tau-board>=0.1,<0.2"]
+
 [project.urls]
 Changelog = "https://github.com/mainsequence-sdk/ms-tau-sdk/blob/development/CHANGELOG.md"
 Documentation = "https://github.com/mainsequence-sdk/ms-tau-sdk/tree/development/docs"
@@ -62,6 +65,9 @@ include = [
   "/src/ms_tau_sdk",
 ]
 
+[tool.uv.sources]
+ms-tau-board = { path = "packages/tau-board" }
+
 [tool.pytest.ini_options]
 addopts = [
   "--import-mode=importlib",

{ms_tau_sdk-1.2.6.dev6 → 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.6.dev6 → 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.6.dev6 → 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,