create-windy 0.2.33 → 0.3.0

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

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import tempfile
+from collections.abc import Callable, Coroutine
+
+import httpx
+import pytest
+
+from southwind_agent_server.adk_adapter import AdkEngineAdapter
+from southwind_agent_server.config import (
+    EnvironmentSecretResolver,
+    OpenAiCompatibleConfig,
+    SecretRef,
+)
+from southwind_agent_server.contracts import (
+    ProviderDataPolicy,
+    ProviderEgress,
+    ProviderFieldPolicy,
+    ProviderInputFieldPolicy,
+    RuntimeLimits,
+    RuntimeToolDefinition,
+    ToolNetworkPolicy,
+)
+from southwind_agent_server.engine import (
+    EngineCompleted,
+    EngineRunRequest,
+    OutputDelta,
+    SafeEngineError,
+    ToolCompleted,
+    ToolRequested,
+    UsageReported,
+)
+from southwind_agent_server.openai_provider import OpenAiCompatibleProvider
+from southwind_agent_server.provider_audit import ProviderAuditStore
+from southwind_agent_server.provider_governance import ProviderRequestGovernance
+from southwind_agent_server.tool_host import ToolHostClient
+
+
+async def test_adk_runner_maps_text_usage_and_terminal() -> None:
+    async def provider_handler(_request: httpx.Request) -> httpx.Response:
+        return sse_response(
+            [
+                {"choices": [{"delta": {"content": "你"}}]},
+                {
+                    "choices": [{"delta": {"content": "好"}}],
+                    "usage": {
+                        "prompt_tokens": 2,
+                        "completion_tokens": 2,
+                        "total_tokens": 4,
+                    },
+                },
+            ]
+        )
+
+    signals = [
+        signal async for signal in engine(provider_handler).execute(runtime_request())
+    ]
+
+    assert [signal.text for signal in signals if isinstance(signal, OutputDelta)] == [
+        "你",
+        "好",
+    ]
+    usage = [signal.usage for signal in signals if isinstance(signal, UsageReported)]
+    assert usage == [
+        {
+            "source": "provider-reported",
+            "inputTokens": 2,
+            "outputTokens": 2,
+            "totalTokens": 4,
+        }
+    ]
+    assert isinstance(signals[-1], EngineCompleted)
+    assert signals[-1].output == {"text": "你好"}
+
+
+async def test_adk_tool_events_execute_only_through_tool_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 tool_call_response("business.records.list")
+        return sse_response([{"choices": [{"delta": {"content": "完成"}}]}])
+
+    async def tool_handler(request: httpx.Request) -> httpx.Response:
+        tool_requests.append(json.loads(request.content))
+        return httpx.Response(200, json={"value": {"total": 1}})
+
+    signals = [
+        signal
+        async for signal in engine(provider_handler, tool_handler).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 == [
+        {
+            "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_adk_denies_unknown_tool_before_host_callback() -> None:
+    host_called = False
+
+    async def provider_handler(_request: httpx.Request) -> httpx.Response:
+        return tool_call_response("business.admin.delete")
+
+    async def tool_handler(_request: httpx.Request) -> httpx.Response:
+        nonlocal host_called
+        host_called = True
+        return httpx.Response(200, json={"value": None})
+
+    with pytest.raises(SafeEngineError) as captured:
+        async for _ in engine(provider_handler, tool_handler).execute(
+            runtime_request("business.records.list")
+        ):
+            pass
+
+    assert captured.value.code == "TOOL_DENIED"
+    assert host_called is False
+
+
+async def test_adk_governance_rejects_before_provider_network() -> None:
+    provider_called = False
+
+    async def provider_handler(_request: httpx.Request) -> httpx.Response:
+        nonlocal provider_called
+        provider_called = True
+        return sse_response([])
+
+    request = runtime_request()
+    request = EngineRunRequest(
+        **{
+            **request.__dict__,
+            "instructions": "password=server-secret-value",
+        }
+    )
+
+    with pytest.raises(SafeEngineError) as captured:
+        async for _ in engine(provider_handler).execute(request):
+            pass
+
+    assert captured.value.code == "FORBIDDEN"
+    assert provider_called is False
+
+
+async def test_adk_cancel_and_provider_error_map_to_safe_errors() -> None:
+    started = asyncio.Event()
+
+    async def slow_provider(_request: httpx.Request) -> httpx.Response:
+        started.set()
+        await asyncio.sleep(0.03)
+        return sse_response([{"choices": [{"delta": {"content": "late"}}]}])
+
+    adapter = engine(slow_provider)
+
+    async def consume() -> None:
+        async for _ in adapter.execute(runtime_request()):
+            pass
+
+    task = asyncio.create_task(consume())
+    await started.wait()
+    await adapter.cancel("run_1")
+    with pytest.raises(SafeEngineError) as cancelled:
+        await task
+    assert cancelled.value.code == "RUN_CANCELLED"
+
+    async def failed_provider(_request: httpx.Request) -> httpx.Response:
+        return httpx.Response(500, text="provider-secret-body")
+
+    with pytest.raises(SafeEngineError) as failed:
+        async for _ in engine(failed_provider).execute(runtime_request()):
+            pass
+    assert failed.value.code == "PROVIDER_UNAVAILABLE"
+    assert "provider-secret-body" not in str(failed.value)
+
+
+def engine(
+    provider_handler: Callable[[httpx.Request], Coroutine[None, None, httpx.Response]],
+    tool_handler: Callable[[httpx.Request], Coroutine[None, None, httpx.Response]]
+    | None = None,
+) -> AdkEngineAdapter:
+    async def unused_tool(_request: httpx.Request) -> httpx.Response:
+        return httpx.Response(500, json={"error": "unused"})
+
+    provider = OpenAiCompatibleProvider(
+        OpenAiCompatibleConfig(
+            base_url="https://provider.test/v1",
+            model="qwen-compatible",
+            api_key_ref=SecretRef("env", "QWEN_API_KEY"),
+            https_host_allowlist=("provider.test",),
+        ),
+        EnvironmentSecretResolver({"QWEN_API_KEY": "server-secret"}),
+        transport=httpx.MockTransport(provider_handler),
+    )
+    audit_path = tempfile.NamedTemporaryFile(suffix=".sqlite3", delete=False).name
+    return AdkEngineAdapter(
+        provider,
+        ToolHostClient(
+            "internal-token",
+            transport=httpx.MockTransport(tool_handler or unused_tool),
+        ),
+        ProviderRequestGovernance(ProviderAuditStore(audit_path, retention_days=90)),
+    )
+
+
+def runtime_request(tool_key: str | None = None) -> EngineRunRequest:
+    tools = (
+        (
+            RuntimeToolDefinition(
+                key=tool_key,
+                label="查询记录",
+                description="查询当前数据范围内的记录。",
+            ),
+        )
+        if tool_key
+        else ()
+    )
+    return EngineRunRequest(
+        run_id="run_1",
+        operation_key="business.answer",
+        input={"question": "记录"},
+        instructions="回答业务问题。",
+        user_prompt="有多少记录？",
+        allowed_tools=tools,
+        limits=RuntimeLimits(max_duration_seconds=60, max_output_bytes=4096),
+        provider_egress=ProviderEgress(
+            mode="configured-endpoint",
+            deployment_key="ai.openai-compatible",
+        ),
+        provider_data_policy=ProviderDataPolicy(
+            input_fields=[
+                ProviderInputFieldPolicy(
+                    json_pointer="/question",
+                    classification="internal",
+                    dlp_action="redact",
+                )
+            ],
+            envelope_fields=[
+                ProviderFieldPolicy(
+                    field=field,
+                    classification="internal",
+                    dlp_action="reject" if field == "instructions" else "redact",
+                )
+                for field in (
+                    "instructions",
+                    "user-prompt",
+                    "tool-definitions",
+                    "provider-output",
+                    "tool-results",
+                )
+            ],
+        ),
+        tool_network_policy=ToolNetworkPolicy(mode="forbidden"),
+        execution_grant="grant_1",
+        tool_host_url="http://server:9747",
+    )
+
+
+def tool_call_response(name: str) -> httpx.Response:
+    return sse_response(
+        [
+            {
+                "choices": [
+                    {
+                        "delta": {
+                            "tool_calls": [
+                                {
+                                    "index": 0,
+                                    "id": "call_1",
+                                    "function": {
+                                        "name": name,
+                                        "arguments": '{"page":2}',
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        ]
+    )
+
+
+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,
+        content=body.encode(),
+        headers={"content-type": "text/event-stream"},
+    )

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

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from google.adk.models.base_llm import BaseLlm
+
+from adk_web_agents.safe_debug.agent import root_agent
+
+
+def test_adk_web_agent_has_no_business_tools_or_provider_model() -> None:
+    assert root_agent.name == "safe_debug"
+    assert root_agent.tools == []
+    assert isinstance(root_agent.model, BaseLlm)
+    assert root_agent.model.model == "windy-safe-debug"

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

@@ -9,7 +9,7 @@ import httpx
 import pytest
 from fastapi import FastAPI
 
-from southwind_agent_server.app import create_app
+from southwind_agent_server.app import create_app, provider_governance_snapshot
 from southwind_agent_server.deterministic import DeterministicEngineAdapter
 
 
@@ -233,3 +233,18 @@ async def test_liveness_does_not_claim_provider_readiness(
     assert live.json() == {"status": "live"}
     assert ready.status_code == 503
     assert ready.json()["code"] == "RUNTIME_UNAVAILABLE"
+
+
+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_openai_provider.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import json
+import sqlite3
+import tempfile
 
 import httpx
 import pytest
@@ -11,7 +13,10 @@ from southwind_agent_server.config import (
     SecretRef,
 )
 from southwind_agent_server.contracts import (
+    ProviderDataPolicy,
     ProviderEgress,
+    ProviderFieldPolicy,
+    ProviderInputFieldPolicy,
     RuntimeLimits,
     RuntimeToolDefinition,
     ToolNetworkPolicy,
@@ -24,6 +29,8 @@ from southwind_agent_server.engine import (
 )
 from southwind_agent_server.openai_engine import OpenAiCompatibleEngineAdapter
 from southwind_agent_server.openai_provider import OpenAiCompatibleProvider
+from southwind_agent_server.provider_audit import ProviderAuditStore
+from southwind_agent_server.provider_governance import ProviderRequestGovernance
 from southwind_agent_server.tool_host import ToolHostClient
 
 
@@ -76,11 +83,13 @@ async def test_provider_error_never_leaks_body_or_secret() -> None:
 
 async def test_engine_executes_only_allowed_tool_through_host() -> None:
     provider_calls = 0
+    provider_body_bytes: list[int] = []
     tool_requests: list[dict[str, object]] = []
 
     async def provider_handler(request: httpx.Request) -> httpx.Response:
         nonlocal provider_calls
         provider_calls += 1
+        provider_body_bytes.append(len(request.content))
         if provider_calls == 1:
             return sse_response(
                 [
@@ -111,12 +120,14 @@ async def test_engine_executes_only_allowed_tool_through_host() -> None:
         tool_requests.append(json.loads(request.content))
         return httpx.Response(200, json={"value": {"total": 1}})
 
+    audit_path = tempfile.NamedTemporaryFile(suffix=".sqlite3", delete=False).name
     engine = OpenAiCompatibleEngineAdapter(
         create_provider(httpx.MockTransport(provider_handler)),
         ToolHostClient(
             "internal-token",
             transport=httpx.MockTransport(tool_handler),
         ),
+        governance(audit_path),
     )
     signals = [
         signal
@@ -132,6 +143,20 @@ async def test_engine_executes_only_allowed_tool_through_host() -> None:
         "arguments": {"page": 2},
     }
     assert signals[-1].output == {"text": "共有一条记录"}  # type: ignore[union-attr]
+    audits = (
+        sqlite3.connect(audit_path)
+        .execute(
+            """
+        select attempt, sent_bytes, decision
+        from provider_attempt_audit order by attempt
+        """
+        )
+        .fetchall()
+    )
+    assert audits == [
+        (1, provider_body_bytes[0], "allow"),
+        (2, provider_body_bytes[1], "allow"),
+    ]
 
 
 async def test_engine_denies_unknown_model_tool_before_host_callback() -> None:
@@ -172,6 +197,7 @@ async def test_engine_denies_unknown_model_tool_before_host_callback() -> None:
             "internal-token",
             transport=httpx.MockTransport(tool_handler),
         ),
+        governance(),
     )
     with pytest.raises(SafeEngineError) as captured:
         async for _signal in engine.execute(runtime_request("business.records.list")):
@@ -191,6 +217,7 @@ async def test_engine_denies_provider_before_network_without_explicit_egress() -
     engine = OpenAiCompatibleEngineAdapter(
         create_provider(httpx.MockTransport(provider_handler)),
         ToolHostClient("internal-token"),
+        governance(),
     )
     request = runtime_request("business.records.list")
     request = EngineRunRequest(
@@ -211,6 +238,7 @@ async def test_engine_denies_mismatched_provider_deployment() -> None:
     engine = OpenAiCompatibleEngineAdapter(
         create_provider(httpx.MockTransport(lambda _request: sse_response([]))),
         ToolHostClient("internal-token"),
+        governance(),
     )
     request = runtime_request("business.records.list")
     request = EngineRunRequest(
@@ -267,12 +295,63 @@ def runtime_request(tool_key: str) -> EngineRunRequest:
             mode="configured-endpoint",
             deployment_key="ai.openai-compatible",
         ),
+        provider_data_policy=provider_data_policy(),
         tool_network_policy=ToolNetworkPolicy(mode="forbidden"),
         execution_grant="grant_1",
         tool_host_url="http://server:9747",
     )
 
 
+def provider_data_policy() -> ProviderDataPolicy:
+    return ProviderDataPolicy(
+        input_fields=[
+            ProviderInputFieldPolicy(
+                json_pointer="/question",
+                classification="internal",
+                dlp_action="redact",
+            )
+        ],
+        envelope_fields=[
+            ProviderFieldPolicy(
+                field="instructions",
+                classification="internal",
+                dlp_action="reject",
+            ),
+            ProviderFieldPolicy(
+                field="user-prompt",
+                classification="internal",
+                dlp_action="redact",
+            ),
+            ProviderFieldPolicy(
+                field="tool-definitions",
+                classification="internal",
+                dlp_action="reject",
+            ),
+            ProviderFieldPolicy(
+                field="provider-output",
+                classification="internal",
+                dlp_action="redact",
+            ),
+            ProviderFieldPolicy(
+                field="tool-results",
+                classification="sensitive",
+                dlp_action="redact",
+            ),
+        ],
+    )
+
+
+def governance(path: str | None = None) -> ProviderRequestGovernance:
+    path = (
+        path
+        or tempfile.NamedTemporaryFile(
+            suffix=".sqlite3",
+            delete=False,
+        ).name
+    )
+    return ProviderRequestGovernance(ProviderAuditStore(path, retention_days=90))
+
+
 def sse_response(chunks: list[object]) -> httpx.Response:
     body = "".join(
         f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n" for chunk in chunks