create-windy 0.6.0 → 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

@@ -6,6 +6,7 @@ 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)
@@ -19,6 +20,11 @@ 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:
@@ -28,7 +34,10 @@ def config(path: str) -> EmbeddingConfig:
         run_artifact_url="http://server:9747/api/internal/embeddings/runs",
         adapter_url="http://adapter:9000",
         adapter_token=None,
-        deployment_key=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",
@@ -56,6 +65,12 @@ def request() -> dict[str, object]:
             "maxUnits": 10,
         },
         "providerEgress": {"mode": "forbidden"},
+        "readinessPin": {
+            "key": "embedding.primary",
+            "identity": IDENTITY,
+            "releaseDigest": DIGEST_A,
+            "offersDigest": DIGEST_B,
+        },
     }
 
 
@@ -78,7 +93,7 @@ def response() -> EmbeddingResponse:
 @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)
+    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
@@ -103,7 +118,9 @@ async def test_run_http_success_events_result_and_cancel(tmp_path: Path) -> None
         assert result.json()["output"]["batchId"] == "batch-1"
 
         waiting = Adapter(response(), block=True)
-        cancelled_app = create_app(config(str(tmp_path / "cancel.sqlite3")), waiting)
+        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()
@@ -122,6 +139,7 @@ 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(
@@ -143,6 +161,24 @@ async def test_run_http_exposes_safe_remote_failure_only(tmp_path: Path) -> None
         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,
@@ -171,6 +207,42 @@ class Adapter:
         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",
@@ -179,7 +251,7 @@ def headers(key: str = "read") -> dict[str, str]:
     }
 
 
-def client(app: object) -> httpx.AsyncClient:
+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

@@ -181,7 +181,9 @@ async def test_recovery_fails_closed_when_deployment_pin_drifts(tmp_path: Path)
         await asyncio.sleep(0)
     events = await restarted.store.events_after(pending.run_id, 0)
     assert events[-1]["type"] == "run.failed"
-    assert events[-1]["error"]["code"] == "CAPABILITY_UNAVAILABLE"
+    error = events[-1]["error"]
+    assert isinstance(error, dict)
+    assert error["code"] == "CAPABILITY_UNAVAILABLE"
 
 
 def response() -> EmbeddingResponse:

package/template/apps/server/src/agent/drizzle-screenshot-intake-repository.integration.test.ts

