create-windy 0.8.3 → 0.10.0

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

@@ -1,305 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-from collections.abc import AsyncIterator
-from typing import cast
-
-import httpx
-import pytest
-from fastapi import FastAPI
-
-from southwind_agent_server.app import create_app
-from southwind_agent_server.deterministic import DeterministicEngineAdapter
-from southwind_agent_server.http_helpers import provider_governance_snapshot
-
-
-@pytest.fixture
-def app() -> FastAPI:
-    return create_app(DeterministicEngineAdapter(), heartbeat_seconds=0.01)
-
-
-@pytest.fixture
-async def client(app: FastAPI) -> AsyncIterator[httpx.AsyncClient]:
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app),
-        base_url="http://agent.test",
-    ) as value:
-        yield value
-
-
-async def start(
-    client: httpx.AsyncClient,
-    operation: str,
-    input_value: object,
-    key: str,
-) -> dict[str, object]:
-    response = await client.post(
-        "/api/agent/runs",
-        headers={"Idempotency-Key": key},
-        json={"operationKey": operation, "input": input_value},
-    )
-    assert response.status_code == 200
-    return cast(dict[str, object], response.json())
-
-
-def events(response: httpx.Response) -> list[dict[str, object]]:
-    result: list[dict[str, object]] = []
-    for frame in response.text.split("\n\n"):
-        data = next(
-            (
-                line.removeprefix("data: ")
-                for line in frame.splitlines()
-                if line.startswith("data: ")
-            ),
-            None,
-        )
-        if data is not None:
-            result.append(json.loads(data))
-    return result
-
-
-async def wait_for_terminal(
-    client: httpx.AsyncClient,
-    run_id: str,
-) -> list[dict[str, object]]:
-    response = await client.get(f"/api/agent/runs/{run_id}/events")
-    assert response.status_code == 200
-    return events(response)
-
-
-async def test_deterministic_result_and_canonical_sequence(
-    client: httpx.AsyncClient,
-) -> None:
-    created = await start(client, "test.echo", {"text": "你好"}, "echo-1")
-    run_id = str(created["runId"])
-    emitted = await wait_for_terminal(client, run_id)
-
-    assert [event["sequence"] for event in emitted] == [1, 2, 3, 4, 5]
-    assert [event["type"] for event in emitted] == [
-        "run.started",
-        "input.prepared",
-        "output.delta",
-        "usage.reported",
-        "run.completed",
-    ]
-    assert emitted[1] == {
-        "type": "input.prepared",
-        "runId": run_id,
-        "sequence": 2,
-        "artifactCount": 0,
-        "inputModalities": ["text"],
-    }
-    result = await client.get(f"/api/agent/runs/{run_id}/result")
-    assert result.json() == {
-        "runId": run_id,
-        "status": "completed",
-        "output": {"text": "你好"},
-    }
-
-
-async def test_replay_supports_header_and_after(client: httpx.AsyncClient) -> None:
-    created = await start(client, "test.echo", {"text": "replay"}, "replay-1")
-    run_id = str(created["runId"])
-    await wait_for_terminal(client, run_id)
-
-    from_header = await client.get(
-        f"/api/agent/runs/{run_id}/events",
-        headers={"Last-Event-ID": "2"},
-    )
-    from_query = await client.get(f"/api/agent/runs/{run_id}/events?after=3")
-    assert [(event["sequence"], event["type"]) for event in events(from_header)] == [
-        (3, "output.delta"),
-        (4, "usage.reported"),
-        (5, "run.completed"),
-    ]
-    assert [(event["sequence"], event["type"]) for event in events(from_query)] == [
-        (4, "usage.reported"),
-        (5, "run.completed"),
-    ]
-
-
-async def test_status_exposes_only_canonical_terminal_event(
-    client: httpx.AsyncClient,
-) -> None:
-    created = await start(client, "test.echo", {"text": "status"}, "status-1")
-    run_id = str(created["runId"])
-    emitted = await wait_for_terminal(client, run_id)
-    terminal_event = emitted[-1]
-    assert terminal_event == {
-        "type": "run.completed",
-        "runId": run_id,
-        "sequence": 5,
-    }
-
-    response = await client.get(f"/api/agent/runs/{run_id}")
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "runId": run_id,
-        "status": "completed",
-        "lastSequence": 5,
-        "terminalEvent": terminal_event,
-    }
-
-
-async def test_idempotency_reuses_or_conflicts(client: httpx.AsyncClient) -> None:
-    first = await start(client, "test.echo", {"text": "same"}, "same-key")
-    second = await start(client, "test.echo", {"text": "same"}, "same-key")
-    assert second["runId"] == first["runId"]
-
-    conflict = await client.post(
-        "/api/agent/runs",
-        headers={"Idempotency-Key": "same-key"},
-        json={"operationKey": "test.echo", "input": {"text": "different"}},
-    )
-    assert conflict.status_code == 409
-    assert conflict.json()["code"] == "RUN_CONFLICT"
-
-
-async def test_cancel_emits_one_terminal_and_heartbeat(
-    client: httpx.AsyncClient,
-) -> None:
-    created = await start(client, "test.wait", None, "cancel-1")
-    run_id = str(created["runId"])
-    stream = asyncio.create_task(client.get(f"/api/agent/runs/{run_id}/events"))
-    await asyncio.sleep(0.03)
-    cancelled = await client.post(
-        f"/api/agent/runs/{run_id}/cancel",
-        json={"reason": "user request"},
-    )
-    response = await stream
-    emitted = events(response)
-
-    assert cancelled.json()["status"] == "cancelled"
-    assert ": heartbeat" in response.text
-    assert [event["type"] for event in emitted].count("run.cancelled") == 1
-    assert emitted[-1]["type"] == "run.cancelled"
-    result = await client.get(f"/api/agent/runs/{run_id}/result")
-    assert result.status_code == 409
-    assert result.json()["code"] == "RUN_CANCELLED"
-
-
-async def test_failure_never_leaks_upstream_exception(
-    client: httpx.AsyncClient,
-) -> None:
-    created = await start(client, "test.fail", None, "fail-1")
-    run_id = str(created["runId"])
-    emitted = await wait_for_terminal(client, run_id)
-    terminal = emitted[-1]
-
-    assert terminal["type"] == "run.failed"
-    serialized = json.dumps(terminal, ensure_ascii=False)
-    assert "upstream-secret-body" not in serialized
-    error = cast(dict[str, object], terminal["error"])
-    assert error["code"] == "RUNTIME_UNAVAILABLE"
-    result = await client.get(f"/api/agent/runs/{run_id}/result")
-    assert "upstream-secret-body" not in result.text
-
-
-async def test_request_validation_uses_canonical_safe_error(
-    client: httpx.AsyncClient,
-) -> None:
-    response = await client.post(
-        "/api/agent/runs",
-        json={"operationKey": "", "input": None},
-    )
-
-    assert response.status_code == 400
-    assert response.json()["code"] == "INVALID_INPUT"
-    assert "detail" not in response.json()
-
-
-@pytest.mark.parametrize(
-    "network_fields",
-    [
-        {"providerEgress": {"mode": "configured-endpoint"}},
-        {"providerEgress": {"mode": "arbitrary-url"}},
-        {"toolNetworkPolicy": {"mode": "allowed"}},
-        {"providerUrl": "https://attacker.invalid/v1"},
-    ],
-)
-async def test_network_policy_dto_is_strict_and_fail_closed(
-    client: httpx.AsyncClient,
-    network_fields: dict[str, object],
-) -> None:
-    response = await client.post(
-        "/api/agent/runs",
-        headers={"Idempotency-Key": "network-policy"},
-        json={
-            "operationKey": "test.echo",
-            "input": None,
-            **network_fields,
-        },
-    )
-
-    assert response.status_code == 400
-    assert response.json()["code"] == "INVALID_INPUT"
-    assert "attacker.invalid" not in response.text
-
-
-async def test_internal_token_protects_run_api() -> None:
-    protected = create_app(
-        DeterministicEngineAdapter(),
-        internal_token="internal-secret",
-    )
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=protected),
-        base_url="http://agent.test",
-    ) as client:
-        denied = await client.post(
-            "/api/agent/runs",
-            headers={"Idempotency-Key": "protected-1"},
-            json={"operationKey": "test.echo", "input": None},
-        )
-        allowed = await client.post(
-            "/api/agent/runs",
-            headers={
-                "Idempotency-Key": "protected-1",
-                "Authorization": "Bearer internal-secret",
-            },
-            json={"operationKey": "test.echo", "input": None},
-        )
-
-    assert denied.status_code == 403
-    assert denied.json()["code"] == "FORBIDDEN"
-    assert allowed.status_code == 200
-
-
-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 == 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:
-    snapshot = provider_governance_snapshot(
-        {
-            "status": "healthy",
-            "retainedRecords": 3,
-            "runId": "run_secret",
-            "prompt": "do-not-expose",
-        }
-    )
-    assert snapshot["status"] == "healthy"
-    assert snapshot["retainedRecords"] == 3
-    assert "runId" not in snapshot
-    assert "prompt" not in snapshot

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

