create-windy 0.5.2 → 0.6.0

package/template/apps/speech-server/tests/test_service.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
 
 import asyncio
+from dataclasses import replace
+
+import pytest
 
 from southwind_speech_server.adapter import SpeechAdapter
 from southwind_speech_server.config import SpeechRuntimeConfig
 from southwind_speech_server.contracts import (
     ArtifactInput,
     JsonValue,
+    OutputArtifactLimits,
+    OutputArtifactSink,
     ProviderEgress,
     RuntimeLimits,
     StartSpeechRunRequest,
 )
-from southwind_speech_server.errors import SafeSpeechError
-from southwind_speech_server.output_validation import canonicalize_output
-from southwind_speech_server.service import SpeechRunService
+from southwind_speech_server.errors import SafeSpeechError, safe_speech_status
+from southwind_speech_server.service import SpeechRunService, validate_options
 from southwind_speech_server.store import RunConflictError, SpeechRunStore
 
 
@@ -24,14 +28,20 @@ class FakeAdapter(SpeechAdapter):
                 internal_token="internal",
                 store_path=":memory:",
                 artifact_url="http://server.internal/api/internal/ai/artifacts",
+                output_artifact_url="http://server.internal/api/internal/ai/output-artifacts",
                 adapter_url="http://127.0.0.1:9000",
                 adapter_token=None,
                 deployment_key=None,
+                deployment_identity=None,
+                release_digest=None,
+                offers_digest=None,
                 capabilities=("speech.transcribe.batch",),
             )
         )
 
-    async def execute(self, request: StartSpeechRunRequest) -> JsonValue:
+    async def execute(
+        self, request: StartSpeechRunRequest, output_grant: str | None = None
+    ) -> JsonValue:
         return {
             "language": "zh",
             "durationMs": 2500,
@@ -48,6 +58,64 @@ class FakeAdapter(SpeechAdapter):
         }
 
 