@@ -154,6 +154,7 @@ describePostgres("Screenshot Intake V2 真实 PostgreSQL 重启与 TTL", () => {
         plan.intakeToken,
         "evidence.image.inspect",
         screenshotDeployment,
+        declaration(bytes).contextDigest,
         context,
       );
       expect(first.artifact.value).toStartWith("v1.");
@@ -167,6 +168,7 @@ describePostgres("Screenshot Intake V2 真实 PostgreSQL 重启与 TTL", () => {
         plan.intakeToken,
         "evidence.image.inspect",
         screenshotDeployment,
+        declaration(bytes).contextDigest,
         context,
       );
       await recovered.bind("run-canonical");
@@ -177,6 +179,7 @@ describePostgres("Screenshot Intake V2 真实 PostgreSQL 重启与 TTL", () => {
         plan.intakeToken,
         "evidence.image.inspect",
         screenshotDeployment,
+        declaration(bytes).contextDigest,
         context,
       );
       await idempotent.bind("run-canonical");

package/template/apps/server/src/agent/run-facade.ts

@@ -200,7 +200,8 @@ export class AgentRunFacade {
       screenshot = await reserveScreenshotForRun(
         this.screenshots,
         screenshotIntakeToken,
-        operationKey,
+        operation.definition,
+        input,
         readinessPin,
         context,
         signal,

package/template/apps/server/src/agent/run-route-screenshot-context.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from "bun:test";
+import { parseStartRequest } from "./run-route-input.js";
+
+test("Run route 不接受客户端自报 Screenshot context 已验证", () => {
+  expect(() =>
+    parseStartRequest({
+      operationKey: "evidence.image.inspect",
+      input: { uiContext: { version: 1 } },
+      screenshotIntakeToken: "0198c47d-7d51-7000-8000-000000000001",
+      screenshotContextDigest: `sha256:${"a".repeat(64)}`,
+    }),
+  ).toThrow("请求格式无效");
+});

package/template/apps/server/src/agent/runtime-bootstrap.ts

@@ -263,6 +263,7 @@ export function registerAgentPlatformRuntime(input: {
         : new InMemoryEmbeddingRunBindingRepository(),
       internalToken,
     ),
+    aiReadiness,
   );
   registerEmbeddingRoutes(aiRouteApp, embeddingFacade);
   registerEmbeddingRunArtifactRoutes(
@@ -316,6 +317,7 @@ export function registerAgentPlatformRuntime(input: {
       speechFacade,
       speechRemote,
       embeddingFacade,
+      modules: input.modules,
     });
   const aiReadinessForModule = (
     moduleName: string,

package/template/apps/server/src/agent/screenshot-context-admission.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, test } from "bun:test";
+import type { ModuleManifest } from "@southwind-ai/modules";
+import { computeScreenshotContextDigestV1 } from "@southwind-ai/shared";
+import type { ModuleAiScreenshotIntakeProducerV2 } from "@southwind-ai/server-sdk";
+import { buildScopeContext } from "../data-access/context.js";
+import { createRequestGuardContext } from "../guards.js";
+import { createServerRuntime } from "../runtime.js";
+import { ScreenshotIntakeRuntimeV2 } from "./screenshot-intake-v2.js";
+import { reserveScreenshotForRun } from "./screenshot-run-binding.js";
+import {
+  screenshotDeployment,
+  screenshotVisionManifest,
+} from "./screenshot-intake-test-support.js";
+
+describe("Screenshot context Run admission", () => {
+  test("Host 重算 Manifest 指向的结构化上下文后才允许绑定", async () => {
+    const producer = fakeProducer();
+    const intake = runtime(producer);
+    const context = guard();
+    const uiContext = {
+      version: 1,
+      pageKey: "case.detail",
+      overlayStack: [{ title: "导入物证", kind: "dialog" }],
+    };
+    const plan = await intake.create(
+      declaration(await computeScreenshotContextDigestV1(uiContext)),
+      context,
+      signal(),
+    );
+    await intake.upload(plan.intakeToken, "image/png", png(), context);
+
+    const binding = await reserveScreenshotForRun(
+      intake,
+      plan.intakeToken,
+      operation(),
+      {
+        uiContext: {
+          overlayStack: [{ kind: "dialog", title: "导入物证" }],
+          pageKey: "case.detail",
+          version: 1,
+        },
+        uiContextDigest: `sha256:${"0".repeat(64)}`,
+      },
+      screenshotDeployment,
+      context,
+      signal(),
+    );
+    expect(binding?.artifact.value).toBe("opaque-screenshot-artifact");
+    await binding?.bind("run-canonical");
+    expect(producer.bound).toEqual(["run-canonical"]);
+    await intake.dispose();
+  });
+
+  test("上下文漂移或只提交自报 digest 会消费 token 并拒绝重放", async () => {
+    const producer = fakeProducer();
+    const intake = runtime(producer);
+    const context = guard();
+    const uiContext = { version: 1, pageKey: "case.detail" };
+    const first = await intake.create(
+      declaration(await computeScreenshotContextDigestV1(uiContext)),
+      context,
+      signal(),
+    );
+    await intake.upload(first.intakeToken, "image/png", png(), context);
+
+    await expect(
+      reserveScreenshotForRun(
+        intake,
+        first.intakeToken,
+        operation(),
+        { uiContext: { version: 1, pageKey: "case.list" } },
+        screenshotDeployment,
+        context,
+        signal(),
+      ),
+    ).rejects.toMatchObject({ code: "RUNTIME_UNAVAILABLE", status: 503 });
+    await expect(
+      reserveScreenshotForRun(
+        intake,
+        first.intakeToken,
+        operation(),
+        { uiContext },
+        screenshotDeployment,
+        context,
+        signal(),
+      ),
+    ).rejects.toMatchObject({ code: "RUNTIME_UNAVAILABLE", status: 503 });
+
+    const second = await intake.create(
+      declaration(await computeScreenshotContextDigestV1(uiContext)),
+      context,
+      signal(),
+    );
+    await intake.upload(second.intakeToken, "image/png", png(), context);
+    await expect(
+      reserveScreenshotForRun(
+        intake,
+        second.intakeToken,
+        operation(),
+        { uiContextDigest: await computeScreenshotContextDigestV1(uiContext) },
+        screenshotDeployment,
+        context,
+        signal(),
+      ),
+    ).rejects.toMatchObject({ code: "RUNTIME_UNAVAILABLE", status: 503 });
+    expect(producer.cancelled).toEqual(["producer-plan", "producer-plan"]);
+    await intake.dispose();
+  });
+
+  test("未 opt-in 的 0.6.0 Screenshot Operation 保留既有兼容边界", async () => {
+    const producer = fakeProducer();
+    const manifest = legacyManifest();
+    const intake = runtime(producer, manifest);
+    const context = guard();
+    const plan = await intake.create(
+      declaration(`sha256:${"f".repeat(64)}`),
+      context,
+      signal(),
+    );
+    await intake.upload(plan.intakeToken, "image/png", png(), context);
+    const binding = await reserveScreenshotForRun(
+      intake,
+      plan.intakeToken,
+      manifest.aiOperations![0]!,
+      { uiContext: { version: 1, pageKey: "legacy" } },
+      screenshotDeployment,
+      context,
+      signal(),
+    );
+    expect(binding?.artifact.value).toBe("opaque-screenshot-artifact");
+    await binding?.bind("run-legacy");
+    await intake.dispose();
+  });
+});
+
+function operation() {
+  const value = screenshotVisionManifest().aiOperations?.[0];
+  if (!value) throw new Error("测试 Manifest 缺少 Vision Operation");
+  return value;
+}
+
+function runtime(
+  producer: ReturnType<typeof fakeProducer>,
+  manifest = screenshotVisionManifest(),
+) {
+  return new ScreenshotIntakeRuntimeV2(
+    [manifest],
+    createServerRuntime(
+      {},
+      {
+        featureCatalog: manifest.features,
+        licenseResolver: { resolve: () => ({ status: "valid" }) },
+      },
+    ),
+    () => producer,
+    (reference) => reference,
+  );
+}
+
+function legacyManifest(): ModuleManifest {
+  const manifest = screenshotVisionManifest();
+  const definition = manifest.aiOperations?.[0];
+  if (!definition) throw new Error("测试 Manifest 缺少 Vision Operation");
+  return {
+    ...manifest,
+    aiOperations: [{ ...definition, screenshotContext: undefined }],
+  };
+}
+
+function fakeProducer(): ModuleAiScreenshotIntakeProducerV2 & {
+  bound: string[];
+  cancelled: string[];
+} {
+  return {
+    bound: [],
+    cancelled: [],
+    async create() {
+      return {
+        contractVersion: 2,
+        intakeToken: "producer-plan",
+        operationKey: "evidence.image.inspect",
+        expiresAt: new Date(Date.now() + 30_000).toISOString(),
+      };
+    },
+    async upload() {
+      return {
+        value: "opaque-screenshot-artifact",
+        mediaType: "image/png",
+        byteSize: png().byteLength,
+        sha256:
+          "b1ff9c8ea3a780bad09b346c423d2d0e46815926879b18e841d928376a946640",
+        expiresAt: new Date(Date.now() + 20_000).toISOString(),
+      };
+    },
+    async bind({ runId }) {
+      this.bound.push(runId);
+    },
+    async cancel({ intakeToken }) {
+      this.cancelled.push(intakeToken);
+    },
+  };
+}
+
+function declaration(contextDigest: `sha256:${string}`) {
+  return {
+    pageId: "case-detail",
+    contextDigest,
+    mediaType: "image/png" as const,
+    byteSize: png().byteLength,
+    pixels: 1,
+  };
+}
+
+function guard() {
+  return createRequestGuardContext(
+    new Request("http://windy.test/api/agent/screenshots"),
+    {
+      resolveActor: () => ({
+        id: "actor-1",
+        type: "user",
+        name: "测试用户",
+        roleCodes: ["user"],
+        permissionKeys: ["evidence.ai.execute"],
+        scopeContext: buildScopeContext("actor-1", undefined, [
+          {
+            id: "role-user",
+            code: "user",
+            dataScope: "self",
+            departmentIds: [],
+          },
+        ]),
+      }),
+      resolveLicense: () => ({ status: "valid" }),
+    },
+  );
+}
+
+function signal() {
+  return AbortSignal.timeout(1_000);
+}
+
+function png(): Uint8Array {
+  return Uint8Array.from(
+    Buffer.from(
+      "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC",
+      "base64",
+    ),
+  );
+}