@@ -1,110 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from io import BytesIO
-
-import httpx
-import pytest
-from PIL import Image
-
-from southwind_agent_server.artifact_input import ArtifactLoader
-from southwind_agent_server.contracts import RuntimeArtifact, RuntimeLimits
-from southwind_agent_server.engine import SafeEngineError
-
-
-async def test_loader_uses_fixed_endpoint_and_sanitizes_image() -> None:
-    source = png(4, 3)
-    digest = hashlib.sha256(source).hexdigest()
-
-    async def respond(request: httpx.Request) -> httpx.Response:
-        assert str(request.url) == "http://server.internal/api/internal/ai/artifacts"
-        assert request.headers["x-ai-artifact-ref"] == "opaque-ref"
-        assert request.headers["authorization"] == "Bearer internal"
-        return httpx.Response(
-            200,
-            content=source,
-            headers={"content-type": "image/png"},
-        )
-
-    prepared = await ArtifactLoader(
-        "http://server.internal/api/internal/ai/artifacts",
-        "internal",
-        transport=httpx.MockTransport(respond),
-    ).prepare(
-        [
-            RuntimeArtifact(
-                value="opaque-ref",
-                media_type="image/png",
-                byte_size=len(source),
-                sha256=digest,
-            )
-        ],
-        ["text", "image"],
-        RuntimeLimits(
-            max_input_bytes=4096,
-            max_output_bytes=4096,
-            max_artifacts=1,
-            max_pixels_per_artifact=12,
-        ),
-    )
-
-    assert len(prepared) == 1
-    assert prepared[0].media_type == "image/png"
-    assert prepared[0].data_url.startswith("data:image/png;base64,")
-
-
-async def test_loader_rejects_pixel_budget_and_integrity_drift() -> None:
-    source = png(4, 3)
-
-    async def respond(_request: httpx.Request) -> httpx.Response:
-        return httpx.Response(
-            200,
-            content=source,
-            headers={"content-type": "image/png"},
-        )
-
-    loader = ArtifactLoader(
-        "http://server.internal/api/internal/ai/artifacts",
-        "internal",
-        transport=httpx.MockTransport(respond),
-    )
-    artifact = RuntimeArtifact(
-        value="opaque-ref",
-        media_type="image/png",
-        byte_size=len(source),
-        sha256=hashlib.sha256(source).hexdigest(),
-    )
-    with pytest.raises(SafeEngineError) as pixels:
-        await loader.prepare(
-            [artifact],
-            ["text", "image"],
-            RuntimeLimits(
-                max_input_bytes=4096,
-                max_output_bytes=4096,
-                max_artifacts=1,
-                max_pixels_per_artifact=11,
-            ),
-        )
-    assert pixels.value.code == "BUDGET_EXCEEDED"
-
-    with pytest.raises(SafeEngineError) as integrity:
-        await loader.prepare(
-            [artifact.model_copy(update={"sha256": "a" * 64})],
-            ["text", "image"],
-            RuntimeLimits(
-                max_input_bytes=4096,
-                max_output_bytes=4096,
-                max_artifacts=1,
-                max_pixels_per_artifact=12,
-            ),
-        )
-    assert integrity.value.code == "INVALID_INPUT"
-
-
-def png(width: int, height: int) -> bytes:
-    target = BytesIO()
-    Image.new("RGB", (width, height), color=(10, 20, 30)).save(
-        target,
-        format="PNG",
-    )
-    return target.getvalue()

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

