create-windy 0.6.12 → 0.6.14

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

@@ -68,18 +68,28 @@ async def wait_for_terminal(
     return events(response)
 
 
-async def test_result_and_canonical_sequence(client: httpx.AsyncClient) -> None:
+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]
+    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,
@@ -98,8 +108,15 @@ async def test_replay_supports_header_and_after(client: httpx.AsyncClient) -> No
         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]
+    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(
@@ -107,7 +124,13 @@ async def test_status_exposes_only_canonical_terminal_event(
 ) -> None:
     created = await start(client, "test.echo", {"text": "status"}, "status-1")
     run_id = str(created["runId"])
-    await wait_for_terminal(client, run_id)
+    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}")
 
@@ -115,12 +138,8 @@ async def test_status_exposes_only_canonical_terminal_event(
     assert response.json() == {
         "runId": run_id,
         "status": "completed",
-        "lastSequence": 4,
-        "terminalEvent": {
-            "type": "run.completed",
-            "runId": run_id,
-            "sequence": 4,
-        },
+        "lastSequence": 5,
+        "terminalEvent": terminal_event,
     }
 
 

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

@@ -0,0 +1,230 @@
+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")

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

@@ -3,7 +3,6 @@ from __future__ import annotations
 import httpx
 import pytest
 
-from southwind_agent_server.adk_adapter import AdkEngineAdapter
 from southwind_agent_server.contracts import StartRunRequest
 from southwind_agent_server.engine import AgentEngineAdapter, SafeEngineError
 from southwind_agent_server.openai_engine import (
@@ -21,10 +20,7 @@ from tests.openai_provider_test_support import (
 )
 
 
-@pytest.mark.parametrize("adapter_kind", ["direct", "adk"])
-async def test_blocked_response_preserves_provider_usage(
-    adapter_kind: str,
-) -> None:
+async def test_blocked_response_preserves_provider_usage() -> None:
     async def provider_handler(_request: httpx.Request) -> httpx.Response:
         return sse_response(
             [
@@ -64,21 +60,12 @@ async def test_blocked_response_preserves_provider_usage(
     )
     await report.start_run("run_1", 101.0)
     provider = create_provider(httpx.MockTransport(provider_handler))
-    adapter: AgentEngineAdapter
-    if adapter_kind == "direct":
-        adapter = OpenAiCompatibleEngineAdapter(
-            provider,
-            ToolHostClient("internal-token"),
-            governance(),
-            report,
-        )
-    else:
-        adapter = AdkEngineAdapter(
-            provider,
-            ToolHostClient("internal-token"),
-            governance(),
-            report,
-        )
+    adapter: AgentEngineAdapter = OpenAiCompatibleEngineAdapter(
+        provider,
+        ToolHostClient("internal-token"),
+        governance(),
+        report,
+    )
 
     with pytest.raises(SafeEngineError) as captured:
         async for _ in adapter.execute(
@@ -102,8 +89,8 @@ async def test_blocked_response_preserves_provider_usage(
     assert attempt["model"] == "provider-model-v2"
 
 
-async def test_adk_cancel_after_response_preserves_provider_usage() -> None:
-    adapter: AdkEngineAdapter
+async def test_cancel_after_response_preserves_provider_usage() -> None:
+    adapter: AgentEngineAdapter
 
     async def provider_handler(_request: httpx.Request) -> httpx.Response:
         await adapter.cancel("run_1")
@@ -128,8 +115,9 @@ async def test_adk_cancel_after_response_preserves_provider_usage() -> None:
         100.0,
     )
     await report.start_run("run_1", 101.0)
-    adapter = AdkEngineAdapter(
-        create_provider(httpx.MockTransport(provider_handler)),
+    provider = create_provider(httpx.MockTransport(provider_handler))
+    adapter = OpenAiCompatibleEngineAdapter(
+        provider,
         ToolHostClient("internal-token"),
         governance(),
         report,

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

@@ -10,6 +10,7 @@ from southwind_agent_server.app import create_app
 from southwind_agent_server.contracts import StartRunRequest
 from southwind_agent_server.deterministic import DeterministicEngineAdapter
 from southwind_agent_server.engine import EngineCompleted
+from southwind_agent_server.engine_identity import DIRECT_ENGINE_ID
 from southwind_agent_server.openai_engine import OpenAiCompatibleEngineAdapter
 from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
 from southwind_agent_server.report_types import (
@@ -94,6 +95,7 @@ class UnavailableRunReportStore(InMemoryAgentRuntimeReportStore):
         run_id: str,
         request: StartRunRequest,
         created_at: float,
+        engine_id: str = DIRECT_ENGINE_ID,
     ) -> None:
         raise RuntimeError("report store unavailable")
 

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

@@ -8,6 +8,7 @@ from southwind_agent_server.contracts import RunReportingContext, StartRunReques
 from southwind_agent_server.report_routes import create_report_router
 from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
 from southwind_agent_server.report_types import UsageFacts
+from southwind_agent_server.store import InMemoryRunStore, RunRecord
 
 
 async def test_internal_run_routes_project_model_deployments_and_facts(
@@ -36,8 +37,36 @@ async def test_internal_run_routes_project_model_deployments_and_facts(
         102.0,
         "provider-model-v2",
     )
+    run_store = InMemoryRunStore()
+    await run_store.create_or_get(
+        RunRecord(
+            run_id="run_1",
+            operation_key="business.answer",
+            input={"prompt": "不应出现在轨迹中"},
+            idempotency_key="idem_1",
+            fingerprint="fingerprint_1",
+            engine_id="windy.direct.openai-compatible.v1",
+            release={"releaseId": "legacy"},
+            events=[
+                {"type": "run.started", "runId": "run_1", "sequence": 1},
+                {
+                    "type": "output.delta",
+                    "runId": "run_1",
+                    "sequence": 2,
+                    "text": "机密输出",
+                },
+                {
+                    "type": "usage.reported",
+                    "runId": "run_1",
+                    "sequence": 3,
+                    "attemptSequence": 1,
+                    "usage": {"totalTokens": 12},
+                },
+            ],
+        )
+    )
     application = FastAPI()
-    application.include_router(create_report_router(store, "internal-token"))
+    application.include_router(create_report_router(store, run_store, "internal-token"))
 
     async with httpx.AsyncClient(
         transport=httpx.ASGITransport(app=application), base_url="http://test"
@@ -84,3 +113,31 @@ async def test_internal_run_routes_project_model_deployments_and_facts(
             "finishedAt": "1970-01-01T00:01:42Z",
         }
     ]
+    assert detail.json()["trajectory"] == {
+        "available": True,
+        "events": [
+            {
+                "sequence": 1,
+                "sequenceEnd": 1,
+                "type": "run.started",
+                "title": "开始执行",
+            },
+            {
+                "sequence": 2,
+                "sequenceEnd": 2,
+                "type": "output.delta",
+                "title": "模型生成输出",
+                "deltaCount": 1,
+                "outputCharacters": 4,
+            },
+            {
+                "sequence": 3,
+                "sequenceEnd": 3,
+                "type": "usage.reported",
+                "title": "Provider 用量已上报",
+                "attemptSequence": 1,
+                "totalTokens": 12,
+            },
+        ],
+    }
+    assert "机密输出" not in detail.text

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

@@ -12,6 +12,7 @@ from southwind_agent_server.report_types import (
 def test_postgres_and_in_memory_summary_present_same_dual_timeline() -> None:
     run = RunReport(
         run_id="run_1",
+        engine_id="windy.direct.openai-compatible.v1",
         operation_key="business.answer",
         release_id="release_1",
         trace_id="trace_1",

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

@@ -11,11 +11,13 @@ from southwind_agent_server.engine import (
     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
 

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

@@ -4,11 +4,12 @@ from unittest.mock import AsyncMock, patch
 
 from pytest import MonkeyPatch
 
-from southwind_agent_server.adk_adapter import AdkEngineAdapter
+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_adk_engine_exposes_vlm_readiness(
+async def test_default_direct_engine_exposes_vlm_readiness(
     monkeypatch: MonkeyPatch,
 ) -> None:
     values = {
@@ -26,7 +27,8 @@ async def test_default_adk_engine_exposes_vlm_readiness(
     for key, value in values.items():
         monkeypatch.setenv(key, value)
     engine = default_engine()
-    assert isinstance(engine, AdkEngineAdapter)
+    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:
@@ -35,3 +37,16 @@ async def test_default_adk_engine_exposes_vlm_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

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

@@ -0,0 +1,91 @@
+from typing import cast
+
+from southwind_agent_server.store import RunRecord
+from southwind_agent_server.trajectory import project_run_trajectory
+
+
+def test_trajectory_preserves_governed_signals_without_sensitive_payloads() -> None:
+    record = RunRecord(
+        run_id="run_1",
+        operation_key="business.answer",
+        input={"prompt": "输入正文"},
+        idempotency_key="idem_1",
+        fingerprint="fingerprint_1",
+        release={"releaseId": "legacy"},
+        events=[
+            {"type": "run.started", "sequence": 1},
+            {
+                "type": "input.prepared",
+                "sequence": 2,
+                "artifactCount": 1,
+                "inputModalities": ["text", "image"],
+            },
+            {
+                "type": "output.delta",
+                "sequence": 3,
+                "text": "第一段输出",
+            },
+            {
+                "type": "output.delta",
+                "sequence": 4,
+                "text": "第二段输出",
+            },
+            {
+                "type": "tool.requested",
+                "sequence": 5,
+                "toolCallId": "call_secret",
+                "toolKey": "business.search",
+                "arguments": {"secret": "不可暴露"},
+            },
+            {
+                "type": "approval.required",
+                "sequence": 6,
+                "toolCallId": "call_secret",
+                "workItemId": "approval_secret",
+            },
+            {
+                "type": "approval.resolved",
+                "sequence": 7,
+                "toolCallId": "call_secret",
+                "workItemId": "approval_secret",
+                "outcome": "approved",
+            },
+            {"type": "tool.completed", "sequence": 8, "toolCallId": "call_secret"},
+            {
+                "type": "usage.reported",
+                "sequence": 9,
+                "attemptSequence": 1,
+                "usage": {"totalTokens": 24, "providerBody": "不可暴露"},
+            },
+            {"type": "run.completed", "sequence": 10},
+        ],
+    )
+
+    trajectory = project_run_trajectory(record)
+    events = cast(list[dict[str, object]], trajectory["events"])
+
+    assert trajectory["available"] is True
+    assert events[2] == {
+        "sequence": 3,
+        "sequenceEnd": 4,
+        "type": "output.delta",
+        "title": "模型生成输出",
+        "deltaCount": 2,
+        "outputCharacters": 10,
+    }
+    assert events[3]["toolKey"] == "business.search"
+    assert events[5]["approvalOutcome"] == "approved"
+    serialized = repr(trajectory)
+    for sensitive in (
+        "输入正文",
+        "第一段输出",
+        "第二段输出",
+        "call_secret",
+        "approval_secret",
+        "不可暴露",
+    ):
+        assert sensitive not in serialized
+
+
+def test_trajectory_marks_expired_canonical_run_as_unavailable() -> None:
+    assert project_run_trajectory(None) == {"available": False, "events": []}