+class FailingOutputAdapter(FakeAdapter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.accepted: list[str | None] = []
+        self.aborted: list[str | None] = []
+
+    async def accept_output_grant(
+        self, request: StartSpeechRunRequest, output_grant: str | None
+    ) -> None:
+        assert request.output_artifact_sink is not None
+        self.accepted.append(output_grant)
+
+    async def execute(
+        self, request: StartSpeechRunRequest, output_grant: str | None = None
+    ) -> JsonValue:
+        raise SafeSpeechError("RUNTIME_UNAVAILABLE", "测试失败", True)
+
+    async def abort_open_output(
+        self, request: StartSpeechRunRequest, output_grant: str | None
+    ) -> None:
+        assert request.output_artifact_sink is not None
+        self.aborted.append(output_grant)
+
+
+class BlockingAdapter(FakeAdapter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.config = replace(self.config, max_concurrent_runs=1, max_queue_depth=1)
+        self.release = asyncio.Event()
+        self.active = 0
+        self.max_active = 0
+
+    async def execute(
+        self, request: StartSpeechRunRequest, output_grant: str | None = None
+    ) -> JsonValue:
+        self.active += 1
+        self.max_active = max(self.max_active, self.active)
+        try:
+            await self.release.wait()
+            return await super().execute(request, output_grant)
+        finally:
+            self.active -= 1
+
+
+class RetryingCleanupAdapter(FailingOutputAdapter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.cleanup_attempts = 0
+
+    async def abort_open_output(
+        self, request: StartSpeechRunRequest, output_grant: str | None
+    ) -> None:
+        self.cleanup_attempts += 1
+        if self.cleanup_attempts < 3:
+            raise SafeSpeechError("CAPABILITY_UNAVAILABLE", "cleanup", True)
+        await super().abort_open_output(request, output_grant)
+
+
 async def test_idempotent_run_emits_progress_and_result_artifact() -> None:
     store = SpeechRunStore(":memory:")
     service = SpeechRunService(FakeAdapter(), store)
@@ -86,44 +154,113 @@ async def test_same_key_with_changed_source_is_rejected() -> None:
         raise AssertionError("相同幂等键的语义漂移必须拒绝")
 
 
-def test_output_has_stable_segments_and_rejects_overrun() -> None:
-    output = canonicalize_output(
-        {
-            "language": "zh",
-            "segments": [
-                {
-                    "id": "provider-id",
-                    "text": "第一段",
-                    "startMs": 0,
-                    "endMs": 1000,
-                    "confidence": 0.9,
-                }
+async def test_concurrency_and_queue_limits_are_enforced() -> None:
+    adapter = BlockingAdapter()
+    service = SpeechRunService(adapter, SpeechRunStore(":memory:"))
+    await service.start(speech_request(), "capacity-1")
+    await service.start(speech_request(), "capacity-2")
+    with pytest.raises(SafeSpeechError, match="队列已满"):
+        await service.start(speech_request(), "capacity-3")
+
+    await asyncio.sleep(0)
+    adapter.release.set()
+    await asyncio.gather(*list(service.tasks.values()))
+
+    assert adapter.max_active == 1
+
+
+async def test_same_key_with_changed_v2_variant_is_rejected() -> None:
+    service = SpeechRunService(FakeAdapter(), SpeechRunStore(":memory:"))
+    request = speech_request()
+    await service.start(request, "speech-v2-conflict")
+    changed = request.model_copy(
+        update={
+            "contract_version": 2,
+            "variant": "translate",
+            "options": {"targetLanguage": "en", "timestamps": "word"},
+        }
+    )
+    try:
+        await service.start(changed, "speech-v2-conflict")
+    except RunConflictError:
+        pass
+    else:
+        raise AssertionError("同一幂等键不得跨 Speech variant 重放")
+
+
+async def test_normalize_uses_host_run_and_aborts_open_output_on_failure() -> None:
+    adapter = FailingOutputAdapter()
+    service = SpeechRunService(adapter, SpeechRunStore(":memory:"))
+    planned = f"speech_{'c' * 64}"
+    request = speech_request().model_copy(
+        update={
+            "run_id": planned,
+            "contract_version": 2,
+            "variant": "normalize",
+            "options": {},
+            "required_capabilities": [
+                "speech.normalize",
+                "speech.output-artifact.v1",
             ],
-        },
-        1000,
-        1,
+            "output_artifact_sink": output_sink(),
+        }
     )
-    assert isinstance(output, dict)
-    segments = output["segments"]
-    assert isinstance(segments, list)
-    assert isinstance(segments[0], dict)
-    assert segments[0]["id"] == "segment-000001"
 
+    created = await service.start(request, "speech-normalize", "output-grant")
+    replayed = await service.start(request, "speech-normalize", None)
+    await asyncio.gather(*service.tasks.values())
+
+    assert created.run_id == planned
+    assert replayed.run_id == planned
+    assert service.require(planned).status == "failed"
+    assert adapter.accepted == ["output-grant"]
+    assert adapter.aborted == ["output-grant"]
+
+
+async def test_failed_run_keeps_terminal_status_while_cleanup_retries() -> None:
+    adapter = RetryingCleanupAdapter()
+    service = SpeechRunService(adapter, SpeechRunStore(":memory:"))
+    request = normalize_request()
+
+    await service.start(request, "speech-cleanup-retry", "output-grant")
+    await asyncio.gather(*service.tasks.values())
+
+    assert request.run_id is not None
+    assert service.require(request.run_id).status == "failed"
+    assert adapter.cleanup_attempts == 3
+    assert adapter.aborted == ["output-grant"]
+
+
+def test_v2_contract_rejects_boolean_timestamps_and_requires_variant() -> None:
+    request = speech_request().model_copy(
+        update={
+            "contract_version": 2,
+            "variant": "translate",
+            "options": {"targetLanguage": "en", "timestamps": True},
+        }
+    )
     try:
-        canonicalize_output(
-            {
-                "segments": [
-                    {"text": "一", "startMs": 0, "endMs": 500},
-                    {"text": "二", "startMs": 500, "endMs": 1000},
-                ]
-            },
-            1000,
-            1,
-        )
+        validate_options(request)
     except SafeSpeechError as error:
-        assert error.code == "OUTPUT_VALIDATION_FAILED"
+        assert error.code == "INVALID_INPUT"
     else:
-        raise AssertionError("超过分段配额的输出必须拒绝")
+        raise AssertionError("boolean timestamps 必须拒绝")
+
+
+def test_retryable_runtime_unavailable_maps_to_503() -> None:
+    assert (
+        safe_speech_status(
+            SafeSpeechError("CAPABILITY_UNAVAILABLE", "unavailable", True)
+        )
+        == 503
+    )
+    assert (
+        safe_speech_status(
+            SafeSpeechError("CAPABILITY_UNAVAILABLE", "unavailable", False)
+        )
+        == 503
+    )
+    assert safe_speech_status(SafeSpeechError("INVALID_INPUT", "invalid", False)) == 400
 
 
 def speech_request() -> StartSpeechRunRequest:
@@ -152,3 +289,41 @@ def speech_request() -> StartSpeechRunRequest:
         ),
         provider_egress=ProviderEgress(mode="forbidden"),
     )
+
+
+def output_sink() -> OutputArtifactSink:
+    return OutputArtifactSink(
+        contract_version=1,
+        scope=f"outscope_{'a' * 32}",
+        output_kind="normalized-audio",
+        deployment_identity=(
+            "windy-deployment-v1_7db61d8e-e50d-4f8a-9f3f-9b7a1d932e01"
+        ),
+        release_digest=f"sha256:{'b' * 64}",
+        offers_digest=f"sha256:{'c' * 64}",
+        policy_digest="d" * 64,
+        grant_generation=1,
+        allowed_media_types=["audio/wav"],
+        expires_at="2026-08-06T12:02:00.000Z",
+        limits=OutputArtifactLimits(
+            max_artifact_bytes=4_096,
+            max_artifacts=1,
+            max_total_bytes=4_096,
+        ),
+    )
+
+
+def normalize_request() -> StartSpeechRunRequest:
+    return speech_request().model_copy(
+        update={
+            "run_id": f"speech_{'e' * 64}",
+            "contract_version": 2,
+            "variant": "normalize",
+            "options": {},
+            "required_capabilities": [
+                "speech.normalize",
+                "speech.output-artifact.v1",
+            ],
+            "output_artifact_sink": output_sink(),
+        }
+    )

package/template/apps/web/src/pages/system/components/OperationGpuMonitor.vue

@@ -79,7 +79,8 @@ function formatBytes(value: number | null) {
           :aria-label="`GPU ${device.index} ${metric.label}`"
           aria-valuemin="0"
           aria-valuemax="100"
-          :aria-valuenow="metric.value ?? 0"
+          :aria-valuenow="metric.value ?? undefined"
+          :aria-valuetext="metric.value === null ? '未知' : undefined"
           class="h-3 overflow-hidden rounded-full bg-muted"
         >
           <div

package/template/apps/web/src/pages/system/components/OperationGpuMonitor.webtest.ts

@@ -58,4 +58,33 @@ describe("GPU 监控面板", () => {
     expect(wrapper.text()).toContain("未检测到 GPU");
     expect(wrapper.text()).toContain("未检测到 nvidia-smi");
   });
+
+  test("未知指标保持无值语义而不是伪装成 0%", () => {
+    const wrapper = mount(OperationGpuMonitor, {
+      props: {
+        gpu: {
+          status: "available",
+          provider: "NVIDIA",
+          message: "设备不支持该指标。",
+          devices: [
+            {
+              index: 0,
+              uuid: "GPU-abc",
+              name: "NVIDIA GPU",
+              usagePercent: null,
+              memoryUsedBytes: null,
+              memoryTotalBytes: null,
+              memoryUsagePercent: null,
+              temperatureCelsius: null,
+              processes: [],
+            },
+          ],
+        },
+      },
+    });
+
+    const progress = wrapper.get('[aria-label="GPU 0 GPU 利用率"]');
+    expect(progress.attributes("aria-valuenow")).toBeUndefined();
+    expect(progress.attributes("aria-valuetext")).toBe("未知");
+  });
 });

package/template/apps/web/src/pages/system/components/OperationServiceMonitor.vue

@@ -120,7 +120,8 @@ function formatBytes(value?: number) {
             :aria-label="metric.label"
             aria-valuemin="0"
             aria-valuemax="100"
-            :aria-valuenow="metric.value ?? 0"
+            :aria-valuenow="metric.value ?? undefined"
+            :aria-valuetext="metric.value === null ? '采集中' : undefined"
             class="h-3 overflow-hidden rounded-full bg-muted"
           >
             <div

package/template/apps/web/src/pages/system/components/OperationServiceMonitor.webtest.ts

@@ -21,7 +21,7 @@ describe("服务监控面板", () => {
             status: "available",
             logicalCores: 16,
             hostUsagePercent: 42.5,
-            processUsagePercent: 3.25,
+            processUsagePercent: null,
             loadAverage1m: 2.1,
           },
         },
@@ -79,5 +79,8 @@ describe("服务监控面板", () => {
     expect(
       wrapper.get('[aria-label="宿主机 CPU"]').attributes("aria-valuenow"),
     ).toBe("42.5");
+    const processCpu = wrapper.get('[aria-label="Bun Server 进程 CPU"]');
+    expect(processCpu.attributes("aria-valuenow")).toBeUndefined();
+    expect(processCpu.attributes("aria-valuetext")).toBe("采集中");
   });
 });

package/template/docker-compose.yml

@@ -39,6 +39,7 @@ services:
       DATABASE_URL: postgresql://windy:${POSTGRES_PASSWORD}@postgres:5432/windy
       WINDY_BOOTSTRAP_ADMIN_PASSWORD: ${WINDY_BOOTSTRAP_ADMIN_PASSWORD:?请在 .env 中设置管理员初始密码}
       WINDY_AUDIT_QUEUE_FILE: /app/data/audit/recovery-queue.json
+      WINDY_STORAGE_ROOT: /app/data/storage
       WINDY_CONTAINERIZED: "1"
       BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD: "true"
       WINDY_SYSTEM_USAGE_PATHS: /app/data/audit
@@ -50,6 +51,9 @@ services:
       AI_ARTIFACT_URL: http://server:9747/api/internal/ai/artifacts
       AI_ARTIFACT_ENCRYPTION_SECRET: ${AI_ARTIFACT_ENCRYPTION_SECRET:-}
       DOCUMENT_SERVER_URL: ${DOCUMENT_SERVER_URL:-}
+      AI_OUTPUT_ARTIFACT_REFERENCE_SECRET: ${AI_OUTPUT_ARTIFACT_REFERENCE_SECRET:-}
+      DOCUMENT_OUTPUT_ARTIFACT_SINK_IDENTITY: ${DOCUMENT_OUTPUT_ARTIFACT_SINK_IDENTITY:-}
+      DOCUMENT_OUTPUT_ARTIFACT_SINK_RELEASE_DIGEST: ${DOCUMENT_OUTPUT_ARTIFACT_SINK_RELEASE_DIGEST:-}
       SPEECH_SERVER_URL: ${SPEECH_SERVER_URL:-}
       EMBEDDING_SERVER_URL: ${EMBEDDING_SERVER_URL:-}
       OPENSEARCH_URL: ${OPENSEARCH_URL:-}
@@ -62,6 +66,7 @@ services:
       - ./apps/server:/app/apps/server
       - ./packages:/app/packages
       - server-audit-data:/app/data/audit
+      - server-storage-data:/app/data/storage
       - tool-sandbox-ipc:/run/windy-tool-sandbox
     depends_on:
       migrate:
@@ -157,8 +162,17 @@ services:
       AI_PROVIDER_CONNECT_TIMEOUT_MS: ${AI_PROVIDER_CONNECT_TIMEOUT_MS:-5000}
       AI_PROVIDER_REQUEST_TIMEOUT_MS: ${AI_PROVIDER_REQUEST_TIMEOUT_MS:-60000}
       AI_PROVIDER_MAX_RESPONSE_BYTES: ${AI_PROVIDER_MAX_RESPONSE_BYTES:-2097152}
+      AI_PROVIDER_MAX_DURATION_SECONDS: ${AI_PROVIDER_MAX_DURATION_SECONDS:-300}
+      AI_PROVIDER_MAX_INPUT_BYTES: ${AI_PROVIDER_MAX_INPUT_BYTES:-67108864}
+      AI_PROVIDER_MAX_ARTIFACTS: ${AI_PROVIDER_MAX_ARTIFACTS:-16}
+      AI_PROVIDER_MAX_PIXELS_PER_ARTIFACT: ${AI_PROVIDER_MAX_PIXELS_PER_ARTIFACT:-100000000}
       AI_PROVIDER_CAPABILITIES: ${AI_PROVIDER_CAPABILITIES:-text-generation}
       AI_PROVIDER_INPUT_MODALITIES: ${AI_PROVIDER_INPUT_MODALITIES:-text}
+      AI_PROVIDER_DEPLOYMENT_IDENTITY: ${AI_PROVIDER_DEPLOYMENT_IDENTITY:-}
+      AI_PROVIDER_RELEASE_DIGEST: ${AI_PROVIDER_RELEASE_DIGEST:-}
+      AI_PROVIDER_READINESS_TTL_SECONDS: ${AI_PROVIDER_READINESS_TTL_SECONDS:-60}
+      AI_PROVIDER_MAX_CONCURRENT_RUNS: ${AI_PROVIDER_MAX_CONCURRENT_RUNS:-1}
+      AI_PROVIDER_MAX_QUEUE_DEPTH: ${AI_PROVIDER_MAX_QUEUE_DEPTH:-0}
     volumes:
       - agent-run-data:/app/data/agent
     depends_on:
@@ -176,9 +190,13 @@ services:
       DOCUMENT_SERVER_INTERNAL_TOKEN: ${AGENT_SERVER_INTERNAL_TOKEN:-}
       DOCUMENT_RUN_STORE_PATH: /app/data/document/runs.sqlite3
       DOCUMENT_ARTIFACT_URL: ${DOCUMENT_ARTIFACT_URL:-http://server:9747/api/internal/ai/artifacts}
+      DOCUMENT_OUTPUT_ARTIFACT_URL: ${DOCUMENT_OUTPUT_ARTIFACT_URL:-http://server:9747/api/internal/ai/output-artifacts}
       DOCUMENT_ADAPTER_URL: ${DOCUMENT_ADAPTER_URL:-}
       DOCUMENT_ADAPTER_TOKEN: ${DOCUMENT_ADAPTER_TOKEN:-}
       DOCUMENT_DEPLOYMENT_KEY: ${DOCUMENT_DEPLOYMENT_KEY:-}
+      DOCUMENT_DEPLOYMENT_IDENTITY: ${DOCUMENT_DEPLOYMENT_IDENTITY:-}
+      DOCUMENT_RELEASE_DIGEST: ${DOCUMENT_RELEASE_DIGEST:-}
+      DOCUMENT_OFFERS_DIGEST: ${DOCUMENT_OFFERS_DIGEST:-}
       DOCUMENT_ADAPTER_CAPABILITIES: ${DOCUMENT_ADAPTER_CAPABILITIES:-document.ocr,document.layout,document.table}
       DOCUMENT_MAX_UNITS: ${DOCUMENT_MAX_UNITS:-500}
     volumes:
@@ -196,12 +214,23 @@ services:
       SPEECH_SERVER_INTERNAL_TOKEN: ${AGENT_SERVER_INTERNAL_TOKEN:-}
       SPEECH_RUN_STORE_PATH: /app/data/speech/runs.sqlite3
       SPEECH_ARTIFACT_URL: ${SPEECH_ARTIFACT_URL:-http://server:9747/api/internal/ai/artifacts}
+      SPEECH_OUTPUT_ARTIFACT_URL: ${SPEECH_OUTPUT_ARTIFACT_URL:-http://server:9747/api/internal/ai/output-artifacts}
       SPEECH_ADAPTER_URL: ${SPEECH_ADAPTER_URL:-}
       SPEECH_ADAPTER_TOKEN: ${SPEECH_ADAPTER_TOKEN:-}
       SPEECH_DEPLOYMENT_KEY: ${SPEECH_DEPLOYMENT_KEY:-}
-      SPEECH_ADAPTER_CAPABILITIES: ${SPEECH_ADAPTER_CAPABILITIES:-speech.transcribe.batch,speech.normalize,speech.vad,speech.timestamps}
+      SPEECH_DEPLOYMENT_IDENTITY: ${SPEECH_DEPLOYMENT_IDENTITY:-}
+      SPEECH_RELEASE_DIGEST: ${SPEECH_RELEASE_DIGEST:-}
+      SPEECH_OFFERS_DIGEST: ${SPEECH_OFFERS_DIGEST:-}
+      SPEECH_ADAPTER_CAPABILITIES: ${SPEECH_ADAPTER_CAPABILITIES:-speech.transcribe.batch,speech.translate,speech.vad,speech.timestamps}
       SPEECH_MAX_UNITS: ${SPEECH_MAX_UNITS:-100000}
       SPEECH_MAX_MEDIA_DURATION_SECONDS: ${SPEECH_MAX_MEDIA_DURATION_SECONDS:-86400}
+      SPEECH_MAX_INPUT_ARTIFACT_BYTES: ${SPEECH_MAX_INPUT_ARTIFACT_BYTES:-2147483648}
+      SPEECH_MAX_INLINE_OUTPUT_BYTES: ${SPEECH_MAX_INLINE_OUTPUT_BYTES:-67108864}
+      SPEECH_MAX_OUTPUT_ARTIFACT_BYTES: ${SPEECH_MAX_OUTPUT_ARTIFACT_BYTES:-536870912}
+      SPEECH_MAX_CONCURRENT_RUNS: ${SPEECH_MAX_CONCURRENT_RUNS:-1}
+      SPEECH_MAX_QUEUE_DEPTH: ${SPEECH_MAX_QUEUE_DEPTH:-0}
+      SPEECH_READINESS_TIMEOUT_SECONDS: ${SPEECH_READINESS_TIMEOUT_SECONDS:-5}
+      SPEECH_READINESS_TTL_SECONDS: ${SPEECH_READINESS_TTL_SECONDS:-60}
     volumes:
       - speech-run-data:/app/data/speech
     depends_on:
@@ -216,6 +245,7 @@ services:
     environment:
       EMBEDDING_SERVER_INTERNAL_TOKEN: ${AGENT_SERVER_INTERNAL_TOKEN:-}
       EMBEDDING_ARTIFACT_URL: ${EMBEDDING_ARTIFACT_URL:-http://server:9747/api/internal/ai/artifacts}
+      EMBEDDING_RUN_ARTIFACT_URL: ${EMBEDDING_RUN_ARTIFACT_URL:-http://server:9747/api/internal/embeddings/runs}
       EMBEDDING_ADAPTER_URL: ${EMBEDDING_ADAPTER_URL:-}
       EMBEDDING_ADAPTER_TOKEN: ${EMBEDDING_ADAPTER_TOKEN:-}
       EMBEDDING_DEPLOYMENT_KEY: ${EMBEDDING_DEPLOYMENT_KEY:-}
@@ -226,6 +256,11 @@ services:
       EMBEDDING_NORMALIZED: ${EMBEDDING_NORMALIZED:-true}
       EMBEDDING_CAPABILITIES: ${EMBEDDING_CAPABILITIES:-embedding.text}
       EMBEDDING_MAX_UNITS: ${EMBEDDING_MAX_UNITS:-256}
+      EMBEDDING_RUN_ENCRYPTION_SECRET: ${EMBEDDING_RUN_ENCRYPTION_SECRET:-}
+      EMBEDDING_MAX_CONCURRENT_RUNS: ${EMBEDDING_MAX_CONCURRENT_RUNS:-1}
+      EMBEDDING_RUN_TERMINAL_TTL_SECONDS: ${EMBEDDING_RUN_TERMINAL_TTL_SECONDS:-604800}
+    volumes:
+      - embedding-run-data:/app/data/embedding
     depends_on:
       server:
         condition: service_started
@@ -267,4 +302,6 @@ volumes:
   tool-sandbox-ipc:
   document-run-data:
   speech-run-data:
+  embedding-run-data:
   opensearch-data:
+  server-storage-data: