create-windy 0.6.12 → 0.6.15

package/template/apps/agent-server/src/southwind_agent_server/trajectory.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from .store import CanonicalEvent, RunRecord
+
+
+def project_run_trajectory(record: RunRecord | None) -> dict[str, object]:
+    if record is None:
+        return {"available": False, "events": []}
+    projected: list[dict[str, object]] = []
+    tool_keys: dict[str, str] = {}
+    output: dict[str, object] | None = None
+    for event in record.events:
+        event_type = text(event.get("type"))
+        sequence = integer(event.get("sequence"))
+        if not event_type or sequence is None:
+            continue
+        if event_type == "output.delta":
+            delta = event.get("text")
+            if not isinstance(delta, str):
+                continue
+            if output is None:
+                output = item(sequence, event_type, "模型生成输出")
+                output.update(
+                    {
+                        "sequenceEnd": sequence,
+                        "deltaCount": 0,
+                        "outputCharacters": 0,
+                    }
+                )
+                projected.append(output)
+            output["sequenceEnd"] = sequence
+            delta_count = integer(output.get("deltaCount"), 0)
+            output_characters = integer(output.get("outputCharacters"), 0)
+            if delta_count is None or output_characters is None:
+                continue
+            output["deltaCount"] = delta_count + 1
+            output["outputCharacters"] = output_characters + len(delta)
+            continue
+        output = None
+        current = event_item(event_type, sequence, event, tool_keys)
+        if current is not None:
+            projected.append(current)
+    return {"available": True, "events": projected}
+
+
+def event_item(
+    event_type: str,
+    sequence: int,
+    event: CanonicalEvent,
+    tool_keys: dict[str, str],
+) -> dict[str, object] | None:
+    if event_type in {"run.started", "run.resumed"}:
+        return item(
+            sequence,
+            event_type,
+            "开始执行" if event_type == "run.started" else "恢复执行",
+        )
+    if event_type == "input.prepared":
+        result = item(sequence, event_type, "输入已准备")
+        result["artifactCount"] = integer(event.get("artifactCount"), 0)
+        modalities = event.get("inputModalities")
+        result["inputModalities"] = (
+            [value for value in modalities if isinstance(value, str)]
+            if isinstance(modalities, list)
+            else []
+        )
+        return result
+    if event_type == "tool.requested":
+        call_id = text(event.get("toolCallId"))
+        tool_key = text(event.get("toolKey"))
+        if call_id and tool_key:
+            tool_keys[call_id] = tool_key
+        result = item(sequence, event_type, "请求 Tool")
+        if tool_key:
+            result["toolKey"] = tool_key
+        return result
+    if event_type in {"tool.completed", "approval.required", "approval.resolved"}:
+        result = item(
+            sequence,
+            event_type,
+            {
+                "tool.completed": "Tool 已完成",
+                "approval.required": "等待审批",
+                "approval.resolved": "审批已处理",
+            }[event_type],
+        )
+        call_id = text(event.get("toolCallId"))
+        tool_key = tool_keys.get(call_id or "")
+        if tool_key:
+            result["toolKey"] = tool_key
+        outcome = text(event.get("outcome"))
+        if event_type == "approval.resolved" and outcome:
+            result["approvalOutcome"] = outcome
+        return result
+    if event_type == "usage.reported":
+        result = item(sequence, event_type, "Provider 用量已上报")
+        attempt = integer(event.get("attemptSequence"))
+        usage = event.get("usage")
+        total = integer(usage.get("totalTokens")) if isinstance(usage, dict) else None
+        if attempt is not None:
+            result["attemptSequence"] = attempt
+        if total is not None:
+            result["totalTokens"] = total
+        return result
+    if event_type in {"run.completed", "run.cancelled", "run.failed"}:
+        result = item(
+            sequence,
+            event_type,
+            {
+                "run.completed": "执行完成",
+                "run.cancelled": "执行已取消",
+                "run.failed": "执行失败",
+            }[event_type],
+        )
+        error = event.get("error")
+        code = text(error.get("code")) if isinstance(error, dict) else None
+        if code:
+            result["errorCode"] = code
+        return result
+    return None
+
+
+def item(sequence: int, event_type: str, title: str) -> dict[str, object]:
+    return {
+        "sequence": sequence,
+        "sequenceEnd": sequence,
+        "type": event_type,
+        "title": title,
+    }
+
+
+def text(value: object) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def integer(value: object, fallback: int | None = None) -> int | None:
+    return value if isinstance(value, int) and value >= 0 else fallback

package/template/apps/agent-server/src/southwind_agent_server/unavailable_engine.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+
+from .engine import AgentEngineAdapter, EngineRunRequest, EngineSignal, SafeEngineError
+from .vlm_readiness import unavailable_vlm_snapshot
+
+
+class UnavailableEngineAdapter(AgentEngineAdapter):
+    """Explicit fail-closed runtime used when no Provider deployment is configured."""
+
+    ENGINE_ID = "windy.unavailable.v1"
+
+    @property
+    def engine_id(self) -> str:
+        return self.ENGINE_ID
+
+    @property
+    def configured(self) -> bool:
+        return False
+
+    @property
+    def capabilities(self) -> tuple[str, ...]:
+        return ()
+
+    @property
+    def input_modalities(self) -> tuple[str, ...]:
+        return ("text",)
+
+    @property
+    def max_concurrent_runs(self) -> int:
+        return 1
+
+    @property
+    def max_queue_depth(self) -> int:
+        return 0
+
+    def supports(self, operation_key: str) -> bool:
+        return bool(operation_key.strip())
+
+    async def execute(
+        self,
+        request: EngineRunRequest,
+    ) -> AsyncIterator[EngineSignal]:
+        del request
+        raise SafeEngineError(
+            "RUNTIME_UNAVAILABLE",
+            "Agent Provider 尚未配置",
+            retryable=False,
+        )
+        if False:
+            yield
+
+    async def cancel(self, run_id: str) -> None:
+        del run_id
+
+    async def readiness(self) -> dict[str, object]:
+        return unavailable_vlm_snapshot(configured=False)

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",