create-windy 0.5.2 → 0.6.1

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

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from datetime import UTC, datetime
+
+import httpx
+
+from southwind_embedding_server.config import EmbeddingConfig
+from southwind_embedding_server.contracts import EmbeddingRequest
+from southwind_embedding_server.pin_cli import compute_pins
+from southwind_embedding_server.readiness import EmbeddingReadinessProbe
+from southwind_embedding_server.readiness_contracts import (
+    AdapterEmbeddingReadinessV1,
+    compute_offers_digest,
+    compute_release_digest,
+    final_offers,
+)
+
+IDENTITY = "windy-deployment-v1_0f26eb34-f384-4ec9-98f3-caf8d582291f"
+ADAPTER_IDENTITY = "windy-deployment-v1_11c93162-e5f0-40af-93ce-9771a4bf12ed"
+DIGEST_A = f"sha256:{'a' * 64}"
+DIGEST_B = f"sha256:{'b' * 64}"
+
+
+def adapter_payload() -> dict[str, object]:
+    return {
+        "contractVersion": 1,
+        "status": "ready",
+        "runtimeKind": "embedding-adapter",
+        "deployment": {
+            "identity": ADAPTER_IDENTITY,
+            "releaseDigest": DIGEST_A,
+            "model": "embedding-model",
+            "version": "2026-08",
+            "dimensions": 3,
+            "normalized": True,
+        },
+        "offers": [
+            {
+                "variant": "text",
+                "capabilityVersion": "embedding.text/v1",
+                "capabilities": ["embedding.text"],
+                "inputModalities": ["text"],
+                "outputModalities": ["embedding"],
+                "limits": limits(),
+            },
+            {
+                "variant": "image",
+                "capabilityVersion": "embedding.image/v1",
+                "capabilities": ["embedding.image"],
+                "inputModalities": ["image"],
+                "outputModalities": ["embedding"],
+                "limits": {
+                    **limits(),
+                    "maxArtifacts": 8,
+                    "maxPixelsPerArtifact": 20_000_000,
+                },
+            },
+        ],
+    }
+
+
+def limits() -> dict[str, int]:
+    return {
+        "maxDurationSeconds": 120,
+        "maxInputBytes": 64 * 1024 * 1024,
+        "maxOutputBytes": 64 * 1024 * 1024,
+        "maxUnits": 64,
+        "maxConcurrentRuns": 2,
+        "maxQueueDepth": 0,
+    }
+
+
+def base_config() -> EmbeddingConfig:
+    return EmbeddingConfig(
+        internal_token="internal",
+        artifact_url="http://server.internal/api/internal/ai/artifacts",
+        run_artifact_url="http://server.internal/api/internal/embeddings/runs",
+        adapter_url="http://adapter.internal",
+        adapter_token="adapter-token",
+        deployment_key="embedding.primary",
+        deployment_identity=IDENTITY,
+        release_digest=DIGEST_A,
+        offers_digest=DIGEST_B,
+        deployment_alias="intranet-v1",
+        model="embedding-model",
+        version="2026-08",
+        dimensions=3,
+        normalized=True,
+        capabilities=("embedding.text", "embedding.image"),
+        max_concurrent_runs=1,
+        max_queue_depth=0,
+    )
+
+
+def pinned_config() -> EmbeddingConfig:
+    config = base_config()
+    adapter = AdapterEmbeddingReadinessV1.model_validate(adapter_payload())
+    return replace(
+        config,
+        release_digest=compute_release_digest(adapter),
+        offers_digest=compute_offers_digest(final_offers(config, adapter)),
+    )
+
+
+def transport(status: int = 200) -> httpx.MockTransport:
+    return httpx.MockTransport(
+        lambda _request: httpx.Response(status, json=adapter_payload())
+    )
+
+
+def probe(config: EmbeddingConfig, status: int = 200) -> EmbeddingReadinessProbe:
+    return EmbeddingReadinessProbe(
+        config,
+        transport(status),
+        wall_clock=lambda: datetime(2026, 8, 6, 1, 2, 3, 4000, tzinfo=UTC),
+        monotonic_clock=lambda: 10.0,
+    )
+
+
+async def test_readiness_attests_bounded_atomic_offers_and_pins() -> None:
+    config = pinned_config()
+    inspection = await probe(config).inspect()
+
+    assert inspection.ready
+    assert inspection.snapshot["runtimeKind"] == "embedding"
+    assert [offer["variant"] for offer in inspection.offers] == ["text", "image"]
+    deployment = inspection.snapshot["deployment"]
+    assert isinstance(deployment, dict)
+    assert deployment == {
+        "key": config.deployment_key,
+        "identity": config.deployment_identity,
+        "releaseDigest": config.release_digest,
+        "offersDigest": config.offers_digest,
+    }
+
+
+async def test_unconfigured_or_failed_downstream_never_becomes_ready() -> None:
+    missing = await probe(replace(base_config(), adapter_url=None)).inspect()
+    assert not missing.ready
+    assert missing.snapshot["configured"] is False
+
+    failed = await probe(pinned_config(), 503).inspect()
+    assert not failed.ready
+    downstream = failed.snapshot["downstreamProbe"]
+    assert isinstance(downstream, dict)
+    assert downstream["failureCode"] == "RESOURCE_UNAVAILABLE"
+
+
+async def test_request_requires_exact_deployment_pin_and_matching_offer() -> None:
+    readiness = probe(pinned_config())
+    inspection = await readiness.inspect()
+    request = embedding_request(inspection.snapshot["deployment"])
+
+    assert readiness.supports(inspection, request)
+    assert request.readiness_pin is not None
+    drifted = request.model_copy(
+        update={
+            "readiness_pin": request.readiness_pin.model_copy(
+                update={"offers_digest": DIGEST_A}
+            )
+        }
+    )
+    assert not readiness.supports(inspection, drifted)
+    assert readiness.supports(
+        inspection, request.model_copy(update={"readiness_pin": None})
+    )
+
+
+async def test_pin_cli_uses_the_same_real_probe_facts() -> None:
+    config = base_config()
+    pins = await compute_pins(config, transport())
+    expected = pinned_config()
+    assert pins == {
+        "deploymentKey": config.deployment_key,
+        "deploymentIdentity": config.deployment_identity,
+        "releaseDigest": expected.release_digest,
+        "offersDigest": expected.offers_digest,
+    }
+
+
+def embedding_request(deployment: object) -> EmbeddingRequest:
+    assert isinstance(deployment, dict)
+    return EmbeddingRequest.model_validate(
+        {
+            "kind": "embedding",
+            "operationKey": "analysis.embedding.text",
+            "items": [{"id": "one", "text": "安全文本"}],
+            "options": {},
+            "inputModalities": ["text"],
+            "requiredCapabilities": ["embedding.text"],
+            "dataClassification": "sensitive",
+            "limits": {
+                "maxDurationSeconds": 30,
+                "maxInputBytes": 1024,
+                "maxOutputBytes": 1024,
+                "maxUnits": 10,
+            },
+            "providerEgress": {"mode": "forbidden"},
+            "readinessPin": deployment,
+        }
+    )

