create-windy 0.5.2 → 0.6.1

package/template/apps/agent-server/tests/test_api.py

@@ -247,15 +247,28 @@ async def test_internal_token_protects_run_api() -> None:
     assert allowed.status_code == 200
 
 
-async def test_liveness_does_not_claim_provider_readiness(
+async def test_liveness_and_process_readiness_do_not_probe_provider(
     client: httpx.AsyncClient,
 ) -> None:
     live = await client.get("/health/live")
     ready = await client.get("/health/ready")
 
     assert live.json() == {"status": "live"}
-    assert ready.status_code == 503
-    assert ready.json()["code"] == "RUNTIME_UNAVAILABLE"
+    assert ready.status_code == 200
+    assert ready.json() == {"status": "ready"}
+    vlm = await client.get("/health/vlm-ready")
+    assert vlm.status_code == 503
+    assert vlm.json() == {
+        "schemaVersion": 1,
+        "status": "unavailable",
+        "configured": False,
+        "runtimeKind": "agent",
+        "observedAt": vlm.json()["observedAt"],
+        "downstreamProbe": {"status": "not-run", "reason": "NOT_CONFIGURED"},
+        "deployment": None,
+        "offers": [],
+        "unavailableReasons": [{"code": "RUNTIME_NOT_CONFIGURED", "retryable": False}],
+    }
 
 
 def test_provider_governance_health_filters_content_identifiers() -> None:

package/template/apps/agent-server/tests/test_openai_provider.py

@@ -24,10 +24,20 @@ from tests.openai_provider_test_support import (
 )
 
 
-async def test_provider_stream_and_health_use_bounded_safe_protocol() -> None:
+async def test_provider_stream_and_vision_probe_use_bounded_safe_protocol() -> None:
     async def handler(request: httpx.Request) -> httpx.Response:
-        if request.url.path.endswith("/models"):
-            return httpx.Response(200, json={"data": []})
+        assert request.url.path.endswith("/chat/completions")
+        body = json.loads(request.content)
+        if body["messages"][0]["content"] != "你好":
+            assert body["messages"][0]["content"][1]["type"] == "image_url"
+            return sse_response(
+                [
+                    {
+                        "model": "qwen-compatible",
+                        "choices": [{"delta": {"content": '{"color":"red"}'}}],
+                    }
+                ]
+            )
         return sse_response(
             [
                 {"choices": [{"delta": {"content": "你"}}]},
@@ -43,7 +53,14 @@ async def test_provider_stream_and_health_use_bounded_safe_protocol() -> None:
         )
 
     provider = create_provider(httpx.MockTransport(handler))
-    await provider.health()
+    provider.config = provider.config.__class__(
+        **{
+            **provider.config.__dict__,
+            "capabilities": ("text-generation", "vision"),
+            "input_modalities": ("text", "image"),
+        }
+    )
+    await provider.probe_vision()
     turn = await provider.complete_turn(
         [{"role": "user", "content": "你好"}],
         (),

package/template/apps/agent-server/tests/test_postgres_store.py

@@ -31,6 +31,7 @@ async def test_multi_replica_replay_recovery_and_immutable_release() -> None:
             {"input": {"secret": f"sensitive-{suffix}"}},
         )
         repeated, repeated_is_new = await second.create_or_get(record)
+        by_idempotency = await second.get_by_idempotency(record.idempotency_key)
         await first.append(record.run_id, "run.started")
         await first.append(record.run_id, "output.delta", {"text": "one"})
         replayed, terminal = await second.events_after(record.run_id, 1, 0)
@@ -56,6 +57,8 @@ async def test_multi_replica_replay_recovery_and_immutable_release() -> None:
 
         assert is_new is True
         assert created.run_id == repeated.run_id
+        assert by_idempotency is not None
+        assert by_idempotency.run_id == created.run_id
         assert repeated_is_new is False
         assert [event["sequence"] for event in replayed] == [2]
         assert terminal is False

package/template/apps/agent-server/tests/test_run_capacity.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+
+import httpx
+
+from southwind_agent_server.app import create_app
+from southwind_agent_server.engine import (
+    EngineCompleted,
+    EngineRunRequest,
+    EngineSignal,
+)
+from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
+from southwind_agent_server.store import InMemoryRunStore
+
+
+class LimitedEngine:
+    max_concurrent_runs = 1
+    max_queue_depth = 1
+
+    def __init__(self) -> None:
+        self.started: asyncio.Queue[str] = asyncio.Queue()
+        self.releases: dict[str, asyncio.Event] = {}
+        self.active = 0
+        self.max_active = 0
+
+    @property
+    def capabilities(self) -> tuple[str, ...]:
+        return ("text-generation",)
+
+    @property
+    def input_modalities(self) -> tuple[str, ...]:
+        return ("text",)
+
+    def supports(self, operation_key: str) -> bool:
+        return operation_key == "test.capacity"
+
+    async def execute(self, request: EngineRunRequest) -> AsyncIterator[EngineSignal]:
+        release = self.releases.setdefault(request.run_id, asyncio.Event())
+        self.active += 1
+        self.max_active = max(self.max_active, self.active)
+        await self.started.put(request.run_id)
+        try:
+            await release.wait()
+            yield EngineCompleted(request.input)
+        finally:
+            self.active -= 1
+
+    async def cancel(self, run_id: str) -> None:
+        self.releases.setdefault(run_id, asyncio.Event()).set()
+
+
+async def test_vlm_capacity_enforces_concurrency_queue_and_idempotency() -> None:
+    engine = LimitedEngine()
+    application = create_app(
+        engine,
+        store=InMemoryRunStore(),
+        report_store=InMemoryAgentRuntimeReportStore(),
+    )
+    try:
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=application),
+            base_url="http://agent.test",
+        ) as client:
+            first = await start(client, "capacity-1", "first")
+            first_id = str(first.json()["runId"])
+            assert await asyncio.wait_for(engine.started.get(), 1) == first_id
+
+            second = await start(client, "capacity-2", "second")
+            second_id = str(second.json()["runId"])
+            same = await start(client, "capacity-2", "second")
+            assert same.json()["runId"] == second_id
+
+            conflict = await start(client, "capacity-2", "changed")
+            assert conflict.status_code == 409
+            assert conflict.json()["code"] == "RUN_CONFLICT"
+
+            rejected = await start(client, "capacity-3", "third")
+            assert rejected.status_code == 503
+            assert rejected.json()["code"] == "RUNTIME_UNAVAILABLE"
+            assert rejected.json()["message"] == "VLM Runtime 容量已满"
+            assert rejected.json()["retryable"] is True
+            assert str(rejected.json()["requestId"]).startswith("request_")
+            assert engine.active == 1
+
+            engine.releases[first_id].set()
+            assert await asyncio.wait_for(engine.started.get(), 1) == second_id
+            assert engine.max_active == 1
+            engine.releases[second_id].set()
+            await terminal(client, second_id)
+    finally:
+        await application.state.run_service.close()
+
+
+async def start(client: httpx.AsyncClient, key: str, value: str) -> httpx.Response:
+    return await client.post(
+        "/api/agent/runs",
+        headers={"Idempotency-Key": key},
+        json={"operationKey": "test.capacity", "input": {"text": value}},
+    )
+
+
+async def terminal(client: httpx.AsyncClient, run_id: str) -> None:
+    for _ in range(100):
+        response = await client.get(f"/api/agent/runs/{run_id}")
+        if response.json()["status"] == "completed":
+            return
+        await asyncio.sleep(0.01)
+    raise AssertionError("Agent Run 未在容量释放后完成")

