create-windy 0.2.20 → 0.2.21

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

@@ -0,0 +1,207 @@
+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
+
+
+@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_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]
+    assert [event["type"] for event in emitted] == [
+        "run.started",
+        "output.delta",
+        "usage.reported",
+        "run.completed",
+    ]
+    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"] for event in events(from_header)] == [3, 4]
+    assert [event["sequence"] for event in events(from_query)] == [4]
+
+
+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()
+
+
+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_does_not_claim_provider_readiness(
+    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"

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

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import pytest
+
+from southwind_agent_server.config import (
+    EnvironmentSecretResolver,
+    OpenAiCompatibleConfig,
+    normalize_base_url,
+)
+
+
+def test_server_config_uses_secret_ref_and_normalizes_endpoint() -> None:
+    environment = {
+        "QWEN_API_URL": "https://example.com/compatible-mode/v1/",
+        "QWEN_MODEL": "qwen-plus",
+        "QWEN_API_KEY": "server-secret",
+    }
+    config = OpenAiCompatibleConfig.from_environment(environment)
+    assert config is not None
+    assert config.base_url == "https://example.com/compatible-mode/v1"
+    assert str(config.api_key_ref) == "[SecretRef]"
+    resolver = EnvironmentSecretResolver(environment)
+    assert config.api_key_ref is not None
+    assert resolver.resolve(config.api_key_ref) == "server-secret"
+
+
+@pytest.mark.parametrize(
+    "endpoint",
+    [
+        "http://public.example.com/v1",
+        "http://169.254.169.254/v1",
+        "https://user:pass@example.com/v1",
+        "https://example.com/v1?token=secret",
+    ],
+)
+def test_rejects_unsafe_endpoint(endpoint: str) -> None:
+    with pytest.raises(ValueError):
+        normalize_base_url(endpoint)
+
+
+def test_allows_private_http_endpoint() -> None:
+    assert normalize_base_url("http://qwen.internal:9000/v1/") == (
+        "http://qwen.internal:9000/v1"
+    )
+    assert normalize_base_url("http://10.20.30.40:8000/v1") == (
+        "http://10.20.30.40:8000/v1"
+    )
+
+
+def test_partial_deployment_fails_fast_without_leaking_value() -> None:
+    marker = "DO-NOT-LEAK"
+    with pytest.raises(ValueError) as captured:
+        OpenAiCompatibleConfig.from_environment(
+            {"QWEN_API_URL": marker, "QWEN_MODEL": ""}
+        )
+    assert marker not in str(captured.value)

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

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+
+from southwind_agent_server.config import (
+    EnvironmentSecretResolver,
+    OpenAiCompatibleConfig,
+    SecretRef,
+)
+from southwind_agent_server.contracts import RuntimeLimits, RuntimeToolDefinition
+from southwind_agent_server.engine import (
+    EngineRunRequest,
+    SafeEngineError,
+    ToolCompleted,
+    ToolRequested,
+)
+from southwind_agent_server.openai_engine import OpenAiCompatibleEngineAdapter
+from southwind_agent_server.openai_provider import OpenAiCompatibleProvider
+from southwind_agent_server.tool_host import ToolHostClient
+
+
+async def test_provider_stream_and_health_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": []})
+        return sse_response(
+            [
+                {"choices": [{"delta": {"content": "你"}}]},
+                {
+                    "choices": [{"delta": {"content": "好"}}],
+                    "usage": {
+                        "prompt_tokens": 2,
+                        "completion_tokens": 2,
+                        "total_tokens": 4,
+                    },
+                },
+            ]
+        )
+
+    provider = create_provider(httpx.MockTransport(handler))
+    await provider.health()
+    turn = await provider.complete_turn(
+        [{"role": "user", "content": "你好"}],
+        (),
+    )
+    assert turn.text_deltas == ["你", "好"]
+    assert turn.usage == {
+        "source": "provider-reported",
+        "inputTokens": 2,
+        "outputTokens": 2,
+        "totalTokens": 4,
+    }
+
+
+async def test_provider_error_never_leaks_body_or_secret() -> None:
+    marker = "upstream-secret-body"
+
+    async def handler(_request: httpx.Request) -> httpx.Response:
+        return httpx.Response(500, text=marker)
+
+    provider = create_provider(httpx.MockTransport(handler))
+    with pytest.raises(SafeEngineError) as captured:
+        await provider.complete_turn([], ())
+    assert captured.value.code == "PROVIDER_UNAVAILABLE"
+    assert marker not in str(captured.value)
+    assert "server-secret" not in str(captured.value)
+
+
+async def test_engine_executes_only_allowed_tool_through_host() -> None:
+    provider_calls = 0
+    tool_requests: list[dict[str, object]] = []
+
+    async def provider_handler(request: httpx.Request) -> httpx.Response:
+        nonlocal provider_calls
+        provider_calls += 1
+        if provider_calls == 1:
+            return sse_response(
+                [
+                    {
+                        "choices": [
+                            {
+                                "delta": {
+                                    "tool_calls": [
+                                        {
+                                            "index": 0,
+                                            "id": "call_1",
+                                            "function": {
+                                                "name": "business.records.list",
+                                                "arguments": '{"page":2}',
+                                            },
+                                        }
+                                    ]
+                                }
+                            }
+                        ]
+                    }
+                ]
+            )
+        return sse_response([{"choices": [{"delta": {"content": "共有一条记录"}}]}])
+
+    async def tool_handler(request: httpx.Request) -> httpx.Response:
+        assert request.headers["authorization"] == "Bearer internal-token"
+        tool_requests.append(json.loads(request.content))
+        return httpx.Response(200, json={"value": {"total": 1}})
+
+    engine = OpenAiCompatibleEngineAdapter(
+        create_provider(httpx.MockTransport(provider_handler)),
+        ToolHostClient(
+            "internal-token",
+            transport=httpx.MockTransport(tool_handler),
+        ),
+    )
+    signals = [
+        signal
+        async for signal in engine.execute(runtime_request("business.records.list"))
+    ]
+    assert any(isinstance(signal, ToolRequested) for signal in signals)
+    assert any(isinstance(signal, ToolCompleted) for signal in signals)
+    assert tool_requests[0] == {
+        "executionGrant": "grant_1",
+        "runId": "run_1",
+        "toolCallId": "call_1",
+        "toolKey": "business.records.list",
+        "arguments": {"page": 2},
+    }
+    assert signals[-1].output == {"text": "共有一条记录"}  # type: ignore[union-attr]
+
+
+async def test_engine_denies_unknown_model_tool_before_host_callback() -> None:
+    tool_called = False
+
+    async def provider_handler(_request: httpx.Request) -> httpx.Response:
+        return sse_response(
+            [
+                {
+                    "choices": [
+                        {
+                            "delta": {
+                                "tool_calls": [
+                                    {
+                                        "index": 0,
+                                        "id": "call_bad",
+                                        "function": {
+                                            "name": "business.admin.delete",
+                                            "arguments": "{}",
+                                        },
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ]
+        )
+
+    async def tool_handler(_request: httpx.Request) -> httpx.Response:
+        nonlocal tool_called
+        tool_called = True
+        return httpx.Response(200, json={"value": None})
+
+    engine = OpenAiCompatibleEngineAdapter(
+        create_provider(httpx.MockTransport(provider_handler)),
+        ToolHostClient(
+            "internal-token",
+            transport=httpx.MockTransport(tool_handler),
+        ),
+    )
+    with pytest.raises(SafeEngineError) as captured:
+        async for _signal in engine.execute(runtime_request("business.records.list")):
+            pass
+    assert captured.value.code == "TOOL_DENIED"
+    assert tool_called is False
+
+
+def create_provider(
+    transport: httpx.AsyncBaseTransport,
+) -> OpenAiCompatibleProvider:
+    environment = {"QWEN_API_KEY": "server-secret"}
+    return OpenAiCompatibleProvider(
+        OpenAiCompatibleConfig(
+            base_url="https://provider.test/v1",
+            model="qwen-compatible",
+            api_key_ref=SecretRef("env", "QWEN_API_KEY"),
+        ),
+        EnvironmentSecretResolver(environment),
+        transport=transport,
+    )
+
+
+def runtime_request(tool_key: str) -> EngineRunRequest:
+    return EngineRunRequest(
+        run_id="run_1",
+        operation_key="business.answer",
+        input={"question": "记录"},
+        instructions="回答业务问题。",
+        user_prompt="有多少记录？",
+        allowed_tools=(
+            RuntimeToolDefinition(
+                key=tool_key,
+                label="查询记录",
+                description="查询当前数据范围内的记录。",
+            ),
+        ),
+        limits=RuntimeLimits(
+            max_duration_seconds=60,
+            max_output_bytes=4096,
+        ),
+        execution_grant="grant_1",
+        tool_host_url="http://server:9747",
+    )
+
+
+def sse_response(chunks: list[object]) -> httpx.Response:
+    body = "".join(
+        f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n" for chunk in chunks
+    )
+    return httpx.Response(
+        200,
+        headers={"content-type": "text/event-stream"},
+        content=f"{body}data: [DONE]\n\n",
+    )

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

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import cast
+
+import pytest
+
+from southwind_agent_server.sqlite_store import (
+    RunStoreCapacityError,
+    SqliteRunStore,
+)
+from southwind_agent_server.store import RunRecord
+
+
+async def test_terminal_run_and_cursor_survive_store_rebuild(
+    tmp_path: Path,
+) -> None:
+    path = str(tmp_path / "runs.sqlite3")
+    first = SqliteRunStore(path)
+    record = fixture("run_1", "key_1")
+    await first.create_or_get(record)
+    await first.append("run_1", "run.started")
+    await first.append("run_1", "output.delta", {"text": "你好"})
+    await first.complete("run_1", {"text": "你好"})
+    first.close()
+
+    restored = SqliteRunStore(path)
+    current = await restored.get("run_1")
+    events, terminal = await restored.events_after("run_1", 1, 0.01)
+    restored.close()
+
+    assert current is not None
+    assert current.status == "completed"
+    assert current.output == {"text": "你好"}
+    assert [event["sequence"] for event in events] == [2, 3]
+    assert terminal is True
+
+
+async def test_incomplete_run_recovers_as_one_safe_terminal(
+    tmp_path: Path,
+) -> None:
+    path = str(tmp_path / "runs.sqlite3")
+    first = SqliteRunStore(path)
+    await first.create_or_get(fixture("run_2", "key_2"))
+    await first.append("run_2", "run.started")
+    first.close()
+
+    restored = SqliteRunStore(path)
+    current = await restored.get("run_2")
+    restored.close()
+
+    assert current is not None
+    assert current.status == "failed"
+    assert [event["type"] for event in current.events] == [
+        "run.started",
+        "run.failed",
+    ]
+    error = cast(dict[str, object], current.events[-1]["error"])
+    assert error["code"] == "RUNTIME_UNAVAILABLE"
+    assert error["retryable"] is True
+    assert "secret" not in str(current.events)
+
+
+async def test_event_and_run_capacity_are_bounded(tmp_path: Path) -> None:
+    store = SqliteRunStore(
+        str(tmp_path / "bounded.sqlite3"),
+        max_runs=1,
+        max_events_per_run=3,
+    )
+    await store.create_or_get(fixture("run_3", "key_3"))
+    await store.append("run_3", "run.started")
+    await store.append("run_3", "output.delta", {"text": "one"})
+    with pytest.raises(RunStoreCapacityError):
+        await store.append("run_3", "output.delta", {"text": "two"})
+
+    current = await store.get("run_3")
+    assert current is not None
+    assert current.status == "failed"
+    assert current.events[-1]["type"] == "run.failed"
+
+    with pytest.raises(RunStoreCapacityError):
+        await store.create_or_get(fixture("run_4", "key_4"))
+    store.close()
+
+
+def fixture(run_id: str, idempotency_key: str) -> RunRecord:
+    return RunRecord(
+        run_id=run_id,
+        operation_key="test.echo",
+        input={"text": "hello"},
+        idempotency_key=idempotency_key,
+        fingerprint=f"fingerprint-{run_id}",
+    )