create-windy 0.8.2 → 0.9.1

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

@@ -1,177 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-
-from southwind_agent_server.contracts import (
-    RunReportingContext,
-    StartRunRequest,
-)
-from southwind_agent_server.deterministic import DeterministicEngineAdapter
-from southwind_agent_server.report_store import (
-    InMemoryAgentRuntimeReportStore,
-)
-from southwind_agent_server.service import AgentRunService
-from southwind_agent_server.store import (
-    CanonicalEvent,
-    InMemoryRunStore,
-    RunRecord,
-)
-
-
-def request(text: str = "done") -> StartRunRequest:
-    return StartRunRequest(
-        operation_key="test.echo",
-        input={"text": text},
-        trace_id="trace_1",
-        reporting=RunReportingContext(
-            actor_id="actor_1",
-            actor_type="user",
-        ),
-    )
-
-
-async def test_rewritten_event_terminal_drives_report_status() -> None:
-    canonical = EventLimitRunStore()
-    report = InMemoryAgentRuntimeReportStore()
-    service = AgentRunService(
-        DeterministicEngineAdapter(),
-        canonical,
-        report,
-    )
-
-    record = await service.start(request(), "event-limit")
-    final = await wait_for_terminal(service, record.run_id)
-    detail = await report.get_run(record.run_id)
-    await service.close()
-
-    assert final.status == "failed"
-    assert detail is not None
-    assert detail["status"] == "failed"
-    assert detail["safeErrorCode"] == "BUDGET_EXCEEDED"
-
-
-async def test_output_limit_terminal_drives_report_status() -> None:
-    canonical = OutputLimitRunStore()
-    report = InMemoryAgentRuntimeReportStore()
-    service = AgentRunService(
-        DeterministicEngineAdapter(),
-        canonical,
-        report,
-    )
-
-    record = await service.start(request("too large"), "output-limit")
-    final = await wait_for_terminal(service, record.run_id)
-    detail = await report.get_run(record.run_id)
-    await service.close()
-
-    assert final.status == "failed"
-    assert detail is not None
-    assert detail["status"] == "failed"
-    assert detail["safeErrorCode"] == "BUDGET_EXCEEDED"
-
-
-async def test_completion_wins_cancel_race_in_report() -> None:
-    canonical = CompleteWinsCancelRunStore()
-    report = InMemoryAgentRuntimeReportStore()
-    service = AgentRunService(
-        DeterministicEngineAdapter(),
-        canonical,
-        report,
-    )
-    invocation = request()
-    record = run_record(invocation, "race")
-    await canonical.create_or_get(record, invocation.model_dump(by_alias=True))
-    await report.ensure_run(record.run_id, invocation, 100.0)
-    await report.start_run(record.run_id, 101.0)
-
-    final = await service.cancel(record.run_id)
-    detail = await report.get_run(record.run_id)
-    await service.close()
-
-    assert final.status == "completed"
-    assert detail is not None
-    assert detail["status"] == "completed"
-
-
-async def wait_for_terminal(
-    service: AgentRunService,
-    run_id: str,
-) -> RunRecord:
-    async def poll() -> RunRecord:
-        while True:
-            record = await service.get(run_id)
-            if record.terminal:
-                return record
-            await asyncio.sleep(0)
-
-    return await asyncio.wait_for(poll(), 1)
-
-
-def run_record(invocation: StartRunRequest, suffix: str) -> RunRecord:
-    return RunRecord(
-        run_id=f"run_{suffix}",
-        operation_key=invocation.operation_key,
-        input=invocation.input,
-        idempotency_key=f"key_{suffix}",
-        fingerprint=f"fingerprint_{suffix}",
-        release=invocation.release.model_dump(by_alias=True),
-        trace_id=invocation.trace_id,
-    )
-
-
-def failure_event(run_id: str, sequence: int) -> CanonicalEvent:
-    return {
-        "type": "run.failed",
-        "runId": run_id,
-        "sequence": sequence,
-        "error": {
-            "code": "BUDGET_EXCEEDED",
-            "message": "Agent 存储超过安全上限",
-            "requestId": f"request_{sequence}",
-            "retryable": False,
-        },
-    }
-
-
-class EventLimitRunStore(InMemoryRunStore):
-    async def append(
-        self,
-        run_id: str,
-        event_type: str,
-        fields: dict[str, object] | None = None,
-    ) -> CanonicalEvent | None:
-        if event_type == "usage.reported":
-            record = await self.get(run_id)
-            assert record is not None
-            event = failure_event(run_id, len(record.events) + 1)
-            return await super().append(
-                run_id,
-                "run.failed",
-                {"error": event["error"]},
-            )
-        return await super().append(run_id, event_type, fields)
-
-
-class OutputLimitRunStore(InMemoryRunStore):
-    async def complete(self, run_id: str, output: object) -> None:
-        del output
-        record = await self.get(run_id)
-        assert record is not None
-        event = failure_event(run_id, len(record.events) + 1)
-        await super().append(
-            run_id,
-            "run.failed",
-            {"error": event["error"]},
-        )
-
-
-class CompleteWinsCancelRunStore(InMemoryRunStore):
-    async def append(
-        self,
-        run_id: str,
-        event_type: str,
-        fields: dict[str, object] | None = None,
-    ) -> CanonicalEvent | None:
-        if event_type == "run.cancelled":
-            await super().complete(run_id, {"winner": "complete"})
-        return await super().append(run_id, event_type, fields)

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