@@ -1,230 +0,0 @@
-from __future__ import annotations
-
-import json
-import tempfile
-from collections.abc import AsyncIterator
-
-import httpx
-from fastapi import FastAPI
-
-from southwind_agent_server.app import create_app
-from southwind_agent_server.client_completion_contracts import (
-    ClientCompletionRequest,
-)
-from southwind_agent_server.client_completion_runtime import ClientCompletionRuntime
-from southwind_agent_server.openai_engine import OpenAiCompatibleEngineAdapter
-from southwind_agent_server.provider_audit import ProviderAuditStore
-from southwind_agent_server.provider_governance import ProviderRequestGovernance
-from southwind_agent_server.tool_host import ToolHostClient
-from tests.openai_provider_test_support import (
-    create_provider,
-    provider_data_policy,
-    sse_response,
-)
-
-
-def request_body(**patch: object) -> dict[str, object]:
-    value: dict[str, object] = {
-        "clientRunId": "carun_1",
-        "operationKey": "business.answer",
-        "deploymentKey": "ai.openai-compatible",
-        "modelAlias": "windy-client-agent-v1",
-        "attempt": 1,
-        "messages": [{"role": "user", "content": "查询记录"}],
-        "tools": [
-            {
-                "type": "function",
-                "function": {
-                    "name": "read_page",
-                    "description": "读取页面",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {"selector": {"type": "string"}},
-                        "required": ["selector"],
-                    },
-                },
-            },
-            {
-                "type": "function",
-                "function": {
-                    "name": "AgentOutput",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {"answer": {"type": "string"}},
-                        "required": ["answer"],
-                    },
-                },
-            },
-        ],
-        "toolChoice": {
-            "type": "function",
-            "function": {"name": "AgentOutput"},
-        },
-        "parallelToolCalls": False,
-        "providerDataPolicy": provider_data_policy().model_dump(by_alias=True),
-        "maxResponseBytes": 65_536,
-    }
-    value.update(patch)
-    return value
-
-
-async def test_internal_client_completion_fixes_provider_and_streams_tools() -> None:
-    observed: dict[str, object] = {}
-
-    async def provider_handler(request: httpx.Request) -> httpx.Response:
-        observed.update(json.loads(request.content))
-        assert request.headers["authorization"] == "Bearer server-secret"
-        return sse_response(
-            [
-                {
-                    "id": "chunk_1",
-                    "model": "physical-model-must-not-leak",
-                    "choices": [
-                        {
-                            "delta": {
-                                "tool_calls": [
-                                    {
-                                        "index": 0,
-                                        "id": "call_1",
-                                        "function": {
-                                            "name": "read_page",
-                                            "arguments": '{"selector":"main"}',
-                                        },
-                                    }
-                                ]
-                            }
-                        }
-                    ],
-                }
-            ]
-        )
-
-    app = configured_app(httpx.MockTransport(provider_handler))
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app),
-        base_url="http://agent.test",
-    ) as client:
-        health = await client.get(
-            "/api/internal/client-agent/health",
-            headers={"authorization": "Bearer internal-token"},
-        )
-        forbidden = await client.post(
-            "/api/internal/client-agent/chat/completions",
-            json=request_body(),
-        )
-        response = await client.post(
-            "/api/internal/client-agent/chat/completions",
-            headers={"authorization": "Bearer internal-token"},
-            json=request_body(),
-        )
-
-    assert health.json() == {"status": "ready"}
-    assert forbidden.status_code == 403
-    assert response.status_code == 200
-    assert observed["model"] == "qwen-compatible"
-    assert observed["stream"] is True
-    assert observed["tools"] == request_body()["tools"]
-    assert observed["tool_choice"] == request_body()["toolChoice"]
-    assert observed["parallel_tool_calls"] is False
-    assert "windy.meta" in response.text
-    assert "windy-client-agent-v1" in response.text
-    assert "physical-model-must-not-leak" not in response.text
-    assert "server-secret" not in response.text
-    assert '"name": "read_page"' in response.text
-
-
-async def test_internal_contract_rejects_model_url_and_redacts_dlp() -> None:
-    sent = ""
-
-    async def provider_handler(request: httpx.Request) -> httpx.Response:
-        nonlocal sent
-        sent = request.content.decode()
-        return sse_response([{"choices": [{"delta": {"content": "ok"}}]}])
-
-    app = configured_app(httpx.MockTransport(provider_handler))
-    headers = {"authorization": "Bearer internal-token"}
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app),
-        base_url="http://agent.test",
-    ) as client:
-        override = await client.post(
-            "/api/internal/client-agent/chat/completions",
-            headers=headers,
-            json=request_body(model="attacker-model", providerUrl="https://evil.test"),
-        )
-        redacted = await client.post(
-            "/api/internal/client-agent/chat/completions",
-            headers=headers,
-            json=request_body(
-                messages=[{"role": "user", "content": "联系 a@example.com"}],
-                tools=[],
-                toolChoice="none",
-            ),
-        )
-
-    assert override.status_code == 400
-    assert redacted.status_code == 200
-    assert "a@example.com" not in sent
-    assert "[REDACTED]" in sent
-
-
-async def test_closing_client_stream_aborts_provider_stream() -> None:
-    provider_closed = False
-
-    class SlowStream(httpx.AsyncByteStream):
-        async def __aiter__(self) -> AsyncIterator[bytes]:
-            yield b'data: {"choices":[{"delta":{"content":"first"}}]}\n\n'
-            yield b'data: {"choices":[{"delta":{"content":"late"}}]}\n\n'
-
-        async def aclose(self) -> None:
-            nonlocal provider_closed
-            provider_closed = True
-
-    async def handler(_request: httpx.Request) -> httpx.Response:
-        return httpx.Response(
-            200,
-            headers={"content-type": "text/event-stream"},
-            stream=SlowStream(),
-        )
-
-    runtime = configured_runtime(httpx.MockTransport(handler))
-    prepared = runtime.prepare(
-        ClientCompletionRequest.model_validate(
-            request_body(tools=[], toolChoice="none")
-        )
-    )
-    stream = runtime.stream(prepared)
-    first = await anext(stream)
-    assert first["choices"]
-    await stream.aclose()
-    assert provider_closed is True
-
-
-def configured_runtime(transport: httpx.AsyncBaseTransport) -> ClientCompletionRuntime:
-    audit = ProviderAuditStore(
-        tempfile.NamedTemporaryFile(suffix=".sqlite3", delete=False).name,
-        retention_days=90,
-    )
-    return ClientCompletionRuntime(
-        create_provider(transport),
-        ProviderRequestGovernance(audit),
-    )
-
-
-def configured_app(transport: httpx.AsyncBaseTransport) -> FastAPI:
-    provider = create_provider(transport)
-    governance = ProviderRequestGovernance(
-        ProviderAuditStore(
-            tempfile.NamedTemporaryFile(suffix=".sqlite3", delete=False).name,
-            retention_days=90,
-        )
-    )
-    engine = OpenAiCompatibleEngineAdapter(
-        provider,
-        ToolHostClient(
-            "internal-token",
-            transport=httpx.MockTransport(lambda _request: httpx.Response(500)),
-        ),
-        governance,
-    )
-    return create_app(engine, internal_token="internal-token")