muse-code-sdk 1.4.11__tar.gz → 1.4.13__tar.gz

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.11
+Version: 1.4.13
 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
@@ -15,6 +15,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic==2.13.5
+Requires-Dist: muse-code-msp==1.4.13
 Dynamic: license-file
 
 # `muse-code-sdk`
@@ -42,13 +43,14 @@ Status: developer preview. Experimental protocol surfaces may change.
 
 The generated MSP wire types live in the companion package
 [`muse-code-msp`](https://pypi.org/project/muse-code-msp/) and are never
-restated here. One runtime dependency: `pydantic`, exact-pinned.
+restated here; it is installed with this package, pinned to the same version.
+One further runtime dependency: `pydantic`, exact-pinned.
 Python 3.10+. Fully typed (`py.typed`).
 
 ## Install
 
 ```sh
-pip install muse-code-sdk muse-code-msp
+pip install muse-code-sdk
 ```
 
 You also need the Muse Code CLI: a `muse` binary on `PATH`, or an explicit
@@ -82,6 +84,47 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
+To run a session and the child agents it starts without approval prompts,
+start it under the built-in `:unrestricted` permission profile. Current
+releases admit every child of such a session without prompts; a child admitted
+with a narrower authority would stay gated at it.
+
+That profile is described, verbatim, as "No filesystem sandbox or approval
+prompts; local commands have direct network access; project trust is
+unchanged." It also sets the approval reviewer to none. Use it only for a
+trusted workspace and trusted prompts. Never use it where the prompts or the
+sandbox are what protects you.
+
+Start it with that profile, and pass the same profile when you resume it.
+Paste inside `main()` above, indented, before `await client.close()`, with the same client:
+
+```python
+from muse_code import ResumeSessionOptions, StartSessionOptions
+
+session = await client.start_session(StartSessionOptions(
+    workspace_root="/path/to/repo",  # an absolute path
+    permission_profile=":unrestricted",
+))
+saved_session_id = session.session_id
+# ... later, in the same client:
+session = await client.resume_session(ResumeSessionOptions(
+    session_id=saved_session_id,
+    permission_profile=":unrestricted",
+))
+```
+
+On start, `require_permission_profile=True` makes the client prove that the
+pick was applied, and raise `PermissionProfileNotApplied` if it cannot (a
+failed `session/read` read-back raises its own error). A host
+that does not report the committed selection fails that proof even when the
+pick was applied (seen with Muse Code 1.4.12). Resume has no
+`require_permission_profile`, so the client never verifies the pick there.
+
+`approval_mode` alone is not enough: it changes the session's own approval
+mode, but its child agents are capped by the session's permission profile.
+Under a prompting profile (such as `:ask-me`, whose approval is `on_request`),
+the children still ask.
+
 ## Documentation
 
 - Guides, cookbook recipes, and the protocol reference:

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/README.md

@@ -23,13 +23,14 @@ Status: developer preview. Experimental protocol surfaces may change.
 
 The generated MSP wire types live in the companion package
 [`muse-code-msp`](https://pypi.org/project/muse-code-msp/) and are never
-restated here. One runtime dependency: `pydantic`, exact-pinned.
+restated here; it is installed with this package, pinned to the same version.
+One further runtime dependency: `pydantic`, exact-pinned.
 Python 3.10+. Fully typed (`py.typed`).
 
 ## Install
 
 ```sh
-pip install muse-code-sdk muse-code-msp
+pip install muse-code-sdk
 ```
 
 You also need the Muse Code CLI: a `muse` binary on `PATH`, or an explicit
@@ -63,6 +64,47 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
+To run a session and the child agents it starts without approval prompts,
+start it under the built-in `:unrestricted` permission profile. Current
+releases admit every child of such a session without prompts; a child admitted
+with a narrower authority would stay gated at it.
+
+That profile is described, verbatim, as "No filesystem sandbox or approval
+prompts; local commands have direct network access; project trust is
+unchanged." It also sets the approval reviewer to none. Use it only for a
+trusted workspace and trusted prompts. Never use it where the prompts or the
+sandbox are what protects you.
+
+Start it with that profile, and pass the same profile when you resume it.
+Paste inside `main()` above, indented, before `await client.close()`, with the same client:
+
+```python
+from muse_code import ResumeSessionOptions, StartSessionOptions
+
+session = await client.start_session(StartSessionOptions(
+    workspace_root="/path/to/repo",  # an absolute path
+    permission_profile=":unrestricted",
+))
+saved_session_id = session.session_id
+# ... later, in the same client:
+session = await client.resume_session(ResumeSessionOptions(
+    session_id=saved_session_id,
+    permission_profile=":unrestricted",
+))
+```
+
+On start, `require_permission_profile=True` makes the client prove that the
+pick was applied, and raise `PermissionProfileNotApplied` if it cannot (a
+failed `session/read` read-back raises its own error). A host
+that does not report the committed selection fails that proof even when the
+pick was applied (seen with Muse Code 1.4.12). Resume has no
+`require_permission_profile`, so the client never verifies the pick there.
+
+`approval_mode` alone is not enough: it changes the session's own approval
+mode, but its child agents are capped by the session's permission profile.
+Under a prompting profile (such as `:ask-me`, whose approval is `on_request`),
+the children still ask.
+
 ## Documentation
 
 - Guides, cookbook recipes, and the protocol reference:

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/pyproject.toml

@@ -5,19 +5,20 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "muse-code-sdk"
-version = "1.4.11"
+version = "1.4.13"
 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"
 license = "MIT"
 license-files = ["LICENSE"]
-# Exactly ONE runtime dependency, exact-pinned: a deliberate, ruled
-# supply-chain exception. Any second dependency is an owner escalation;
-# bumps are deliberate reviewed PRs.
-# muse-code-msp is deliberately NOT declared: it is not on the registry yet,
-# and promoting it is the owner escalation decided with the first publish
-# (the @muse-code/msp devDependency precedent; test_publish_shape pins this).
-dependencies = ["pydantic==2.13.5"]
+# Two runtime dependencies, both exact-pinned. pydantic is the deliberate,
+# ruled supply-chain exception; bumps are deliberate reviewed PRs.
+# muse-code-msp is the companion wire-types package generated and released
+# from the same tree, so its pin is this package's own version: a plain
+# `pip install muse-code-sdk` must import, and the release bump moves this
+# package's version and its muse-code-msp pin together; pydantic bumps stay
+# reviewed PRs (test_publish_shape pins the pairing).
+dependencies = ["pydantic==2.13.5", "muse-code-msp==1.4.13"]
 classifiers = [
     # Alpha states the withheld promise: publication is permitted, but the
     # stability promise and conformance claim stay withheld — experimental

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/src/muse_code/__init__.py

@@ -80,7 +80,7 @@ __all__ = [
 ]
 
 EXPECTED_SCHEMA_FINGERPRINT: Final[str] = (
-    "sha256:f282ad16e21520d0cda68cb190149b86e2b062eef1dd282749360c05aa3d1082"
+    "sha256:7fddaf646dbc317e5fcac0785e135eb04df14fbb0db1863089dfd6da21730e5b"
 )
 """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.11"
+__version__: Final[str] = "1.4.13"
 
 # 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.11 → muse_code_sdk-1.4.13}/src/muse_code/facade/approval.py

@@ -61,6 +61,7 @@ _REFRESH_FROM_UPDATE = frozenset(
 _REFRESH_FROM_REQUEST = frozenset(
     {
         "approvalId",
+        "cuaCardFacts",
         "itemId",
         "judgeEscalated",
         "protectedWrite",
@@ -297,6 +298,10 @@ class ApprovalRouter:
         # Omitted rather than nulled when absent, like ``feedback`` below.
         if "subagentOrigin" in params:
             refreshed["subagentOrigin"] = params["subagentOrigin"]
+        # A Computer Use card's facts belong to the call, so they stay with
+        # the retained request across stages.
+        if "cuaCardFacts" in requested:
+            refreshed["cuaCardFacts"] = requested["cuaCardFacts"]
         acked = self._in_flight.get(requested["approvalId"])
         if acked is not None:
             return self._after_ack(acked, refreshed)

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/src/muse_code_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.11
+Version: 1.4.13
 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
@@ -15,6 +15,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic==2.13.5
+Requires-Dist: muse-code-msp==1.4.13
 Dynamic: license-file
 
 # `muse-code-sdk`
@@ -42,13 +43,14 @@ Status: developer preview. Experimental protocol surfaces may change.
 
 The generated MSP wire types live in the companion package
 [`muse-code-msp`](https://pypi.org/project/muse-code-msp/) and are never
-restated here. One runtime dependency: `pydantic`, exact-pinned.
+restated here; it is installed with this package, pinned to the same version.
+One further runtime dependency: `pydantic`, exact-pinned.
 Python 3.10+. Fully typed (`py.typed`).
 
 ## Install
 
 ```sh
-pip install muse-code-sdk muse-code-msp
+pip install muse-code-sdk
 ```
 
 You also need the Muse Code CLI: a `muse` binary on `PATH`, or an explicit
@@ -82,6 +84,47 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
+To run a session and the child agents it starts without approval prompts,
+start it under the built-in `:unrestricted` permission profile. Current
+releases admit every child of such a session without prompts; a child admitted
+with a narrower authority would stay gated at it.
+
+That profile is described, verbatim, as "No filesystem sandbox or approval
+prompts; local commands have direct network access; project trust is
+unchanged." It also sets the approval reviewer to none. Use it only for a
+trusted workspace and trusted prompts. Never use it where the prompts or the
+sandbox are what protects you.
+
+Start it with that profile, and pass the same profile when you resume it.
+Paste inside `main()` above, indented, before `await client.close()`, with the same client:
+
+```python
+from muse_code import ResumeSessionOptions, StartSessionOptions
+
+session = await client.start_session(StartSessionOptions(
+    workspace_root="/path/to/repo",  # an absolute path
+    permission_profile=":unrestricted",
+))
+saved_session_id = session.session_id
+# ... later, in the same client:
+session = await client.resume_session(ResumeSessionOptions(
+    session_id=saved_session_id,
+    permission_profile=":unrestricted",
+))
+```
+
+On start, `require_permission_profile=True` makes the client prove that the
+pick was applied, and raise `PermissionProfileNotApplied` if it cannot (a
+failed `session/read` read-back raises its own error). A host
+that does not report the committed selection fails that proof even when the
+pick was applied (seen with Muse Code 1.4.12). Resume has no
+`require_permission_profile`, so the client never verifies the pick there.
+
+`approval_mode` alone is not enough: it changes the session's own approval
+mode, but its child agents are capped by the session's permission profile.
+Under a prompting profile (such as `:ask-me`, whose approval is `on_request`),
+the children still ask.
+
 ## Documentation
 
 - Guides, cookbook recipes, and the protocol reference:

muse_code_sdk-1.4.13/src/muse_code_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pydantic==2.13.5
+muse-code-msp==1.4.13

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/tests/test_facade_approval.py

@@ -687,6 +687,53 @@ async def test_an_approval_updated_that_advances_the_requirement_re_asks_the_han
     assert session.fold.pending_approvals() == []
 
 
+CUA_CARD_FACTS: Params = {
+    "page": {"host": "shop.example.com", "hostAscii": "shop.example.com"},
+    "steps": [
+        {
+            "step": 1,
+            "kind": "verb:buy",
+            "action": "click",
+            "effect": "may buy or pay with your account",
+            "roleWord": "button",
+            "label": "Place order",
+        }
+    ],
+}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("facts", [CUA_CARD_FACTS, None])
+async def test_a_stage_advance_keeps_the_requests_cua_card_facts(facts: Any) -> None:
+    # `cuaCardFacts` belongs to the call and `approval/updated` doesn't carry
+    # it, so the refreshed stage-2 request keeps the original request's facts,
+    # and a request without facts stays without the key.
+    transport, session, minted = wired()
+    seen: List[Params] = []
+
+    def handler(request: Any) -> ApprovalDecisionInput:
+        seen.append(dict(request))
+        return ApprovalDecisionInput(choice_id="allow_once")
+
+    session.on_approval(handler)
+    overrides: Params = {} if facts is None else {"cuaCardFacts": facts}
+    first = session.apply(approval_requested(**overrides))
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, {**decide_result("mint-0"), "terminal": False})
+    await settled_io(first.io)
+
+    updated = session.apply(stage_resolved(2, CHOICES))
+    await wait_for_writes(transport, 2)
+    assert minted == ["mint-0", "mint-1"]
+    assert len(seen) == 2
+    if facts is None:
+        assert "cuaCardFacts" not in seen[1]
+    else:
+        assert seen[1]["cuaCardFacts"] == facts
+    answer(transport, 1, decide_result("mint-1"))
+    await settled_io(updated.io)
+
+
 @pytest.mark.asyncio
 async def test_an_approval_updated_naming_the_decided_stage_asks_nothing() -> None:
     # The per-stage latch: an update that still names the stage this client

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/tests/test_manifests.py

@@ -3,7 +3,7 @@
 The governing rule: the two package manifests carry the chartered shape
 (names, floor, wheel purity, license, ``py.typed``), the dependency posture
 holds (zero runtime deps in ``muse_code_msp``; exactly one exact-pinned
-pydantic in ``muse_code``; every dev tool exact-pinned in the committed
+pydantic plus ``muse-code-msp`` at the facade's own version in ``muse_code``; every dev tool exact-pinned in the committed
 lock), and the schema-fingerprint pin binds to the stable bundle manifest so
 a schema advance that forgets the Python SDK reds this lane.
 """
@@ -66,13 +66,17 @@ def test_facade_package_manifest_shape() -> None:
     assert project["name"] == "muse-code-sdk"
     assert project["requires-python"] == ">=3.10"
     deps = project.get("dependencies", [])
-    assert len(deps) == 1, (
+    assert len(deps) == 2, (
         f"muse_code declares {len(deps)} runtime dependencies; the ruled "
-        "grant is exactly one (pydantic, exact pin)"
+        "grant is exactly two: pydantic (exact pin) and the companion "
+        "wire-types package at the facade's own version"
     )
     assert re.fullmatch(r"pydantic==\d+(\.\d+)+", deps[0]), (
         f"the pydantic dependency must be an exact pin, got: {deps[0]!r}"
     )
+    assert deps[1] == f"muse-code-msp=={project['version']}", (
+        f"the wire-types dependency must be pinned to the facade's own version, got: {deps[1]!r}"
+    )
     assert "license" in project
     assert (SDK_DIR / "src" / "muse_code" / "py.typed").is_file()
 

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/tests/test_publish_shape.py

@@ -16,6 +16,7 @@ regressed package.
 from __future__ import annotations
 
 import json
+import os
 import re
 import subprocess
 import sys
@@ -181,28 +182,39 @@ def test_the_classifiers_state_the_posture() -> None:
         )
 
 
-def test_the_wire_types_stay_out_of_the_facade_dependencies() -> None:
-    # The rule's letter: exactly one runtime dependency (the pydantic pin);
-    # any second, for either package, is an owner escalation. muse-code-msp is
-    # therefore deliberately NOT declared, the @muse-code/msp devDependency
-    # precedent: it does not exist on the registry, and declaring it before it
-    # does would turn a working editable install into a hard `pip install`
-    # failure. The gate script's printed owner-run sequence publishes
-    # muse-code-msp FIRST; promoting it into dependencies at that point is the
-    # owner escalation the governing rule names, decided with the publish itself.
-    deps = _pyproject(SDK_DIR)["project"].get("dependencies", [])
-    assert all(not d.startswith("muse-code-msp") for d in deps)
+def test_the_wire_types_are_a_same_version_pin_of_the_facade() -> None:
+    # The facade imports the generated wire types at import time, so a plain
+    # `pip install muse-code-sdk` must bring them along: muse-code-msp is the
+    # facade's second runtime dependency, exact-pinned to the facade's OWN
+    # version (both packages are versioned and released from the same tree,
+    # wire types first). The release bump rewrites the facade's version and
+    # its muse-code-msp pin together (pydantic bumps stay reviewed PRs); a
+    # drift between them, or a range, is a packaging defect. The wire-types
+    # package itself still declares no runtime dependency.
+    sdk = _pyproject(SDK_DIR)["project"]
+    deps = sdk.get("dependencies", [])
+    msp_pins = [d for d in deps if d.startswith("muse-code-msp")]
+    assert msp_pins == [f"muse-code-msp=={sdk['version']}"], (
+        f"muse-code-msp must be pinned to the facade's own version {sdk['version']!r}, got {msp_pins!r}"
+    )
+    assert sdk["version"] == _pyproject(MSP_DIR)["project"]["version"]
+    assert [d for d in deps if not d.startswith("muse-code-msp")] == [
+        d for d in deps if d.startswith("pydantic==")
+    ], "besides the wire types, pydantic (exact pin) is the only runtime dependency"
     assert _pyproject(MSP_DIR)["project"].get("dependencies", []) == []
 
 
 def _run_gate(
-    *args: str, env: dict[str, str] | None = None
+    *args: str, env: dict[str, str] | None = None, script: Path = GATE_SCRIPT
 ) -> subprocess.CompletedProcess[str]:
     # The env is built from scratch — GITHUB_ACTIONS and the OIDC variables
     # are absent unless a test passes them — so the refusal arms below see
-    # exactly the context they assert, wherever the suite itself runs.
+    # exactly the context they assert, wherever the suite itself runs. Every
+    # gate run, the checked-in script or a copied layout's, goes through here,
+    # so each carries the same wall (review 5581715933: an uncapped child wait
+    # would hang the lane instead of failing a named test).
     return subprocess.run(
-        [str(GATE_SCRIPT), *args],
+        [str(script), *args],
         capture_output=True,
         text=True,
         timeout=GATE_WALL_SECONDS,
@@ -361,6 +373,64 @@ def test_the_publish_path_cannot_ship_a_wheel_without_its_row(tmp_path: Path) ->
     assert "do not match the derived rows" in result.stderr
 
 
+def _copied_gate_layout(tmp_path: Path) -> Path:
+    # The gate reads its repo root from its own location, so a copy of the
+    # script plus exactly the files its manifest-identity gates read makes a
+    # seedable tree; build-only mode notes a missing anchor and tolerates a
+    # non-git tree, so the run reaches the dependency-posture gate.
+    for source in (
+        "scripts/publish-sdk-pypi.sh",
+        "scripts/check-public-mirror-text.py",
+        "clients/msp-py/pyproject.toml",
+        "clients/msp-py/LICENSE",
+        "clients/msp-py/README.md",
+        "clients/sdk-py/pyproject.toml",
+        "clients/sdk-py/LICENSE",
+        "clients/sdk-py/README.md",
+        "schema/msp/stable/manifest.json",
+    ):
+        target = tmp_path / source
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes((PROJECT_ROOT / source).read_bytes())
+    script = tmp_path / "scripts" / "publish-sdk-pypi.sh"
+    script.chmod(0o755)
+    return script
+
+
+def _run_copied_gate(script: Path) -> subprocess.CompletedProcess[str]:
+    return _run_gate("--build-only", env={"HOME": os.environ.get("HOME", "/tmp")}, script=script)
+
+
+def test_the_dependency_gate_refuses_a_drifted_or_missing_wire_types_pin(tmp_path: Path) -> None:
+    # The same-version rule: the wire-types pin must equal the facade's own
+    # version. The committed tree can never carry a drift (the pairing test
+    # above), so each fault is seeded into a copied layout and the gate must
+    # die naming the facade's own version, not pass to the build.
+    manifest = PROJECT_ROOT / "clients" / "sdk-py" / "pyproject.toml"
+    own = _pyproject(SDK_DIR)["project"]["version"]
+    for label, seeded in (
+        ("drifted", manifest.read_text().replace('"muse-code-msp==', '"muse-code-msp==1.0.0-never-', 1)),
+        ("missing", re.sub(r',\s*"muse-code-msp==[^"]+"', "", manifest.read_text(), count=1)),
+        # A valid-shape pin at the WRONG version: the shape regex accepts it, only the ==own-version half refuses
+        # it (review 5580868376 P1: without this seed a gate trimmed to the shape check stays green).
+        ("stale", manifest.read_text().replace(f'"muse-code-msp=={own}"', '"muse-code-msp==0.0.1"', 1)),
+    ):
+        root = tmp_path / label
+        script = _copied_gate_layout(root)
+        copy = root / "clients" / "sdk-py" / "pyproject.toml"
+        assert seeded != manifest.read_text(), f"{label}: the fault must change the manifest"
+        copy.write_text(seeded)
+        result = _run_copied_gate(script)
+        assert result.returncode != 0, f"{label}: the gate must refuse:\n{result.stdout}\n{result.stderr}"
+        assert "the facade's own version" in (result.stdout + result.stderr), (
+            f"{label}: the refusal must name the same-version rule:\n{result.stdout}\n{result.stderr}"
+        )
+        if label == "stale":
+            assert "muse-code-msp==0.0.1" in (result.stdout + result.stderr), (
+                f"{label}: the refusal must quote the stale pin it found:\n{result.stdout}\n{result.stderr}"
+            )
+
+
 def test_a_pre_release_version_refuses_the_row_derivation(tmp_path: Path) -> None:
     # The plain-X.Y.Z refusal, proven under its fault: setuptools would
     # normalize a PEP 440 suffix in the built wheel's filename, so the

{muse_code_sdk-1.4.11 → muse_code_sdk-1.4.13}/tests/test_recovery_observation.py

@@ -151,6 +151,18 @@ async def test_absent_malformed_or_unbound_observation_is_unknown(diagnose, obse
 @pytest.mark.asyncio
 @pytest.mark.parametrize("delta, support, expected", [
     ({"effectiveMode": "on", "effectiveSource": "request", "qualification": "qualified"}, "recognized", "qualified"),
+    pytest.param(
+        {"effectiveMode": "on", "effectiveSource": "retained", "qualification": "qualified"},
+        "recognized", "qualified", id="retained-source",
+    ),
+    pytest.param(
+        {"effectiveMode": "off", "effectiveSource": "hostPolicy", "qualification": "notRequired"},
+        "recognized", "unknown", id="host-policy-source",
+    ),
+    pytest.param(
+        {"effectiveMode": "on", "effectiveSource": "request", "qualification": "unknown"},
+        "recognized", "unknown", id="unknown-qualification",
+    ),
     pytest.param(
         {"effectiveMode": "on", "effectiveSource": "request", "qualification": "future-value"},
         "unknown", "unknown", id="future-qualification",

muse_code_sdk-1.4.11/src/muse_code_sdk.egg-info/requires.txt

@@ -1 +0,0 @@
-pydantic==2.13.5