create-windy 0.5.1 → 0.6.0

package/template/apps/document-server/tests/test_multipart_security.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import tempfile
+from collections.abc import AsyncIterator
+from pathlib import Path
+
+import httpx
+import pytest
+
+from southwind_document_server.adapter_errors import SafeDocumentError
+from southwind_document_server.contracts import (
+    OutputArtifactLimits,
+    OutputArtifactSinkDescriptor,
+)
+from southwind_document_server.multipart_output import parse_adapter_response
+
+from .support import artifact_declaration, document_output, sink_descriptor
+from .test_adapter import multipart_response
+
+
+class BlockingMultipartStream(httpx.AsyncByteStream):
+    def __init__(self, prefix: bytes) -> None:
+        self.prefix = prefix
+        self.blocked = asyncio.Event()
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield self.prefix
+        self.blocked.set()
+        await asyncio.Event().wait()
+        yield b"unreachable"
+
+
+async def test_multipart_requires_manifest_first_and_exact_content_type() -> None:
+    wrong_type = httpx.Response(
+        200,
+        headers={"content-type": "application/octet-stream"},
+        content=b"provider-output",
+    )
+    await assert_invalid(wrong_type)
+
+    boundary = "southwind-document-v1"
+    artifact_first = httpx.Response(
+        200,
+        headers={"content-type": f"multipart/related; boundary={boundary}"},
+        content=(
+            f"--{boundary}\r\n"
+            "Content-Type: application/pdf\r\n"
+            "Content-Length: 4\r\n\r\n"
+            "data\r\n"
+            f"--{boundary}--\r\n"
+        ).encode(),
+    )
+    await assert_invalid(artifact_first)
+
+
+async def test_multipart_enforces_aggregate_and_part_mime_bounds() -> None:
+    first = b"123456"
+    second = b"abcdef"
+    declarations = [
+        artifact_declaration(
+            len(first),
+            hashlib.sha256(first).hexdigest(),
+        ),
+        artifact_declaration(
+            len(second),
+            hashlib.sha256(second).hexdigest(),
+        ).model_copy(
+            update={
+                "output_key": "searchable-pdf-2",
+                "filename": "searchable-2.pdf",
+            }
+        ),
+    ]
+    sink = sink_descriptor().model_copy(
+        update={
+            "limits": OutputArtifactLimits(
+                max_artifact_bytes=10,
+                max_artifacts=2,
+                max_total_bytes=10,
+            )
+        }
+    )
+    total_overrun = multipart_response(
+        document_output([item.model_dump(by_alias=True) for item in declarations]),
+        [
+            (declarations[0].output_key, first),
+            (declarations[1].output_key, second),
+        ],
+    )
+    await assert_invalid(total_overrun, sink)
+
+    payload = b"%PDF-mime"
+    declaration = artifact_declaration(
+        len(payload),
+        hashlib.sha256(payload).hexdigest(),
+    )
+    valid = multipart_response(
+        document_output([declaration.model_dump(by_alias=True)]),
+        [(declaration.output_key, payload)],
+    )
+    mime_drift = httpx.Response(
+        200,
+        headers=valid.headers,
+        content=valid.content.replace(
+            b"Content-Type: application/pdf\r\n",
+            b"Content-Type: audio/wav\r\n",
+        ),
+    )
+    await assert_invalid(mime_drift)
+
+
+async def test_multipart_rejects_declared_part_length_drift() -> None:
+    payload = b"%PDF-length"
+    declaration = artifact_declaration(
+        len(payload),
+        hashlib.sha256(payload).hexdigest(),
+    )
+    response = multipart_response(
+        document_output([declaration.model_dump(by_alias=True)]),
+        [(declaration.output_key, payload)],
+        declared_lengths=[len(payload) + 1],
+    )
+    await assert_invalid(response)
+
+
+async def test_truncated_current_part_removes_tempfile(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    payload = b"%PDF-truncated-current"
+    declaration = artifact_declaration(
+        len(payload),
+        hashlib.sha256(payload).hexdigest(),
+    )
+    complete = multipart_response(
+        document_output([declaration.model_dump(by_alias=True)]),
+        [(declaration.output_key, payload)],
+    )
+    start = complete.content.index(payload)
+    truncated = httpx.Response(
+        200,
+        headers=complete.headers,
+        content=complete.content[: start + 3],
+    )
+    monkeypatch.setattr(tempfile, "tempdir", str(tmp_path))
+
+    with pytest.raises(SafeDocumentError):
+        await parse_adapter_response(
+            truncated,
+            64 * 1024,
+            20,
+            sink_descriptor(),
+        )
+    assert await asyncio.to_thread(lambda: not any(tmp_path.iterdir()))
+
+
+async def test_cancelled_second_part_removes_all_tempfiles(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    first = b"%PDF-complete-first"
+    second = b"%PDF-blocked-second"
+    declarations = [
+        artifact_declaration(len(first), hashlib.sha256(first).hexdigest()),
+        artifact_declaration(
+            len(second),
+            hashlib.sha256(second).hexdigest(),
+        ).model_copy(
+            update={
+                "output_key": "searchable-pdf-2",
+                "filename": "searchable-2.pdf",
+            }
+        ),
+    ]
+    complete = multipart_response(
+        document_output([item.model_dump(by_alias=True) for item in declarations]),
+        [
+            (declarations[0].output_key, first),
+            (declarations[1].output_key, second),
+        ],
+    )
+    second_start = complete.content.rindex(second)
+    stream = BlockingMultipartStream(complete.content[: second_start + 3])
+    response = httpx.Response(
+        200,
+        headers=complete.headers,
+        stream=stream,
+    )
+    monkeypatch.setattr(tempfile, "tempdir", str(tmp_path))
+
+    task = asyncio.create_task(
+        parse_adapter_response(
+            response,
+            64 * 1024,
+            20,
+            sink_descriptor().model_copy(
+                update={
+                    "limits": OutputArtifactLimits(
+                        max_artifact_bytes=32 * 1024,
+                        max_artifacts=2,
+                        max_total_bytes=64 * 1024,
+                    )
+                }
+            ),
+        )
+    )
+    await stream.blocked.wait()
+    task.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await task
+    assert await asyncio.to_thread(lambda: not any(tmp_path.iterdir()))
+
+
+async def test_manifest_and_artifacts_share_one_public_output_budget(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    payload = b"x" * 900
+    declaration = artifact_declaration(
+        len(payload),
+        hashlib.sha256(payload).hexdigest(),
+    )
+    complete = multipart_response(
+        document_output([declaration.model_dump(by_alias=True)]),
+        [(declaration.output_key, payload)],
+    )
+    manifest_start = complete.content.index(b'{"pages"')
+    manifest_end = complete.content.index(b"\r\n--", manifest_start)
+    manifest_size = manifest_end - manifest_start
+    public_limit = 1024
+    assert manifest_size <= public_limit
+    assert len(payload) <= public_limit
+    assert manifest_size + len(payload) > public_limit
+    monkeypatch.setattr(tempfile, "tempdir", str(tmp_path))
+
+    with pytest.raises(SafeDocumentError):
+        await parse_adapter_response(
+            complete,
+            public_limit,
+            20,
+            sink_descriptor(),
+        )
+    assert await asyncio.to_thread(lambda: not any(tmp_path.iterdir()))
+
+
+async def assert_invalid(
+    response: httpx.Response,
+    sink: OutputArtifactSinkDescriptor | None = None,
+) -> None:
+    descriptor = sink or sink_descriptor()
+    try:
+        await parse_adapter_response(response, 64 * 1024, 20, descriptor)
+    except SafeDocumentError as error:
+        assert error.code == "OUTPUT_VALIDATION_FAILED"
+    else:
+        raise AssertionError("非法 multipart 必须拒绝")

package/template/apps/document-server/tests/test_readiness.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import AsyncIterator
+from dataclasses import replace
+from datetime import UTC, datetime, timedelta
+
+import httpx
+import pytest
+
+from southwind_document_server.adapter import DocumentAdapter
+from southwind_document_server.adapter_errors import SafeDocumentError
+from southwind_document_server.readiness import DocumentReadinessProbe
+from southwind_document_server.readiness_contracts import (
+    DOCUMENT_OUTPUT_ARTIFACT_CAPABILITY_V1,
+)
+
+from .support import (
+    adapter_readiness_payload,
+    document_request,
+    readiness_facts,
+    readiness_sink_descriptor,
+    runtime_config,
+    sink_descriptor,
+    sink_readiness_payload,
+)
+
+
+async def test_real_probe_emits_v1_snapshot_and_checks_sink_protocol() -> None:
+    calls: list[tuple[str, str | None]] = []
+    config = replace(runtime_config(), adapter_token="adapter-secret")
+
+    async def adapter_handler(request: httpx.Request) -> httpx.Response:
+        calls.append((request.url.path, request.headers.get("authorization")))
+        return httpx.Response(200, json=adapter_readiness_payload())
+
+    async def sink_handler(request: httpx.Request) -> httpx.Response:
+        calls.append((request.url.path, request.headers.get("authorization")))
+        return httpx.Response(200, json=sink_readiness_payload())
+
+    inspection = await DocumentReadinessProbe(
+        config,
+        httpx.MockTransport(adapter_handler),
+        httpx.MockTransport(sink_handler),
+    ).inspect()
+
+    assert inspection.ready
+    assert calls == [
+        ("/v1/document/readiness", "Bearer adapter-secret"),
+        (
+            "/api/internal/ai/output-artifacts/health/ready",
+            "Bearer internal",
+        ),
+    ]
+    assert inspection.snapshot["schemaVersion"] == 1
+    assert inspection.snapshot["runtimeKind"] == "document"
+    assert inspection.snapshot["deployment"] == {
+        "key": config.deployment_key,
+        "identity": config.deployment_identity,
+        "releaseDigest": config.release_digest,
+        "offersDigest": config.offers_digest,
+    }
+    offer = inspection.offers[0]
+    capabilities = offer["capabilities"]
+    assert isinstance(capabilities, list)
+    assert DOCUMENT_OUTPUT_ARTIFACT_CAPABILITY_V1 in capabilities
+
+
+async def test_missing_producer_identity_is_not_configured_without_network() -> None:
+    called = False
+
+    async def handler(_request: httpx.Request) -> httpx.Response:
+        nonlocal called
+        called = True
+        return httpx.Response(200, json=adapter_readiness_payload())
+
+    config = replace(runtime_config(), deployment_identity=None)
+    inspection = await DocumentReadinessProbe(
+        config,
+        httpx.MockTransport(handler),
+    ).inspect()
+
+    assert not called
+    assert inspection.snapshot["status"] == "unavailable"
+    assert inspection.snapshot["configured"] is False
+    assert inspection.snapshot["unavailableReasons"] == [
+        {"code": "RUNTIME_NOT_CONFIGURED", "retryable": True}
+    ]
+
+
+async def test_unreachable_timeout_malformed_and_unknown_fail_closed() -> None:
+    async def connection_failed(_request: httpx.Request) -> httpx.Response:
+        raise httpx.ConnectError("secret endpoint")
+
+    failed = await DocumentReadinessProbe(
+        runtime_config(),
+        httpx.MockTransport(connection_failed),
+    ).inspect()
+    assert failure(failed.snapshot) == ("CONNECTION_FAILED", True)
+
+    async def slow(_request: httpx.Request) -> httpx.Response:
+        await asyncio.sleep(0.05)
+        return httpx.Response(200, json=adapter_readiness_payload())
+
+    timed_out = await DocumentReadinessProbe(
+        replace(runtime_config(), readiness_timeout_seconds=0.001),
+        httpx.MockTransport(slow),
+    ).inspect()
+    assert failure(timed_out.snapshot) == ("TIMEOUT", True)
+
+    malformed = await DocumentReadinessProbe(
+        runtime_config(),
+        httpx.MockTransport(
+            lambda _request: httpx.Response(
+                200,
+                headers={"content-type": "application/json"},
+                content=b'{"contractVersion":1,"contractVersion":1}',
+            )
+        ),
+    ).inspect()
+    assert failure(malformed.snapshot) == ("INVALID_RESPONSE", False)
+
+    unknown = adapter_readiness_payload()
+    unknown["providerBody"] = "must-not-pass"
+    invalid = await DocumentReadinessProbe(
+        runtime_config(),
+        httpx.MockTransport(lambda _request: httpx.Response(200, json=unknown)),
+    ).inspect()
+    assert failure(invalid.snapshot) == ("INVALID_RESPONSE", False)
+    assert "must-not-pass" not in json.dumps(invalid.snapshot)
+
+
+async def test_oversized_chunked_probe_response_fails_before_copy() -> None:
+    class OversizedBody(httpx.AsyncByteStream):
+        async def __aiter__(self) -> AsyncIterator[bytes]:
+            yield b" " * (64 * 1024)
+            yield b"x"
+
+    probe = DocumentReadinessProbe(
+        runtime_config(),
+        httpx.MockTransport(
+            lambda _request: httpx.Response(
+                200,
+                headers={"content-type": "application/json"},
+                stream=OversizedBody(),
+            )
+        ),
+    )
+
+    inspection = await probe.inspect()
+    assert failure(inspection.snapshot) == ("INVALID_RESPONSE", False)
+
+
+async def test_sink_unavailable_and_offers_drift_fail_closed() -> None:
+    adapter = httpx.MockTransport(
+        lambda _request: httpx.Response(
+            200,
+            json=adapter_readiness_payload(),
+        )
+    )
+    sink = httpx.MockTransport(
+        lambda _request: httpx.Response(503, json={"detail": "secret"})
+    )
+    unavailable = await DocumentReadinessProbe(
+        runtime_config(),
+        adapter,
+        sink,
+    ).inspect()
+    assert failure(unavailable.snapshot) == ("RESOURCE_UNAVAILABLE", True)
+
+    drifted = await DocumentReadinessProbe(
+        replace(runtime_config(), offers_digest=f"sha256:{'f' * 64}"),
+        adapter,
+        httpx.MockTransport(
+            lambda _request: httpx.Response(200, json=sink_readiness_payload())
+        ),
+    ).inspect()
+    assert failure(drifted.snapshot) == ("INVALID_RESPONSE", False)
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    [
+        (
+            "identity",
+            "windy-deployment-v1_3a77bbd9-2c2e-46af-8b5d-f015247970fe",
+        ),
+        ("releaseDigest", f"sha256:{'8' * 64}"),
+        ("protocolVersion", 2),
+    ],
+)
+async def test_sink_identity_release_and_protocol_drift_fail_closed(
+    field: str,
+    value: object,
+) -> None:
+    payload = sink_readiness_payload()
+    sink = payload["sink"]
+    assert isinstance(sink, dict)
+    sink[field] = value
+    inspection = await DocumentReadinessProbe(
+        runtime_config(),
+        httpx.MockTransport(
+            lambda request: httpx.Response(
+                200,
+                json=(
+                    adapter_readiness_payload()
+                    if request.url.path.endswith("/readiness")
+                    else payload
+                ),
+            )
+        ),
+    ).inspect()
+
+    assert failure(inspection.snapshot) == ("INVALID_RESPONSE", False)
+
+
+async def test_non_artifact_offer_does_not_probe_sink_or_claim_capability() -> None:
+    release_digest, offers_digest = readiness_facts(output_artifact=False)
+    sink_called = False
+
+    async def sink_handler(_request: httpx.Request) -> httpx.Response:
+        nonlocal sink_called
+        sink_called = True
+        return httpx.Response(200, json=sink_readiness_payload())
+
+    probe = DocumentReadinessProbe(
+        replace(
+            runtime_config(),
+            release_digest=release_digest,
+            offers_digest=offers_digest,
+        ),
+        httpx.MockTransport(
+            lambda _request: httpx.Response(
+                200,
+                json=adapter_readiness_payload(output_artifact=False),
+            )
+        ),
+        httpx.MockTransport(sink_handler),
+    )
+    inspection = await probe.inspect()
+
+    assert inspection.ready
+    assert not sink_called
+    capabilities = inspection.offers[0]["capabilities"]
+    assert isinstance(capabilities, list)
+    assert DOCUMENT_OUTPUT_ARTIFACT_CAPABILITY_V1 not in capabilities
+    assert not probe.supports(
+        inspection,
+        document_request(sink=readiness_sink_descriptor()),
+    )
+
+
+async def test_execution_reprobes_and_rejects_drifted_output_sink() -> None:
+    async def handler(request: httpx.Request) -> httpx.Response:
+        if request.url.path.endswith("/v1/document/readiness"):
+            return httpx.Response(200, json=adapter_readiness_payload())
+        if request.url.path.endswith("/health/ready"):
+            return httpx.Response(200, json=sink_readiness_payload())
+        raise AssertionError("漂移必须在读取 Artifact 前失败")
+
+    adapter = DocumentAdapter(
+        runtime_config(),
+        httpx.MockTransport(handler),
+    )
+    with pytest.raises(SafeDocumentError) as captured:
+        await adapter.execute(document_request(sink=sink_descriptor()))
+
+    assert captured.value.code == "CAPABILITY_UNAVAILABLE"
+
+
+async def test_probe_completion_and_execute_use_half_open_expiry() -> None:
+    checked_at = datetime(2026, 7, 31, 12, 0, tzinfo=UTC)
+    adapter = httpx.MockTransport(
+        lambda request: httpx.Response(
+            200,
+            json=(
+                adapter_readiness_payload()
+                if request.url.path.endswith("/readiness")
+                else sink_readiness_payload()
+            ),
+        )
+    )
+    completion_clock = iter([checked_at, checked_at + timedelta(seconds=60)])
+    stale = await DocumentReadinessProbe(
+        runtime_config(),
+        adapter,
+        wall_clock=lambda: next(completion_clock),
+        monotonic_clock=lambda: 0,
+    ).inspect()
+    assert stale.snapshot["status"] == "unavailable"
+    assert stale.snapshot["unavailableReasons"] == [
+        {"code": "PROBE_STALE", "retryable": True}
+    ]
+
+    execution_clock = iter([checked_at, checked_at, checked_at + timedelta(seconds=60)])
+    runtime = DocumentAdapter(
+        runtime_config(),
+        adapter,
+        wall_clock=lambda: next(execution_clock),
+        monotonic_clock=lambda: 0,
+    )
+    with pytest.raises(SafeDocumentError) as captured:
+        await runtime.execute(document_request())
+    assert captured.value.code == "CAPABILITY_UNAVAILABLE"
+
+
+def failure(snapshot: dict[str, object]) -> tuple[str, bool]:
+    probe = snapshot["downstreamProbe"]
+    assert isinstance(probe, dict)
+    return str(probe["failureCode"]), bool(probe["retryable"])

package/template/apps/document-server/tests/test_readiness_contracts.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+import pytest
+from pydantic import ValidationError
+
+from southwind_document_server.readiness_contracts import (
+    AdapterDocumentReadinessV1,
+    OutputArtifactSinkReadinessV1,
+    compute_offers_digest,
+    compute_release_digest,
+)
+
+from .support import adapter_readiness_payload, sink_readiness_payload
+
+
+def test_release_digest_binds_variant_versions_and_sink_facts() -> None:
+    first = adapter_readiness_payload(output_artifact=False)
+    offer = dict(cast_list(first["offers"])[0])
+    first["offers"] = [
+        {**offer, "variant": "fast", "capabilityVersion": "adapter-v1"},
+        {**offer, "variant": "accurate", "capabilityVersion": "adapter-v2"},
+    ]
+    swapped = json.loads(json.dumps(first))
+    cast_list(swapped["offers"])[0]["capabilityVersion"] = "adapter-v2"
+    cast_list(swapped["offers"])[1]["capabilityVersion"] = "adapter-v1"
+    left = AdapterDocumentReadinessV1.model_validate(first)
+    right = AdapterDocumentReadinessV1.model_validate(swapped)
+    assert compute_release_digest(left, None) != compute_release_digest(right, None)
+
+    sink = OutputArtifactSinkReadinessV1.model_validate(sink_readiness_payload())
+    drifted_payload = sink_readiness_payload()
+    drifted_sink = dict(cast_dict(drifted_payload["sink"]))
+    drifted_sink["releaseDigest"] = f"sha256:{'8' * 64}"
+    drifted_payload["sink"] = drifted_sink
+    drifted = OutputArtifactSinkReadinessV1.model_validate(drifted_payload)
+    adapter = AdapterDocumentReadinessV1.model_validate(adapter_readiness_payload())
+    assert compute_release_digest(adapter, sink) != compute_release_digest(
+        adapter, drifted
+    )
+
+
+def test_python_cardinality_and_safe_integer_match_common_v1_fixture() -> None:
+    boundary = load_fixture("document-python-parity.json")
+    payload = adapter_readiness_payload(output_artifact=False)
+    base = dict(cast_list(payload["offers"])[0])
+    base["capabilities"] = [
+        f"document.capability-{index}"
+        for index in range(boundary["maxCapabilitiesPerOffer"])
+    ]
+    modalities = ["text", "image", "audio", "video", "document", "embedding"]
+    assert len(modalities) == boundary["maxModalities"]
+    base["inputModalities"] = modalities
+    base["outputModalities"] = modalities
+    limits = dict(cast_dict(base["limits"]))
+    for key in limits:
+        limits[key] = 0 if key == "maxQueueDepth" else boundary["maxSafeInteger"]
+    base["limits"] = limits
+    payload["offers"] = [
+        {**base, "variant": f"variant-{index}"}
+        for index in range(boundary["maxOffers"])
+    ]
+    AdapterDocumentReadinessV1.model_validate(payload)
+
+    too_many_capabilities = json.loads(json.dumps(payload))
+    capabilities = cast_list(too_many_capabilities["offers"])[0]["capabilities"]
+    assert isinstance(capabilities, list)
+    capabilities.append("document.capability-overflow")
+    with pytest.raises(ValidationError):
+        AdapterDocumentReadinessV1.model_validate(too_many_capabilities)
+
+    unsafe = json.loads(json.dumps(payload))
+    cast_dict(cast_list(unsafe["offers"])[0]["limits"])["maxInputBytes"] = boundary[
+        "firstUnsafeInteger"
+    ]
+    with pytest.raises(ValidationError):
+        AdapterDocumentReadinessV1.model_validate(unsafe)
+
+
+def test_python_integer_number_parity_matches_common_v1_fixture() -> None:
+    boundary = load_fixture("document-python-parity.json")
+    numbers = cast(dict[str, list[object]], boundary["integerNumbers"])
+    for value in numbers["acceptedJson"]:
+        payload = adapter_readiness_payload(output_artifact=False)
+        cast_dict(cast_list(payload["offers"])[0]["limits"])["maxInputBytes"] = value
+        parsed = AdapterDocumentReadinessV1.model_validate(payload)
+        assert parsed.offers[0].limits.max_input_bytes == int(cast(int | float, value))
+
+    rejected = [
+        *numbers["rejectedJson"],
+        *(float(cast(str, token)) for token in numbers["rejectedNonFinite"]),
+    ]
+    for value in rejected:
+        payload = adapter_readiness_payload(output_artifact=False)
+        cast_dict(cast_list(payload["offers"])[0]["limits"])["maxInputBytes"] = value
+        with pytest.raises(ValidationError):
+            AdapterDocumentReadinessV1.model_validate(payload)
+
+
+def test_python_digest_matches_shared_v1_fixture() -> None:
+    fixture = load_fixture("document.json")
+    snapshot = cast_dict(fixture["snapshot"])
+    deployment = cast_dict(snapshot["deployment"])
+    offers = snapshot["offers"]
+    assert isinstance(offers, list)
+    assert compute_offers_digest(offers) == deployment["offersDigest"]
+
+
+def load_fixture(name: str) -> dict[str, Any]:
+    path = (
+        Path(__file__).parents[3]
+        / "packages/server-sdk/contracts/ai-runtime-readiness/v1"
+        / name
+    )
+    value = json.loads(path.read_text())
+    assert isinstance(value, dict)
+    return cast(dict[str, Any], value)
+
+
+def cast_list(value: object) -> list[dict[str, object]]:
+    assert isinstance(value, list)
+    assert all(isinstance(item, dict) for item in value)
+    return value
+
+
+def cast_dict(value: object) -> dict[str, object]:
+    assert isinstance(value, dict)
+    return value