ms-tau-sdk 1.2.12.dev20__tar.gz → 1.2.12.dev21__tar.gz

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/CHANGELOG.md

@@ -1,7 +1,21 @@
 # Changelog
 
-## Unreleased
-
+## 1.2.12 — 2026-09-27
+
+- Local `/api/chat` sessions now survive a UI reload and a Tau restart. Local mode records each chat
+  session and adds `GET /api/local/v1/chat-sessions` to list them and
+  `GET /api/local/v1/chat-sessions/{sessionUid}/history` to read one back. The history uses the
+  shape of the platform's `GET /api/v1/agent-sessions/{uid}/history/`: user and assistant text,
+  reasoning, and tool calls with their arguments, results, and `isError`, projected from the Tau
+  transcript by the platform's rules. A turn still running is returned in `inProgressMessage`.
+  `GET /api/local/v1/agent` returns the Agent's name and description from the workspace's
+  `.agents/agent_card.json`. A local chat turn now runs to its durable end when its client
+  disconnects or reloads, and only `POST /api/chat/session/cancel` stops it. A second turn for a
+  session that is still running returns 409 `session_busy`. After a Stop, the next turn in a local
+  session used to fail with "Runtime cancellation was requested" until the idle runtime was
+  evicted; the session's next turn now runs on a fresh runtime. Managed chat behavior is unchanged.
+  With `MAINSEQUENCE_TAU_TRUSTED_ORIGINS` set, CORS also exposes `X-Agent-Session-Uid` and
+  `x-vercel-ai-ui-message-stream`. See ADR 0018. Fixes #47.
 - Added `MAINSEQUENCE_TAU_PROVIDER_TIMEOUT_SECONDS`, the HTTP timeout for model-provider calls.
   It was fixed at 60 seconds for every provider hydrated from the platform, with no setting
   or environment variable to change it. A self-hosted OpenAI-compatible provider such as an
@@ -9,15 +23,15 @@
   prompt exhausted all three attempts, and Tau reported only an empty transport failure. The
   default stays 60 seconds, and an explicit `timeout_seconds` passed to `ProviderFactory.build`
   still takes precedence.
+
+## 1.2.11 — 2026-09-27
+
 - Added authenticated-process-scoped discovery and bounded hydration for direct local A2A Message
   conversations. The SDK now persists exact public requester/responder Messages independently from
   Tau execution entries, returns stable context and Message identities across restart, supports
   cursor pagination and exact completed-request replay, and exposes
   `GET /api/local/v1/conversations` plus its bounded Message-history route. Existing internal
   sessions are not heuristically reconstructed. Fixes #45.
-
-## 1.2.11 — 2026-09-27
-
 - Added a version-locked `tau-ai==0.4.2` compatibility patch for OpenAI-compatible transport
   failures that exhausted retries with an empty terminal message. The SDK now preserves the
   concrete HTTPX error type, transport phase, retry evidence, total provider duration, one failure

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 1.2.12.dev20
+Version: 1.2.12.dev21
 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
@@ -172,6 +172,15 @@ events as distinct sections. Correlated provider failures appear first as one hu
 incident with cause, phase, retries, duration, and bounded traceback frames; raw JSON is an
 expandable secondary view.
 
+Local `/api/chat` sessions are reload-safe as well. List them with
+`GET /api/local/v1/chat-sessions` and read one back with
+`GET /api/local/v1/chat-sessions/{sessionUid}/history`, which returns the platform's chat history
+shape: user and assistant text, reasoning, and tool calls with their results, plus a turn still
+running in `inProgressMessage`. Continue a session by sending its `sessionUid` to `POST /api/chat`.
+A local chat turn keeps running when its client disconnects; stop it with
+`POST /api/chat/session/cancel`. `GET /api/local/v1/agent` returns the Agent's name and description
+from the workspace's `.agents/agent_card.json`.
+
 Direct local A2A Message conversations are also reload-safe without becoming Tasks. List them with
 `GET /api/local/v1/conversations`, then hydrate one with
 `GET /api/local/v1/conversations/{contextId}/messages`; both reads are bounded and scoped to the

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/README.md