@@ -1,112 +0,0 @@
-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.engine_identity import DIRECT_ENGINE_ID
-from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
-from southwind_agent_server.store import InMemoryRunStore
-
-
-class LimitedEngine:
-    engine_id = DIRECT_ENGINE_ID
-    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_run_operational_logging.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import io
-import json
-import logging
-from collections.abc import Iterator
-from typing import TextIO, cast
-
-import httpx
-import pytest
-
-from southwind_agent_server.app import create_app
-from southwind_agent_server.deterministic import DeterministicEngineAdapter
-from southwind_agent_server.runtime_logging import AgentOperationalAttempt, logger
-from southwind_agent_server.service import AgentRunService
-from southwind_agent_server.store import RunRecord
-from southwind_agent_server.structured_logging import AgentStructuredLogHandler
-
-
-@pytest.fixture(autouse=True)
-def operational_log_level() -> Iterator[None]:
-    previous = logger.level
-    logger.setLevel(logging.INFO)
-    try:
-        yield
-    finally:
-        logger.setLevel(previous)
-
-
-@pytest.mark.parametrize("broken_sink", [False, True])
-async def test_real_run_completion_and_replay_with_operational_logs(
-    monkeypatch: pytest.MonkeyPatch,
-    broken_sink: bool,
-) -> None:
-    class Stream(io.StringIO):
-        def write(self, value: str) -> int:
-            written = super().write(value)
-            if broken_sink:
-                raise OSError("sink-secret")
-            return written
-
-    stream = Stream()
-    monkeypatch.setattr(logger, "handlers", [AgentStructuredLogHandler(stream)])
-    monkeypatch.setattr(logger, "propagate", False)
-    app = create_app(DeterministicEngineAdapter(), heartbeat_seconds=0.01)
-    service = cast(AgentRunService, app.state.run_service)
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app),
-        base_url="http://agent.test",
-    ) as client:
-
-        async def start() -> httpx.Response:
-            return await client.post(
-                "/api/agent/runs",
-                headers={"Idempotency-Key": "operational-replay"},
-                json={
-                    "operationKey": "test.echo",
-                    "input": {"text": "input-secret"},
-                    "traceId": "1" * 32,
-                },
-            )
-
-        response = await start()
-        assert response.status_code == 200
-        run_id = str(response.json()["runId"])
-        await asyncio.gather(*service._tasks)
-        replay = await start()
-        assert replay.json()["runId"] == run_id
-        events = await client.get(f"/api/agent/runs/{run_id}/events")
-        result = await client.get(f"/api/agent/runs/{run_id}/result")
-    assert result.json()["status"] == "completed"
-    assert result.json()["output"] == {"text": "input-secret"}
-    assert "run.failed" not in events.text
-    records = [json.loads(line) for line in stream.getvalue().splitlines()]
-    assert [record["event"] for record in records] == [
-        "agent.run.attempt.started",
-        "agent.run.attempt.completed",
-    ]
-    assert all(record["runId"] == run_id for record in records)
-    assert all(record["traceId"] == "1" * 32 for record in records)
-    assert records[-1]["outcome"] == "success"
-    assert records[-1]["durationMs"] >= 0
-    assert "input-secret" not in stream.getvalue()
-    assert "sink-secret" not in stream.getvalue()
-
-
-@pytest.mark.parametrize("status", ["failed", "cancelled", "running"])
-def test_attempt_terminal_mapping_and_duplicate_finish_are_safe(
-    monkeypatch: pytest.MonkeyPatch,
-    status: str,
-) -> None:
-    stream = io.StringIO()
-    monkeypatch.setattr(logger, "handlers", [AgentStructuredLogHandler(stream)])
-    monkeypatch.setattr(logger, "propagate", False)
-    record = RunRecord("run-1", "test.echo", {"secret": "input"}, "key", "digest")
-    attempt = AgentOperationalAttempt(record)
-    attempt.start()
-    attempt.start()
-    attempt.finish(status)
-    attempt.finish(status)
-    records = [json.loads(line) for line in stream.getvalue().splitlines()]
-    assert len(records) == 2
-    assert records[-1]["outcome"] == "failure"
-    expected = status if status in {"failed", "cancelled"} else "interrupted"
-    assert records[-1]["errorCode"] == f"AGENT_RUN_{expected.upper()}"
-    assert "secret" not in stream.getvalue()
-
-
-def test_unknown_info_message_does_not_expand_log_content() -> None:
-    stream = io.StringIO()
-    handler = AgentStructuredLogHandler(cast(TextIO, stream))
-    handler.emit(logging.makeLogRecord({"levelno": logging.INFO, "msg": "secret"}))
-    assert stream.getvalue() == ""

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