package/template/apps/embedding-server/tests/test_run_http.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+import httpx
+import pytest
+from fastapi import FastAPI
+
+os.environ.setdefault("EMBEDDING_SERVER_INTERNAL_TOKEN", "test-internal")
+os.environ.setdefault("EMBEDDING_RUN_ENCRYPTION_SECRET", "x" * 32)
+os.environ.setdefault("EMBEDDING_RUN_STORE_PATH", "/tmp/embedding-test-runs.sqlite3")
+os.environ.setdefault("EMBEDDING_DEPLOYMENT_ALIAS", "test")
+os.environ.setdefault("EMBEDDING_MODEL", "test")
+os.environ.setdefault("EMBEDDING_MODEL_VERSION", "test")
+os.environ.setdefault("EMBEDDING_DIMENSIONS", "3")
+
+from southwind_embedding_server.app import create_app
+from southwind_embedding_server.config import EmbeddingConfig
+from southwind_embedding_server.contracts import EmbeddingRequest, EmbeddingResponse
+from southwind_embedding_server.error import SafeEmbeddingError
+from southwind_embedding_server.readiness import EmbeddingReadinessInspection
+
+IDENTITY = "windy-deployment-v1_0f26eb34-f384-4ec9-98f3-caf8d582291f"
+DIGEST_A = f"sha256:{'a' * 64}"
+DIGEST_B = f"sha256:{'b' * 64}"
+
+
+def config(path: str) -> EmbeddingConfig:
+    return EmbeddingConfig(
+        internal_token="internal",
+        artifact_url="http://server:9747/api/internal/ai/artifacts",
+        run_artifact_url="http://server:9747/api/internal/embeddings/runs",
+        adapter_url="http://adapter:9000",
+        adapter_token=None,
+        deployment_key="embedding.primary",
+        deployment_identity=IDENTITY,
+        release_digest=DIGEST_A,
+        offers_digest=DIGEST_B,
+        deployment_alias="intranet-v1",
+        model="embedding-model",
+        version="2026-08",
+        dimensions=3,
+        normalized=True,
+        capabilities=("embedding.text",),
+        run_store_path=path,
+        run_encryption_secret="x" * 32,
+    )
+
+
+def request() -> dict[str, object]:
+    return {
+        "kind": "embedding",
+        "operationKey": "analysis.embedding.text",
+        "items": [{"id": "one", "text": "安全文本"}],
+        "options": {},
+        "inputModalities": ["text"],
+        "requiredCapabilities": ["embedding.text"],
+        "dataClassification": "sensitive",
+        "limits": {
+            "maxDurationSeconds": 30,
+            "maxInputBytes": 1024,
+            "maxOutputBytes": 1024,
+            "maxUnits": 10,
+        },
+        "providerEgress": {"mode": "forbidden"},
+        "readinessPin": {
+            "key": "embedding.primary",
+            "identity": IDENTITY,
+            "releaseDigest": DIGEST_A,
+            "offersDigest": DIGEST_B,
+        },
+    }
+
+
+def response() -> EmbeddingResponse:
+    return EmbeddingResponse.model_validate(
+        {
+            "batchId": "batch-1",
+            "items": [{"id": "one", "vector": [1, 0, 0], "inputSha256": "a" * 64}],
+            "metadata": {
+                "deploymentAlias": "intranet-v1",
+                "model": "embedding-model",
+                "version": "2026-08",
+                "dimensions": 3,
+                "normalized": True,
+            },
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_run_http_success_events_result_and_cancel(tmp_path: Path) -> None:
+    adapter = Adapter(response())
+    app = create_app(config(str(tmp_path / "runs.sqlite3")), adapter, ReadyReadiness())
+    async with client(app) as remote:
+        denied = await remote.post("/api/embeddings/runs", json=request())
+        assert denied.status_code == 403
+        started = await remote.post(
+            "/api/embeddings/runs",
+            headers=headers("start-1"),
+            json=request(),
+        )
+        assert started.status_code == 202
+        run_id = started.json()["runId"]
+        await adapter.called.wait()
+        events = await remote.get(
+            f"/api/embeddings/runs/{run_id}/events", headers=headers()
+        )
+        assert events.status_code == 200
+        assert '"type":"run.started"' in events.text
+        assert '"type":"run.completed"' in events.text
+        result = await remote.get(
+            f"/api/embeddings/runs/{run_id}/result", headers=headers()
+        )
+        assert result.status_code == 200
+        assert result.json()["output"]["batchId"] == "batch-1"
+
+        waiting = Adapter(response(), block=True)
+        cancelled_app = create_app(
+            config(str(tmp_path / "cancel.sqlite3")), waiting, ReadyReadiness()
+        )
+        async with client(cancelled_app) as cancel_remote:
+            accepted = await cancel_remote.post(
+                "/api/embeddings/runs", headers=headers("cancel-1"), json=request()
+            )
+            cancel_id = accepted.json()["runId"]
+            await waiting.called.wait()
+            cancelled = await cancel_remote.post(
+                f"/api/embeddings/runs/{cancel_id}/cancel", headers=headers()
+            )
+            assert cancelled.status_code == 200
+            assert cancelled.json()["status"] == "cancelled"
+
+
+@pytest.mark.asyncio
+async def test_run_http_exposes_safe_remote_failure_only(tmp_path: Path) -> None:
+    app = create_app(
+        config(str(tmp_path / "failed.sqlite3")),
+        Adapter(None, failure=True),
+        ReadyReadiness(),
+    )
+    async with client(app) as remote:
+        started = await remote.post(
+            "/api/embeddings/runs", headers=headers("fail-1"), json=request()
+        )
+        run_id = started.json()["runId"]
+        for _ in range(20):
+            events = await remote.get(
+                f"/api/embeddings/runs/{run_id}/events", headers=headers()
+            )
+            if '"type":"run.failed"' in events.text:
+                break
+            await asyncio.sleep(0)
+        assert '"code":"RUNTIME_UNAVAILABLE"' in events.text
+        result = await remote.get(
+            f"/api/embeddings/runs/{run_id}/result", headers=headers()
+        )
+        assert result.status_code == 409
+        assert result.json()["code"] == "RUN_NOT_READY"
+
+
+@pytest.mark.asyncio
+async def test_unready_request_does_not_create_run(tmp_path: Path) -> None:
+    app = create_app(
+        config(str(tmp_path / "unready.sqlite3")),
+        Adapter(response()),
+        UnreadyReadiness(),
+    )
+    async with client(app) as remote:
+        rejected = await remote.post(
+            "/api/embeddings/runs", headers=headers("unready"), json=request()
+        )
+        assert rejected.status_code == 503
+        missing = await remote.get(
+            "/api/embeddings/runs/embedding_unready/result", headers=headers()
+        )
+        assert missing.status_code == 404
+
+
+class Adapter:
+    def __init__(
+        self,
+        value: EmbeddingResponse | None,
+        failure: bool = False,
+        block: bool = False,
+    ) -> None:
+        self.value = value
+        self.failure = failure
+        self.block = block
+        self.called = asyncio.Event()
+        self.config = config("/tmp/unused.sqlite3")
+
+    async def readiness(self) -> bool:
+        return True
+
+    async def embed(
+        self, _request: EmbeddingRequest, _run_id: str | None = None
+    ) -> EmbeddingResponse:
+        self.called.set()
+        if self.block:
+            await asyncio.Event().wait()
+        if self.failure:
+            raise SafeEmbeddingError("RUNTIME_UNAVAILABLE", "adapter unavailable", True)
+        assert self.value is not None
+        return self.value
+
+
+class ReadyReadiness:
+    async def inspect(self) -> EmbeddingReadinessInspection:
+        return EmbeddingReadinessInspection(
+            {
+                "status": "ready",
+                "deployment": {
+                    "key": "embedding.primary",
+                    "identity": IDENTITY,
+                    "releaseDigest": DIGEST_A,
+                    "offersDigest": DIGEST_B,
+                },
+            },
+            ({"variant": "text"},),
+        )
+
+    def supports(
+        self, _inspection: EmbeddingReadinessInspection, request: EmbeddingRequest
+    ) -> bool:
+        return bool(
+            request.readiness_pin
+            and request.readiness_pin.identity == IDENTITY
+            and request.readiness_pin.release_digest == DIGEST_A
+            and request.readiness_pin.offers_digest == DIGEST_B
+        )
+
+
+class UnreadyReadiness(ReadyReadiness):
+    async def inspect(self) -> EmbeddingReadinessInspection:
+        return EmbeddingReadinessInspection({"status": "unavailable"})
+
+    def supports(
+        self, _inspection: EmbeddingReadinessInspection, _request: EmbeddingRequest
+    ) -> bool:
+        return False
+
+
+def headers(key: str = "read") -> dict[str, str]:
+    return {
+        "authorization": "Bearer internal",
+        "idempotency-key": key,
+        "x-embedding-run-id": f"embedding_{key}",
+    }
+
+
+def client(app: FastAPI) -> httpx.AsyncClient:
+    return httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://embedding"
+    )

package/template/apps/embedding-server/tests/test_run_service.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import asyncio
+import sqlite3
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+
+from southwind_embedding_server.adapter import EmbeddingAdapter
+from southwind_embedding_server.config import EmbeddingConfig
+from southwind_embedding_server.contracts import EmbeddingRequest, EmbeddingResponse
+from southwind_embedding_server.run_cipher import EmbeddingRunCipher
+from southwind_embedding_server.run_service import EmbeddingRunService, deployment_pin
+from southwind_embedding_server.run_store import EmbeddingRunStore, RunConflictError
+
+
+def config(path: str) -> EmbeddingConfig:
+    return EmbeddingConfig(
+        internal_token="internal",
+        artifact_url="http://server:9747/api/internal/ai/artifacts",
+        run_artifact_url="http://server:9747/api/internal/embeddings/runs",
+        adapter_url="http://adapter:9000",
+        adapter_token=None,
+        deployment_key="local",
+        deployment_alias="intranet-v1",
+        model="embedding-model",
+        version="2026-08",
+        dimensions=3,
+        normalized=True,
+        capabilities=("embedding.text",),
+        run_store_path=path,
+        run_encryption_secret="x" * 32,
+    )
+
+
+def request(text: str = "敏感文本") -> EmbeddingRequest:
+    return EmbeddingRequest.model_validate(
+        {
+            "kind": "embedding",
+            "operationKey": "analysis.embedding.text",
+            "items": [{"id": "one", "text": text}],
+            "options": {},
+            "inputModalities": ["text"],
+            "requiredCapabilities": ["embedding.text"],
+            "dataClassification": "sensitive",
+            "limits": {
+                "maxDurationSeconds": 30,
+                "maxInputBytes": 1024,
+                "maxOutputBytes": 1024,
+                "maxUnits": 10,
+            },
+            "providerEgress": {"mode": "forbidden"},
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_encrypts_invocation_and_emits_monotonic_terminal_events(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = str(tmp_path / "embedding.sqlite3")
+    adapter = EmbeddingAdapter(config(path))
+
+    run_ids: list[str | None] = []
+
+    async def embed(
+        _request: EmbeddingRequest, _run_id: str | None = None
+    ) -> EmbeddingResponse:
+        run_ids.append(_run_id)
+        return EmbeddingResponse.model_validate(
+            {
+                "batchId": "batch-1",
+                "items": [{"id": "one", "vector": [1, 0, 0], "inputSha256": "a" * 64}],
+                "metadata": {
+                    "deploymentAlias": "intranet-v1",
+                    "model": "embedding-model",
+                    "version": "2026-08",
+                    "dimensions": 3,
+                    "normalized": True,
+                },
+            }
+        )
+
+    monkeypatch.setattr(adapter, "embed", embed)
+    store = EmbeddingRunStore(path, EmbeddingRunCipher("x" * 32), 60)
+    service = EmbeddingRunService(adapter, store, 1)
+    started = await service.start(request(), "key-1", "embedding_started")
+    for _ in range(20):
+        if (await service.require(started.run_id)).terminal:
+            break
+        await asyncio.sleep(0)
+    events = await store.events_after(started.run_id, 0)
+    assert [event["sequence"] for event in events] == [1, 2]
+    assert [event["type"] for event in events] == ["run.started", "run.completed"]
+    assert run_ids == [started.run_id]
+    with sqlite3.connect(path) as database:
+        cipher = str(
+            database.execute("select invocation_cipher from embedding_runs").fetchone()[
+                0
+            ]
+        )
+    assert "敏感文本" not in cipher
+
+
+@pytest.mark.asyncio
+async def test_rejects_same_idempotency_key_with_changed_semantics(
+    tmp_path: Path,
+) -> None:
+    path = str(tmp_path / "embedding.sqlite3")
+    store = EmbeddingRunStore(path, EmbeddingRunCipher("x" * 32), 60)
+    first, _ = await store.create_or_get(
+        "run-1", request(), "key-1", "a" * 64, deployment_pin(config(path))
+    )
+    assert first.status == "accepted"
+    with pytest.raises(RunConflictError):
+        await store.create_or_get(
+            "run-2",
+            request("changed"),
+            "key-1",
+            "b" * 64,
+            deployment_pin(config(path)),
+        )
+
+
+@pytest.mark.asyncio
+async def test_recovers_accepted_run_after_sqlite_restart(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = str(tmp_path / "embedding.sqlite3")
+    first_store = EmbeddingRunStore(path, EmbeddingRunCipher("x" * 32), 60)
+    pending, _ = await first_store.create_or_get(
+        "embedding_recovered",
+        request(),
+        "recover-key",
+        "a" * 64,
+        deployment_pin(config(path)),
+    )
+    adapter = EmbeddingAdapter(config(path))
+    invoked: list[str | None] = []
+
+    async def embed(
+        _request: EmbeddingRequest, run_id: str | None = None
+    ) -> EmbeddingResponse:
+        invoked.append(run_id)
+        return response()
+
+    monkeypatch.setattr(adapter, "embed", embed)
+    restarted_store = EmbeddingRunStore(path, EmbeddingRunCipher("x" * 32), 60)
+    restarted = EmbeddingRunService(adapter, restarted_store, 1)
+    await restarted.recover()
+    for _ in range(20):
+        if (await restarted.require(pending.run_id)).terminal:
+            break
+        await asyncio.sleep(0)
+    assert invoked == [pending.run_id]
+    assert (await restarted.require(pending.run_id)).status == "completed"
+
+
+@pytest.mark.asyncio
+async def test_recovery_fails_closed_when_deployment_pin_drifts(tmp_path: Path) -> None:
+    path = str(tmp_path / "embedding.sqlite3")
+    initial = config(path)
+    store = EmbeddingRunStore(path, EmbeddingRunCipher("x" * 32), 60)
+    pending, _ = await store.create_or_get(
+        "embedding_drifted",
+        request(),
+        "drift-key",
+        "a" * 64,
+        deployment_pin(initial),
+    )
+    restarted = EmbeddingRunService(
+        EmbeddingAdapter(replace(initial, model="replacement-model")),
+        EmbeddingRunStore(path, EmbeddingRunCipher("x" * 32), 60),
+        1,
+    )
+    await restarted.recover()
+    for _ in range(20):
+        if (await restarted.require(pending.run_id)).terminal:
+            break
+        await asyncio.sleep(0)
+    events = await restarted.store.events_after(pending.run_id, 0)
+    assert events[-1]["type"] == "run.failed"
+    error = events[-1]["error"]
+    assert isinstance(error, dict)
+    assert error["code"] == "CAPABILITY_UNAVAILABLE"
+
+
+def response() -> EmbeddingResponse:
+    return EmbeddingResponse.model_validate(
+        {
+            "batchId": "batch-1",
+            "items": [{"id": "one", "vector": [1, 0, 0], "inputSha256": "a" * 64}],
+            "metadata": {
+                "deploymentAlias": "intranet-v1",
+                "model": "embedding-model",
+                "version": "2026-08",
+                "dimensions": 3,
+                "normalized": True,
+            },
+        }
+    )