@@ -141,6 +141,15 @@ events as distinct sections. Correlated provider failures appear first as one hu
 incident with cause, phase, retries, duration, and bounded traceback frames; raw JSON is an
 expandable secondary view.
 
+Local `/api/chat` sessions are reload-safe as well. List them with
+`GET /api/local/v1/chat-sessions` and read one back with
+`GET /api/local/v1/chat-sessions/{sessionUid}/history`, which returns the platform's chat history
+shape: user and assistant text, reasoning, and tool calls with their results, plus a turn still
+running in `inProgressMessage`. Continue a session by sending its `sessionUid` to `POST /api/chat`.
+A local chat turn keeps running when its client disconnects; stop it with
+`POST /api/chat/session/cancel`. `GET /api/local/v1/agent` returns the Agent's name and description
+from the workspace's `.agents/agent_card.json`.
+
 Direct local A2A Message conversations are also reload-safe without becoming Tasks. List them with
 `GET /api/local/v1/conversations`, then hydrate one with
 `GET /api/local/v1/conversations/{contextId}/messages`; both reads are bounded and scoped to the

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/pyproject.toml

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

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/src/ms_tau_sdk/agent_skills/tau_local_development/SKILL.md

@@ -81,6 +81,16 @@ a platform AgentSession. Local mode supports:
   rescheduling safe unclaimed work and terminalizing stale uncertain work rather than replaying
   possible side effects.
 
+For a chat UI over `POST /api/chat`, do not read `runtime.sqlite3` or keep a browser-only
+transcript either. List sessions with `GET /api/local/v1/chat-sessions?limit=<n>&cursor=<opaque>`
+and hydrate one with `GET /api/local/v1/chat-sessions/{sessionUid}/history`. The history has the
+platform's `GET /api/v1/agent-sessions/{uid}/history/` shape, including reasoning, tool calls with
+results, and a running turn in `inProgressMessage`, so one reader serves local and deployed
+Agents. Reuse the listed `sessionUid` in `POST /api/chat`. A local chat turn keeps running when
+the client disconnects or reloads; stop it only with `POST /api/chat/session/cancel`, and queue a
+new message while a session is `working` (`POST /api/chat` returns 409 `session_busy`). Title the
+UI from `GET /api/local/v1/agent`, which reads the workspace's `.agents/agent_card.json`.
+
 For the default direct Message flow, do not read `runtime.sqlite3` or keep a browser-only source of
 truth. Discover conversations with `GET /api/local/v1/conversations?limit=<n>&cursor=<opaque>` and
 hydrate the latest bounded Message tail with

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/src/ms_tau_sdk/api/chat.py

@@ -95,11 +95,24 @@ async def chat(
             message_count=len(body.messages) if body.messages else None,
         ),
     )
+    # A local turn is recorded as a chat session and outlives this request, so a
+    # reload or a closed tab leaves it running; only session/cancel stops it. A
+    # managed turn stays bound to the request that streams it.
+    local_turn = (
+        await manager.start_local_chat_turn(session_uid, prompt, provenance=provenance)
+        if manager.settings.local_mode
+        else None
+    )
+    events = (
+        local_turn.events()
+        if local_turn is not None
+        else manager.prompt(session_uid, prompt, provenance=provenance)
+    )
 
     async def stream() -> AsyncIterator[bytes]:
         encoder = AssistantUiEncoder()
         try:
-            async for event in manager.prompt(session_uid, prompt, provenance=provenance):
+            async for event in events:
                 for payload in encoder.encode(event):
                     yield encoder.sse(payload)
             try:
@@ -107,9 +120,10 @@ async def chat(
                     yield encoder.sse(payload)
                 yield encoder.done()
             finally:
-                manager.mark_response_delivered(session_uid)
+                if local_turn is None:
+                    manager.mark_response_delivered(session_uid)
         except asyncio.CancelledError:
-            if not encoder.finished:
+            if local_turn is None and not encoder.finished:
                 await manager.cancel(session_uid)
             raise
         except Exception as error:
@@ -144,6 +158,9 @@ async def chat(
                     }
                 )
             yield encoder.done()
+        finally:
+            if local_turn is not None:
+                local_turn.detach()
 
     return StreamingResponse(
         stream(),

ms_tau_sdk-1.2.12.dev21/src/ms_tau_sdk/api/local_chat.py

@@ -0,0 +1,256 @@
+"""Reload-safe local `/api/chat` sessions and the local Agent's identity (ADR 0018)."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Annotated, Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from ms_tau_sdk.backend.client import MainSequenceClient
+from ms_tau_sdk.backend.models import LocalChatSessionSummary
+from ms_tau_sdk.protocols.chat_history import (
+    HISTORY_VERSION,
+    HistoryMessage,
+    current_branch,
+    iso_timestamp,
+    latest_message_preview,
+    project_history,
+)
+from ms_tau_sdk.runtime.manager import SessionRuntimeManager
+from ms_tau_sdk.settings import TauSDKSettings
+
+from .dependencies import backend, runtime_manager, settings
+
+router = APIRouter(prefix="/api/local/v1")
+BackendDep = Annotated[MainSequenceClient, Depends(backend)]
+RuntimeManagerDep = Annotated[SessionRuntimeManager, Depends(runtime_manager)]
+SettingsDep = Annotated[TauSDKSettings, Depends(settings)]
+logger = structlog.get_logger(__name__)
+
+AGENT_CARD_PATH = Path(".agents") / "agent_card.json"
+LOCAL_AGENT_NAME = "Local Main Sequence TAU Agent"
+
+
+def _require_local(config: TauSDKSettings) -> None:
+    if not config.local_mode:
+        raise HTTPException(
+            status_code=409,
+            detail="Local chat sessions require TAU_LOCAL_MODE=true",
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class AgentIdentity:
+    name: str | None = None
+    description: str | None = None
+
+
+def _read_agent_identity(workspace: Path) -> AgentIdentity:
+    """Read the name and description of the workspace's `.agents/agent_card.json`.
+
+    The platform takes a deployed Agent's name and description from the same file.
+    A missing or unreadable card leaves both unset rather than inventing them.
+    """
+
+    path = workspace / AGENT_CARD_PATH
+    try:
+        card = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return AgentIdentity()
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        logger.warning(
+            "local_agent.card_unreadable",
+            message="The workspace Agent Card could not be read",
+            path=str(AGENT_CARD_PATH),
+            error_type=type(error).__name__,
+        )
+        return AgentIdentity()
+    if not isinstance(card, dict):
+        return AgentIdentity()
+
+    def text(key: str) -> str | None:
+        value = card.get(key)
+        return value.strip() if isinstance(value, str) and value.strip() else None
+
+    return AgentIdentity(name=text("name"), description=text("description"))
+
+
+async def workspace_agent_identity(workspace: Path) -> AgentIdentity:
+    return await asyncio.to_thread(_read_agent_identity, workspace)
+
+
+@dataclass(frozen=True, slots=True)
+class _SessionProjection:
+    summary: LocalChatSessionSummary
+    messages: list[HistoryMessage]
+    in_progress: HistoryMessage | None
+    status: str
+    error: str | None
+    updated_at: datetime
+
+
+async def _project_session(
+    client: MainSequenceClient,
+    manager: SessionRuntimeManager,
+    config: TauSDKSettings,
+    session_uid: str,
+) -> _SessionProjection:
+    """Project a session's durable branch plus the turn this process is running.
+
+    The running turn is read before the durable entries. If that turn committed in
+    between, its durable entries already hold everything the live view had.
+    """
+
+    live_turn = manager.live_turn(session_uid)
+    live_entries = live_turn.entries() if live_turn is not None else None
+    transcript = await client.get_local_chat_transcript(
+        session_uid,
+        turn_uid=live_turn.turn_uid if live_turn is not None else None,
+    )
+    if transcript.turn_committed:
+        live_entries = None
+    durable = [
+        item.entry
+        for item in transcript.entries
+        if live_entries is None or live_turn is None or item.turn_uid != live_turn.turn_uid
+    ]
+    branch = current_branch(durable)
+    projected = project_history(
+        [*branch, *(live_entries or [])],
+        target_agent_uid=config.local_agent_uid,
+    )
+    messages = projected.messages
+    in_progress: HistoryMessage | None = None
+    if (
+        live_entries is not None
+        and messages
+        and messages[-1]["role"] == "assistant"
+        and projected.source_indexes[-1] >= len(branch)
+    ):
+        # The running turn's newest assistant message, streaming or awaiting a tool.
+        in_progress = {**messages.pop(), "completedAt": None}
+    running = (
+        live_entries is not None
+        or transcript.session.working
+        or manager.local_session_running(session_uid)
+    )
+    status = "running" if running else ("error" if projected.last_turn_error else "completed")
+    updated_at = transcript.session.updated_at
+    if projected.last_timestamp is not None:
+        updated_at = max(updated_at, projected.last_timestamp)
+    return _SessionProjection(
+        summary=transcript.session,
+        messages=messages,
+        in_progress=in_progress,
+        status=status,
+        error=projected.last_turn_error if status == "error" else None,
+        updated_at=updated_at,
+    )
+
+
+def _session_summary(
+    summary: LocalChatSessionSummary,
+    *,
+    message_count: int,
+    latest_message_preview: str | None,
+    updated_at: datetime,
+    working: bool,
+) -> dict[str, Any]:
+    return {
+        "sessionUid": summary.session_uid,
+        "title": summary.title,
+        "messageCount": message_count,
+        "latestMessagePreview": latest_message_preview,
+        "createdAt": iso_timestamp(summary.created_at),
+        "updatedAt": iso_timestamp(updated_at),
+        "working": working,
+    }
+
+
+@router.get("/chat-sessions")
+async def list_chat_sessions(
+    client: BackendDep,
+    manager: RuntimeManagerDep,
+    config: SettingsDep,
+    limit: int = Query(default=50, ge=1, le=100),
+    cursor: str | None = Query(default=None, min_length=1, max_length=1024),
+) -> dict[str, Any]:
+    _require_local(config)
+    try:
+        page = await client.list_local_chat_sessions(limit=limit, cursor=cursor)
+    except ValueError as error:
+        raise HTTPException(status_code=400, detail=str(error)) from error
+    sessions: list[dict[str, Any]] = []
+    for summary in page.sessions:
+        if manager.live_turn(summary.session_uid) is None:
+            sessions.append(
+                _session_summary(
+                    summary,
+                    message_count=summary.message_count,
+                    latest_message_preview=summary.latest_message_preview,
+                    updated_at=summary.updated_at,
+                    working=(summary.working or manager.local_session_running(summary.session_uid)),
+                )
+            )
+            continue
+        projection = await _project_session(client, manager, config, summary.session_uid)
+        visible = [
+            *projection.messages,
+            *([projection.in_progress] if projection.in_progress is not None else []),
+        ]
+        sessions.append(
+            _session_summary(
+                summary,
+                message_count=len(visible),
+                latest_message_preview=latest_message_preview(visible),
+                updated_at=max(summary.updated_at, projection.updated_at),
+                working=projection.status == "running",
+            )
+        )
+    return {"sessions": sessions, "nextCursor": page.next_cursor}
+
+
+@router.get("/chat-sessions/{session_uid}/history")
+async def chat_session_history(
+    session_uid: str,
+    client: BackendDep,
+    manager: RuntimeManagerDep,
+    config: SettingsDep,
+) -> dict[str, Any]:
+    _require_local(config)
+    canonical = config.local_session_uid(session_uid)
+    projection = await _project_session(client, manager, config, canonical)
+    identity = await workspace_agent_identity(config.workspace)
+    return {
+        "version": HISTORY_VERSION,
+        "session": {
+            "sessionId": canonical,
+            "threadId": canonical,
+            "agentName": identity.name or LOCAL_AGENT_NAME,
+            "agentUid": config.local_agent_uid,
+            "agentSessionUid": canonical,
+            "status": projection.status,
+            "startedAt": iso_timestamp(projection.summary.created_at),
+            "updatedAt": iso_timestamp(projection.updated_at),
+            "error": projection.error,
+        },
+        "messages": projection.messages,
+        "inProgressMessage": projection.in_progress,
+    }
+
+
+@router.get("/agent")
+async def local_agent(config: SettingsDep) -> dict[str, str | None]:
+    _require_local(config)
+    identity = await workspace_agent_identity(config.workspace)
+    return {
+        "name": identity.name,
+        "displayName": identity.name,
+        "description": identity.description,
+    }

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/src/ms_tau_sdk/app.py

@@ -13,7 +13,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 
 from ms_tau_sdk import __version__
-from ms_tau_sdk.api import a2a, chat, conversations, health, inspection, sessions
+from ms_tau_sdk.api import a2a, chat, conversations, health, inspection, local_chat, sessions
 from ms_tau_sdk.application import ApplicationServices
 from ms_tau_sdk.errors import TauSDKError
 from ms_tau_sdk.logging import RequestContextMiddleware, configure_logging
@@ -24,6 +24,9 @@ from ms_tau_sdk.settings import TauSDKSettings, get_settings
 
 logger = structlog.get_logger(__name__)
 LOCAL_UNSUPPORTED_PATH_PREFIXES = ("/internal/a2a",)
+# Response headers a trusted cross-origin chat client must read: the canonical
+# session of a `POST /api/chat` stream and the stream protocol marker.
+CORS_EXPOSED_HEADERS = ("X-Agent-Session-Uid", "x-vercel-ai-ui-message-stream")
 
 
 def create_app(
@@ -113,6 +116,7 @@ def create_app(
             allow_credentials=True,
             allow_methods=["*"],
             allow_headers=["*"],
+            expose_headers=list(CORS_EXPOSED_HEADERS),
         )
     app.add_middleware(RequestContextMiddleware)
 
@@ -152,6 +156,7 @@ def create_app(
     app.include_router(chat.router)
     app.include_router(a2a.router)
     app.include_router(conversations.router)
+    app.include_router(local_chat.router)
     app.include_router(sessions.router)
     app.include_router(inspection.router)
     return app

{ms_tau_sdk-1.2.12.dev20 → ms_tau_sdk-1.2.12.dev21}/src/ms_tau_sdk/backend/client.py

@@ -33,6 +33,8 @@ from .models import (
     AgentTaskEventPage,
     AgentTaskExecutionAttempt,
     AgentTaskSnapshot,
+    LocalChatSessionPage,
+    LocalChatTranscript,
     LocalConversationMessagePage,
     LocalConversationPage,
     ProviderControl,
@@ -185,6 +187,30 @@ class MainSequenceClient:
         del context_id, limit, before_sequence
         raise LocalModeUnsupportedError("Local conversation history requires TAU local mode")
 
+    async def begin_local_chat_turn(self, session_uid: str, prompt: str) -> None:
+        """Record that `/api/chat` is starting a turn in a local session."""
+
+        del session_uid, prompt
+        raise LocalModeUnsupportedError("Local chat sessions require TAU local mode")
+
+    async def list_local_chat_sessions(
+        self,
+        *,
+        limit: int,
+        cursor: str | None,
+    ) -> LocalChatSessionPage:
+        del limit, cursor
+        raise LocalModeUnsupportedError("Local chat session discovery requires TAU local mode")
+
+    async def get_local_chat_transcript(
+        self,
+        session_uid: str,
+        *,
+        turn_uid: str | None = None,
+    ) -> LocalChatTranscript:
+        del session_uid, turn_uid
+        raise LocalModeUnsupportedError("Local chat session history requires TAU local mode")
+
     async def _request(
         self,
         method: str,