package/template/apps/agent-server/tests/test_runtime_factory_readiness.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+from pytest import MonkeyPatch
+
+from southwind_agent_server.adk_adapter import AdkEngineAdapter
+from southwind_agent_server.runtime_factory import default_engine
+
+
+async def test_default_adk_engine_exposes_vlm_readiness(
+    monkeypatch: MonkeyPatch,
+) -> None:
+    values = {
+        "QWEN_API_URL": "http://vlm.internal/v1",
+        "QWEN_MODEL": "vision-model",
+        "AGENT_SERVER_INTERNAL_TOKEN": "internal-token",
+        "AI_PROVIDER_AUDIT_STORE_PATH": ".data/provider-audit.sqlite3",
+        "AI_PROVIDER_CAPABILITIES": "text-generation,vision",
+        "AI_PROVIDER_INPUT_MODALITIES": "text,image",
+        "AI_PROVIDER_DEPLOYMENT_IDENTITY": (
+            "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04"
+        ),
+        "AI_PROVIDER_RELEASE_DIGEST": "sha256:" + "d" * 64,
+    }
+    for key, value in values.items():
+        monkeypatch.setenv(key, value)
+    engine = default_engine()
+    assert isinstance(engine, AdkEngineAdapter)
+    provider = engine._provider
+    assert provider is not None
+    with patch.object(provider, "probe_vision", AsyncMock()) as probe:
+        snapshot = await engine.readiness()
+
+    probe.assert_awaited_once()
+    assert snapshot["status"] == "ready"
+    assert snapshot["runtimeKind"] == "agent"