@@ -1,119 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import AsyncIterator
-from pathlib import Path
-from typing import cast
-
-import httpx
-import pytest
-
-from southwind_agent_server.app import create_app
-from southwind_agent_server.deterministic import DeterministicEngineAdapter
-from southwind_agent_server.runtime_compatibility import (
-    runtime_compatibility_offer,
-)
-
-TOKEN = "runtime-compatibility-test-token"
-
-
-@pytest.fixture
-async def client() -> AsyncIterator[httpx.AsyncClient]:
-    app = create_app(DeterministicEngineAdapter(), internal_token=TOKEN)
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app),
-        base_url="http://agent.test",
-    ) as value:
-        yield value
-
-
-async def test_compatibility_offer_is_authenticated_and_matches_public_fixture(
-    client: httpx.AsyncClient,
-) -> None:
-    denied = await client.get("/api/agent/runtime/compatibility")
-    allowed = await client.get(
-        "/api/agent/runtime/compatibility",
-        headers={"Authorization": f"Bearer {TOKEN}"},
-    )
-
-    assert denied.status_code == 403
-    assert allowed.status_code == 200
-    assert allowed.json() == public_fixture()
-
-
-async def test_start_accepts_legacy_without_pin(
-    client: httpx.AsyncClient,
-) -> None:
-    legacy = await start(client, "legacy-pin")
-
-    assert legacy.status_code == 200
-
-
-async def test_start_accepts_complete_matching_pin(
-    client: httpx.AsyncClient,
-) -> None:
-    offer = runtime_compatibility_offer("windy.direct.openai-compatible.v1")
-    pinned = await start(
-        client,
-        "current-pin",
-        {
-            "X-Windy-Agent-Runtime-Protocol": "1",
-            "X-Windy-Agent-Runtime-Offer-Digest": str(offer["offerDigest"]),
-        },
-    )
-
-    assert pinned.status_code == 200
-
-
-@pytest.mark.parametrize(
-    "headers",
-    [
-        {"X-Windy-Agent-Runtime-Protocol": "1"},
-        {"X-Windy-Agent-Runtime-Offer-Digest": "sha256:" + "0" * 64},
-        {
-            "X-Windy-Agent-Runtime-Protocol": "2",
-            "X-Windy-Agent-Runtime-Offer-Digest": "sha256:" + "0" * 64,
-        },
-        {
-            "X-Windy-Agent-Runtime-Protocol": "1",
-            "X-Windy-Agent-Runtime-Offer-Digest": "sha256:" + "0" * 64,
-        },
-    ],
-)
-async def test_start_rejects_partial_or_incompatible_pin_before_admission(
-    client: httpx.AsyncClient,
-    headers: dict[str, str],
-) -> None:
-    response = await start(client, "rejected-pin", headers)
-
-    assert response.status_code == 409
-    assert response.json() == {
-        "code": "RUNTIME_UNAVAILABLE",
-        "message": "Agent Runtime compatibility pin 不匹配",
-        "requestId": response.json()["requestId"],
-        "retryable": False,
-    }
-
-
-async def start(
-    client: httpx.AsyncClient,
-    key: str,
-    headers: dict[str, str] | None = None,
-) -> httpx.Response:
-    return await client.post(
-        "/api/agent/runs",
-        headers={
-            "Authorization": f"Bearer {TOKEN}",
-            "Idempotency-Key": key,
-            **(headers or {}),
-        },
-        json={"operationKey": "test.echo", "input": {"text": key}},
-    )
-
-
-def public_fixture() -> dict[str, object]:
-    path = (
-        Path(__file__).parents[3]
-        / "packages/server-sdk/contracts/agent-runtime-compatibility/v1/offer.json"
-    )
-    return cast(dict[str, object], json.loads(path.read_text(encoding="utf8")))

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

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, patch
-
-from pytest import MonkeyPatch
-
-from southwind_agent_server.openai_engine import OpenAiCompatibleEngineAdapter
-from southwind_agent_server.runtime_factory import default_engine
-from southwind_agent_server.unavailable_engine import UnavailableEngineAdapter
-
-
-async def test_default_direct_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, OpenAiCompatibleEngineAdapter)
-    assert engine.engine_id == "windy.direct.openai-compatible.v1"
-    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"
-
-
-async def test_missing_provider_uses_explicit_unavailable_engine(
-    monkeypatch: MonkeyPatch,
-) -> None:
-    for key in ("QWEN_API_URL", "QWEN_MODEL"):
-        monkeypatch.delenv(key, raising=False)
-
-    engine = default_engine()
-
-    assert isinstance(engine, UnavailableEngineAdapter)
-    assert engine.engine_id == "windy.unavailable.v1"
-    assert (await engine.readiness())["configured"] is False