muse-code-sdk 1.4.6__tar.gz → 1.4.8__tar.gz

{muse_code_sdk-1.4.6/src/muse_code_sdk.egg-info → muse_code_sdk-1.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.6
+Version: 1.4.8
 Summary: Muse Code SDK for MSP: asyncio-first facade over the generated wire types (muse-code-msp), with a thin sync wrapper.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/meta-models/muse-code-sdk

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "muse-code-sdk"
-version = "1.4.6"
+version = "1.4.8"
 description = "Muse Code SDK for MSP: asyncio-first facade over the generated wire types (muse-code-msp), with a thin sync wrapper."
 readme = "README.md"
 requires-python = ">=3.10"

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8}/src/muse_code/__init__.py

@@ -80,7 +80,7 @@ __all__ = [
 ]
 
 EXPECTED_SCHEMA_FINGERPRINT: Final[str] = (
-    "sha256:eae467ab60cb9a5d5af4de616830f065e59375c987fd59269c8cc33ed2a1137f"
+    "sha256:4e3200c3c9dc0cd7919d11022630d43f9bc1c5cdda375381e90b0183b5665069"
 )
 """The stable schema-bundle fingerprint this SDK was built against.
 
@@ -92,7 +92,7 @@ Python SDK reds this lane instead of drifting silently.
 # The lockstep rule: the release train bumps pyproject.toml, the
 # distribution-metadata authority; this constant is aligned at publication
 # time.
-__version__: Final[str] = "1.4.6"
+__version__: Final[str] = "1.4.8"
 
 # The facade is imported last so the constants above are already bound: the
 # spawn path reads ``EXPECTED_SCHEMA_FINGERPRINT`` (lazily, at initialize

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8}/src/muse_code/facade/client.py

@@ -130,12 +130,17 @@ class ResumeSessionOptions:
         exclude_items: Ask the host to omit item bodies from the history.
         history: The history preference forwarded as the wire's ``history``
             member.
+        permission_profile: The permission profile pick forwarded as the
+            wire's ``permissionProfile`` member: the host restores the
+            retained authority first, then applies the pick. Omitted means
+            no override.
     """
 
     session_id: str
     cursor: str | None = None
     exclude_items: bool | None = None
     history: Mapping[str, Any] | None = None
+    permission_profile: str | None = None
 
 
 # Drift pins — the Python twin of the TS `AssertNever` on START_FORWARDED /
@@ -483,6 +488,8 @@ class MuseClient(Generic[_I]):
             params["excludeItems"] = options.exclude_items
         if options.history is not None:
             params["history"] = options.history
+        if options.permission_profile is not None:
+            params["permissionProfile"] = options.permission_profile
         return await self._open("session/resume", params, _ResumeOpening)
 
     async def close(self) -> None:

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8}/src/muse_code/facade/turn_handle.py

@@ -97,9 +97,10 @@ class _TerminalUnknown:
 
 TurnOutcome = Union[_Completed, _Unqueued, _TerminalUnknown]
 """How a turn ended, from a waiter's point of view. ``turn/retracted``,
-``turn/retryScheduled``, and ``turn/foregroundCompleted`` are deliberately
-absent: a retracted turn still reaches its own terminal, and a scheduled
-retry or a foreground notice is explicitly non-terminal."""
+``turn/retryScheduled``, ``turn/modelRetryScheduled``, and
+``turn/foregroundCompleted`` are deliberately absent: a retracted turn still
+reaches its own terminal, and a scheduled retry, a scheduled backoff, or a
+foreground notice is explicitly non-terminal."""
 
 
 def is_launch_failure(outcome: TurnOutcome) -> bool:

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8}/src/muse_code/fold/session_fold.py

@@ -10,7 +10,8 @@ are neither an item nor a state family:
 
 - the TURN LIFECYCLE — ``turn/started``, ``turn/completed``,
   ``turn/retracted``, ``turn/unqueued``, and the non-terminal
-  ``turn/retryScheduled`` and ``turn/foregroundCompleted``;
+  ``turn/retryScheduled``, ``turn/modelRetryScheduled``, and
+  ``turn/foregroundCompleted``;
 - the APPROVAL and USER-INPUT view events as fold INPUTS — the pending sets
   and their first durable terminal. The decision flow (choosing and sending a
   resolution) is the facade's, not the fold's;
@@ -71,6 +72,7 @@ VIEW_EVENT_METHODS: frozenset[str] = frozenset(
         "turn/foregroundCompleted",
         "turn/retracted",
         "turn/retryScheduled",
+        "turn/modelRetryScheduled",
         "turn/unqueued",
         "approval/requested",
         "approval/updated",
@@ -139,6 +141,9 @@ class TurnEntry:
             ``turn/completed`` folded.
         error: Present iff the terminal was ``"failed"``.
         retry_scheduled: The latest scheduled model retry; non-terminal.
+        model_retry_scheduled: The latest scheduled provider-backoff retry;
+            non-terminal. The model-attempt twin of ``retry_scheduled``;
+            clears on the turn's terminal.
         foreground_completed: The latest foreground-completed notice;
             non-terminal. Tells a renderer the answer is done while
             ``blockingAgents`` hold the turn; clears on the turn's terminal.
@@ -150,6 +155,7 @@ class TurnEntry:
     terminal: str | None = None
     error: Params | None = None
     retry_scheduled: Params | None = None
+    model_retry_scheduled: Params | None = None
     foreground_completed: Params | None = None
 
 
@@ -422,6 +428,7 @@ class _InternalTurn:
     terminal: str | None = None
     error: Params | None = None
     retry_scheduled: Params | None = None
+    model_retry_scheduled: Params | None = None
     foreground_completed: Params | None = None
 
 
@@ -572,6 +579,8 @@ class SessionFold:
             return self._turn_unqueued(params)
         if method == "turn/retryScheduled":
             return self._turn_retry_scheduled(params)
+        if method == "turn/modelRetryScheduled":
+            return self._turn_model_retry_scheduled(params)
         if method == "turn/foregroundCompleted":
             return self._turn_foreground_completed(params)
         if method == "approval/requested":
@@ -675,6 +684,9 @@ class SessionFold:
         # The retry hint is a "retrying in Ns" countdown, and it clears on the
         # turn's next event — which a completion is.
         turn.retry_scheduled = None
+        # Same for the provider-backoff hint: a finished turn is not
+        # waiting out a backoff.
+        turn.model_retry_scheduled = None
         # Same for the foreground hint: a finished turn is not
         # background-waiting.
         turn.foreground_completed = None
@@ -720,6 +732,18 @@ class SessionFold:
         turn.retry_scheduled = params
         return TurnFold(turn_id, turn.state)
 
+    def _turn_model_retry_scheduled(self, params: Params) -> FoldOutcome:
+        # Non-terminal by contract: it never resolves a turn-wait.
+        turn_id = str(params["turnId"])
+        turn = self._turn_for(turn_id)
+        # ...but it is still a turn frame, so it takes the same redelivery
+        # guard as the retry hint: a replayed page must not re-plant the
+        # provider-backoff hint on a turn that already left `running`.
+        if turn.state != "running":
+            return IgnoredStaleFrame("turn/modelRetryScheduled", turn_id)
+        turn.model_retry_scheduled = params
+        return TurnFold(turn_id, turn.state)
+
     def _turn_foreground_completed(self, params: Params) -> FoldOutcome:
         # Non-terminal by contract: it never resolves a turn-wait.
         turn_id = str(params["turnId"])
@@ -753,6 +777,7 @@ class SessionFold:
             terminal=turn.terminal,
             error=turn.error,
             retry_scheduled=turn.retry_scheduled,
+            model_retry_scheduled=turn.model_retry_scheduled,
             foreground_completed=turn.foreground_completed,
         )
 

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8/src/muse_code_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.6
+Version: 1.4.8
 Summary: Muse Code SDK for MSP: asyncio-first facade over the generated wire types (muse-code-msp), with a thin sync wrapper.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/meta-models/muse-code-sdk

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8}/tests/test_facade_turn.py

@@ -139,6 +139,25 @@ def turn_retry_scheduled(turn_id: str, view_cursor: str) -> dict[str, Any]:
     }
 
 
+def turn_model_retry_scheduled(turn_id: str, view_cursor: str) -> dict[str, Any]:
+    return {
+        "method": "turn/modelRetryScheduled",
+        "params": {
+            "attempt": 2,
+            "errorKind": "overloaded",
+            "httpStatus": 529,
+            "maxAttempts": 5,
+            "nextAttempt": 3,
+            "retryDelayMs": 4_000,
+            "sessionId": SESSION,
+            "sourceRange": SOURCE,
+            "system": "meta",
+            "turnId": turn_id,
+            "viewCursor": view_cursor,
+        },
+    }
+
+
 def turn_foreground_completed(turn_id: str, view_cursor: str) -> dict[str, Any]:
     return {
         "method": "turn/foregroundCompleted",
@@ -331,6 +350,32 @@ async def test_turn_retry_scheduled_never_settles_the_wait() -> None:
     await watcher
 
 
+@pytest.mark.asyncio
+async def test_turn_model_retry_scheduled_never_settles_the_wait() -> None:
+    s = session()
+    turn = s.turn("t-1")
+    s.apply(turn_started("t-1", "v:1"))
+    s.apply(turn_model_retry_scheduled("t-1", "v:2"))
+
+    settled = False
+
+    async def watch() -> None:
+        nonlocal settled
+        await turn.completed
+        settled = True
+
+    import asyncio
+
+    watcher = asyncio.ensure_future(watch())
+    for _ in range(5):
+        await asyncio.sleep(0)
+    assert settled is False, "a scheduled backoff is a fact about a RUNNING turn"
+
+    s.apply(turn_completed("t-1", "completed", "v:3"))
+    assert (await turn.completed).kind == "completed"
+    await watcher
+
+
 @pytest.mark.asyncio
 async def test_turn_foreground_completed_never_settles_the_wait() -> None:
     s = session()

{muse_code_sdk-1.4.6 → muse_code_sdk-1.4.8}/tests/test_session_fold.py

@@ -110,6 +110,25 @@ def retry_scheduled(turn_id: str, view_cursor: str) -> dict[str, Any]:
     }
 
 
+def model_retry_scheduled(turn_id: str, view_cursor: str) -> dict[str, Any]:
+    return {
+        "method": "turn/modelRetryScheduled",
+        "params": {
+            "attempt": 2,
+            "errorKind": "overloaded",
+            "httpStatus": 529,
+            "maxAttempts": 5,
+            "nextAttempt": 3,
+            "retryDelayMs": 4_000,
+            "sessionId": SESSION,
+            "sourceRange": SOURCE,
+            "system": "meta",
+            "turnId": turn_id,
+            "viewCursor": view_cursor,
+        },
+    }
+
+
 def foreground_completed(turn_id: str, view_cursor: str) -> dict[str, Any]:
     return {
         "method": "turn/foregroundCompleted",
@@ -493,6 +512,58 @@ def test_a_replayed_page_never_re_plants_the_retry_hint_on_a_turn_that_left_runn
     assert fold.apply(retry) == IgnoredStaleFrame("turn/retryScheduled", "turn-1")
 
 
+def test_turn_model_retry_scheduled_is_non_terminal_the_turn_keeps_running() -> None:
+    fold = SessionFold()
+    fold.apply(turn_started("turn-1", "cmd-1", "v:s:1"))
+    fold.apply(model_retry_scheduled("turn-1", "v:s:2"))
+
+    assert fold.active_turn_id == "turn-1", "a scheduled backoff never settles a turn"
+    held = fold.turn("turn-1")
+    assert held is not None
+    assert held.state == "running"
+    assert held.model_retry_scheduled is not None
+    assert held.model_retry_scheduled["nextAttempt"] == 3
+
+
+def test_turn_completed_clears_the_provider_backoff_hint() -> None:
+    fold = SessionFold()
+    fold.apply(turn_started("turn-1", "cmd-1", "v:s:1"))
+    fold.apply(model_retry_scheduled("turn-1", "v:s:2"))
+    held = fold.turn("turn-1")
+    assert held is not None and held.model_retry_scheduled is not None, (
+        "the hint is set while the turn runs"
+    )
+
+    fold.apply(turn_completed("turn-1", "completed", "v:s:3"))
+
+    held = fold.turn("turn-1")
+    assert held is not None and held.model_retry_scheduled is None
+
+
+def test_a_replayed_page_never_re_plants_the_backoff_hint_on_a_turn_that_left_running() -> None:
+    fold = SessionFold()
+    backoff = model_retry_scheduled("turn-1", "v:s:2")
+    page = [
+        turn_started("turn-1", "cmd-1", "v:s:1"),
+        backoff,
+        turn_completed("turn-1", "cancelled", "v:s:3"),
+        turn_retracted("turn-1", "cmd-1", "v:s:4"),
+    ]
+    for event in page:
+        fold.apply(event)
+    held = fold.turn("turn-1")
+    assert held is not None and held.model_retry_scheduled is None, "in-order delivery is clean"
+
+    for event in page:
+        fold.apply(event)
+
+    held = fold.turn("turn-1")
+    assert held is not None
+    assert held.state == "retracted"
+    assert held.model_retry_scheduled is None, "the replayed hint is dropped"
+    assert fold.apply(backoff) == IgnoredStaleFrame("turn/modelRetryScheduled", "turn-1")
+
+
 def test_turn_completed_clears_the_foreground_hint() -> None:
     fold = SessionFold()
     fold.apply(turn_started("turn-1", "cmd-1", "v:s:1"))
@@ -1081,6 +1152,7 @@ def test_every_generated_view_notification_is_routed_never_the_default() -> None
         "turn/completed": turn_completed("turn-t", "completed", "v:t:6"),
         "turn/retracted": turn_retracted("turn-t2", "cmd-t2", "v:t:7"),
         "turn/retryScheduled": retry_scheduled("turn-t3", "v:t:8"),
+        "turn/modelRetryScheduled": model_retry_scheduled("turn-t3", "v:t:8b"),
         "turn/foregroundCompleted": foreground_completed("turn-t5", "v:t:23"),
         "turn/unqueued": turn_unqueued("turn-t4", "cmd-t4", "v:t:9"),
         "approval/requested": approval_requested("a-t", "v:t:10"),