package/template/apps/agent-server/tests/test_sqlite_store.py

@@ -31,10 +31,13 @@ async def test_terminal_run_and_cursor_survive_store_rebuild(
 
     restored = SqliteRunStore(path, TEST_CIPHER)
     current = await restored.get("run_1")
+    by_idempotency = await restored.get_by_idempotency("key_1")
     events, terminal = await restored.events_after("run_1", 1, 0.01)
     await restored.close()
 
     assert current is not None
+    assert by_idempotency is not None
+    assert by_idempotency.run_id == current.run_id
     assert current.status == "completed"
     assert current.output == {"text": "你好"}
     assert [event["sequence"] for event in events] == [2, 3]

package/template/apps/agent-server/tests/test_vision_readiness_enforcement.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import pytest
+
+from southwind_agent_server.contracts import StartRunRequest
+from southwind_agent_server.engine import SafeEngineError
+from southwind_agent_server.fingerprint import request_fingerprint
+from southwind_agent_server.vision_requirement import require_vision_readiness
+
+
+def vision_request(**values: object) -> StartRunRequest:
+    base: dict[str, object] = {
+        "operation_key": "evidence.image.inspect",
+        "input": None,
+        "input_modalities": ["text", "image"],
+        "required_capabilities": ["text-generation", "vision"],
+    }
+    return StartRunRequest(**{**base, **values})  # type: ignore[arg-type]
+
+
+class ReadyEngine:
+    async def readiness(self) -> dict[str, object]:
+        deployment = {
+            "key": "ai.openai-compatible",
+            "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
+            "releaseDigest": "sha256:" + "d" * 64,
+            "offersDigest": "sha256:" + "a" * 64,
+        }
+        return {
+            "status": "ready",
+            "deployment": deployment,
+            "downstreamProbe": {
+                "status": "passed",
+                **{
+                    "deploymentIdentity": deployment["identity"],
+                    "releaseDigest": deployment["releaseDigest"],
+                    "offersDigest": deployment["offersDigest"],
+                },
+            },
+        }
+
+
+async def test_vision_requires_pin_and_rejects_deployment_drift() -> None:
+    with pytest.raises(SafeEngineError, match="VLM Runtime"):
+        await require_vision_readiness(ReadyEngine(), vision_request())
+
+    pin = {
+        "key": "ai.openai-compatible",
+        "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
+        "releaseDigest": "sha256:" + "d" * 64,
+        "offersDigest": "sha256:" + "a" * 64,
+    }
+    await require_vision_readiness(ReadyEngine(), vision_request(readiness_pin=pin))
+    drifted = vision_request(
+        readiness_pin={**pin, "offersDigest": "sha256:" + "b" * 64}
+    )
+    with pytest.raises(SafeEngineError, match="VLM Runtime"):
+        await require_vision_readiness(ReadyEngine(), drifted)
+
+
+def test_readiness_pin_changes_idempotency_fingerprint() -> None:
+    pin = {
+        "key": "ai.openai-compatible",
+        "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
+        "releaseDigest": "sha256:" + "d" * 64,
+        "offersDigest": "sha256:" + "a" * 64,
+    }
+    first = request_fingerprint(vision_request(readiness_pin=pin))
+    second = request_fingerprint(
+        vision_request(readiness_pin={**pin, "offersDigest": "sha256:" + "b" * 64})
+    )
+    assert first != second

package/template/apps/agent-server/tests/test_vlm_readiness.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from base64 import b64decode
+from datetime import UTC, datetime
+from io import BytesIO
+
+from PIL import Image
+
+from southwind_agent_server.config import OpenAiCompatibleConfig
+from southwind_agent_server.engine import SafeEngineError
+from southwind_agent_server.vision_probe import _PROBE_IMAGE
+from southwind_agent_server.vlm_readiness import VlmReadinessProbe
+
+
+class ProbeProvider:
+    def __init__(self, error: SafeEngineError | None = None) -> None:
+        self.calls = 0
+        self.error = error
+
+    async def probe_vision(self) -> None:
+        self.calls += 1
+        if self.error:
+            raise self.error
+
+
+def test_synthetic_probe_image_is_a_decodable_red_pixel() -> None:
+    encoded = _PROBE_IMAGE.removeprefix("data:image/png;base64,")
+    with Image.open(BytesIO(b64decode(encoded))) as image:
+        image.load()
+        assert image.size == (1, 1)
+        assert image.convert("RGB").getpixel((0, 0)) == (255, 0, 0)
+
+
+def config(**values: object) -> OpenAiCompatibleConfig:
+    base: dict[str, object] = {
+        "base_url": "http://vlm.internal/v1",
+        "model": "vlm",
+        "api_key_ref": None,
+        "capabilities": ("text-generation", "vision"),
+        "input_modalities": ("text", "image"),
+        "readiness_deployment_identity": (
+            "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04"
+        ),
+        "readiness_release_digest": "sha256:" + "d" * 64,
+    }
+    return OpenAiCompatibleConfig(**{**base, **values})  # type: ignore[arg-type]
+
+
+async def test_vlm_readiness_requires_synthetic_image_inference() -> None:
+    provider = ProbeProvider()
+    now = datetime(2026, 8, 6, tzinfo=UTC)
+    snapshot = await VlmReadinessProbe(
+        config(), provider, wall_clock=lambda: now
+    ).inspect()
+
+    assert provider.calls == 1
+    assert snapshot["status"] == "ready"
+    assert snapshot["runtimeKind"] == "agent"
+    assert snapshot["offers"] == [
+        {
+            "variant": "vision",
+            "capabilities": ["text-generation", "vision"],
+            "inputModalities": ["text", "image"],
+            "outputModalities": ["text"],
+            "limits": {
+                "maxDurationSeconds": 300,
+                "maxInputBytes": 67_108_864,
+                "maxOutputBytes": 2 * 1024 * 1024,
+                "maxArtifacts": 16,
+                "maxPixelsPerArtifact": 100_000_000,
+                "maxConcurrentRuns": 1,
+                "maxQueueDepth": 0,
+            },
+        }
+    ]
+    assert snapshot["deployment"] == {
+        "key": "ai.openai-compatible",
+        "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
+        "releaseDigest": "sha256:" + "d" * 64,
+        "offersDigest": "sha256:"
+        "7beb2eeb442fd68c90d94b9469db732acdc51222e152ae0be3ae7be00d2459b2",
+    }
+
+
+async def test_vlm_readiness_does_not_claim_unconfigured_or_failed_vision() -> None:
+    unconfigured = ProbeProvider()
+    no_vision = await VlmReadinessProbe(
+        config(capabilities=("text-generation",)), unconfigured
+    ).inspect()
+    assert unconfigured.calls == 0
+    assert no_vision["status"] == "unavailable"
+    assert no_vision["configured"] is False
+
+    unavailable = await VlmReadinessProbe(
+        config(),
+        ProbeProvider(SafeEngineError("PROVIDER_UNAVAILABLE", "safe", retryable=True)),
+        wall_clock=lambda: datetime(2026, 8, 6, tzinfo=UTC),
+    ).inspect()
+    assert unavailable["status"] == "unavailable"
+    assert unavailable["downstreamProbe"] == {
+        "status": "failed",
+        "checkedAt": unavailable["observedAt"],
+        "latencyMs": 0,
+        "failureCode": "RESOURCE_UNAVAILABLE",
+        "retryable": True,
+    }