create-windy 0.4.1 → 0.5.1

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

@@ -4,8 +4,9 @@ import asyncio
 import logging
 import uuid
 
+from .approval_resolution import resolve_pending_approval
 from .artifact_input import ArtifactLoader
-from .contracts import AgentError, StartRunRequest
+from .contracts import StartRunRequest
 from .engine import (
     AgentEngineAdapter,
     EngineCompleted,
@@ -14,19 +15,24 @@ from .engine import (
 )
 from .fingerprint import request_fingerprint, resolved_release
 from .lease import cancel_on_lease_loss, lease_failed
-from .signal_events import canonical_signal_event
-from .store import IdempotencyConflictError, RunRecord, RunStore
+from .report_lifecycle import (
+    append_and_sync_canonical_event,
+    ensure_run_report_safely,
+    start_run_report_safely,
+    sync_terminal_from_canonical,
+)
+from .report_store import AgentRuntimeReportStore
+from .signal_events import canonical_failure_fields, canonical_signal_event
+from .store import RunRecord, RunStore
 from .telemetry import AgentRunTrace
 
 logger = logging.getLogger(__name__)
 
 
-class RunNotFoundError(Exception):
-    pass
+class RunNotFoundError(Exception): ...
 
 
-class OperationNotFoundError(Exception):
-    pass
+class OperationNotFoundError(Exception): ...
 
 
 class AgentRunService:
@@ -34,10 +40,12 @@ class AgentRunService:
         self,
         engine: AgentEngineAdapter,
         store: RunStore,
+        report_store: AgentRuntimeReportStore,
         artifact_loader: ArtifactLoader | None = None,
     ) -> None:
         self.engine = engine
         self.store = store
+        self.report_store = report_store
         self.artifact_loader = artifact_loader
         self._tasks: set[asyncio.Task[None]] = set()
         self._active_run_ids: set[str] = set()
@@ -72,6 +80,7 @@ class AgentRunService:
             candidate,
             request.model_dump(by_alias=True),
         )
+        await ensure_run_report_safely(self.report_store, record.run_id, request)
         if created:
             self._spawn(record, request)
         return record
@@ -92,14 +101,21 @@ class AgentRunService:
             return_exceptions=True,
         )
         await self.store.close()
+        await self.report_store.close()
 
     async def _recover_once(self) -> None:
         for record, raw in await self.store.recoverable():
             if record.run_id in self._active_run_ids:
                 continue
+            request = StartRunRequest.model_validate(raw)
+            await ensure_run_report_safely(
+                self.report_store,
+                record.run_id,
+                request,
+            )
             self._spawn(
                 record,
-                StartRunRequest.model_validate(raw),
+                request,
                 resumed=True,
             )
 
@@ -141,8 +157,13 @@ class AgentRunService:
         if record.terminal:
             return record
         await self.engine.cancel(run_id)
-        await self._resolve_pending_approval(record, "cancelled")
-        await self.store.append(run_id, "run.cancelled")
+        await resolve_pending_approval(self.store, record, "cancelled")
+        await append_and_sync_canonical_event(
+            self.report_store,
+            self.store,
+            run_id,
+            "run.cancelled",
+        )
         return await self.get(run_id)
 
     async def _execute(
@@ -162,10 +183,14 @@ class AgentRunService:
             lambda completed: cancel_on_lease_loss(completed, execution_task)
         )
         try:
-            await self.store.append(
+            await start_run_report_safely(self.report_store, record.run_id)
+            if await append_and_sync_canonical_event(
+                self.report_store,
+                self.store,
                 record.run_id,
                 "run.resumed" if resumed else "run.started",
-            )
+            ):
+                return
             if invocation.artifacts and not self.artifact_loader:
                 raise SafeEngineError(
                     "RUNTIME_UNAVAILABLE",
@@ -217,9 +242,21 @@ class AgentRunService:
                 async for signal in self.engine.execute(request):
                     if isinstance(signal, EngineCompleted):
                         await self.store.complete(record.run_id, signal.output)
+                        await sync_terminal_from_canonical(
+                            self.report_store,
+                            self.store,
+                            record.run_id,
+                        )
                         return
                     event_type, fields = canonical_signal_event(signal)
-                    await self.store.append(record.run_id, event_type, fields)
+                    if await append_and_sync_canonical_event(
+                        self.report_store,
+                        self.store,
+                        record.run_id,
+                        event_type,
+                        fields,
+                    ):
+                        return
             await self._fail(
                 record.run_id,
                 SafeEngineError(
@@ -232,7 +269,7 @@ class AgentRunService:
             await self._fail(record.run_id, error)
         except TimeoutError:
             current = await self.get(record.run_id)
-            await self._resolve_pending_approval(current, "timed-out")
+            await resolve_pending_approval(self.store, current, "timed-out")
             await self._fail(
                 record.run_id,
                 SafeEngineError(
@@ -302,44 +339,12 @@ class AgentRunService:
         self._tasks.discard(task)
         self._active_run_ids.discard(run_id)
 
-    async def _resolve_pending_approval(
-        self,
-        record: RunRecord,
-        outcome: str,
-    ) -> None:
-        pending: dict[str, object] | None = None
-        for event in record.events:
-            if event.get("type") == "approval.required":
-                pending = event
-            elif event.get("type") == "approval.resolved":
-                pending = None
-        if not pending:
-            return
-        work_item_id = pending.get("workItemId")
-        tool_call_id = pending.get("toolCallId")
-        if isinstance(work_item_id, str) and isinstance(tool_call_id, str):
-            await self.store.append(
-                record.run_id,
-                "approval.resolved",
-                {
-                    "workItemId": work_item_id,
-                    "toolCallId": tool_call_id,
-                    "outcome": outcome,
-                },
-            )
-
     async def _fail(self, run_id: str, failure: SafeEngineError) -> None:
-        error = AgentError(
-            code=failure.code,
-            message=failure.safe_message,
-            request_id=f"request_{uuid.uuid4().hex}",
-            retryable=failure.retryable,
-        )
-        await self.store.append(
+        await append_and_sync_canonical_event(
+            self.report_store,
+            self.store,
             run_id,
             "run.failed",
-            {"error": error.model_dump(by_alias=True)},
+            canonical_failure_fields(failure),
+            fallback_safe_error_code=failure.code,
         )
-
-
-__all__ = ["AgentRunService", "IdempotencyConflictError"]

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

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+import uuid
+
+from .contracts import AgentError
 from .engine import (
     ApprovalRequired,
     ApprovalResolved,
     OutputDelta,
+    SafeEngineError,
     ToolCompleted,
     ToolRequested,
     UsageReported,
@@ -32,5 +36,18 @@ def canonical_signal_event(signal: object) -> tuple[str, dict[str, object]]:
     if isinstance(signal, ToolCompleted):
         return "tool.completed", {"toolCallId": signal.tool_call_id}
     if isinstance(signal, UsageReported):
-        return "usage.reported", {"usage": signal.usage}
+        return "usage.reported", {
+            "attemptSequence": signal.attempt_sequence,
+            "usage": signal.usage.event_value(),
+        }
     raise TypeError("unsupported engine signal")
+
+
+def canonical_failure_fields(failure: SafeEngineError) -> dict[str, object]:
+    error = AgentError(
+        code=failure.code,
+        message=failure.safe_message,
+        request_id=f"request_{uuid.uuid4().hex}",
+        retryable=failure.retryable,
+    )
+    return {"error": error.model_dump(by_alias=True)}

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

@@ -62,15 +62,13 @@ async def test_adk_runner_maps_text_usage_and_terminal() -> None:
         "你",
         "好",
     ]
-    usage = [signal.usage for signal in signals if isinstance(signal, UsageReported)]
-    assert usage == [
-        {
-            "source": "provider-reported",
-            "inputTokens": 2,
-            "outputTokens": 2,
-            "totalTokens": 4,
-        }
-    ]
+    usage = [signal for signal in signals if isinstance(signal, UsageReported)]
+    assert len(usage) == 1
+    assert usage[0].attempt_sequence == 1
+    assert usage[0].usage.source == "provider-reported"
+    assert usage[0].usage.input_tokens == 2
+    assert usage[0].usage.output_tokens == 2
+    assert usage[0].usage.total_tokens == 4
     assert isinstance(signals[-1], EngineCompleted)
     assert signals[-1].output == {"text": "你好"}
 

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

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import httpx
+import pytest
+from google.adk.cli.service_registry import get_service_registry
+from google.adk.events.event import Event
+from google.genai import types
+
+from adk_web_agents.services import SESSION_SERVICE_URI
+from southwind_agent_server.adk_debug_sessions import (
+    IMPORTED_SESSION_STATE_KEY,
+    DebugSessionDetailV1,
+    DebugSessionListEnvelopeV1,
+    ImportedDebugSessionReadOnlyError,
+    WindyDebugSessionClientV1,
+    WindyDebugSessionServiceV1,
+)
+
+SESSION_ID = "wdbg1_" + "a" * 43
+
+
+def test_services_module_registers_official_custom_uri(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("ADK_DEBUG_PLATFORM_URL", "https://platform.test")
+    monkeypatch.setenv("ADK_DEBUG_PLATFORM_TOKEN", "debug-token")
+
+    service = get_service_registry().create_session_service(SESSION_SERVICE_URI)
+
+    assert isinstance(service, WindyDebugSessionServiceV1)
+
+
+async def test_client_uses_read_only_platform_routes_and_strict_v1_dto() -> None:
+    requests: list[httpx.Request] = []
+
+    async def handler(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        if request.url.path.endswith(SESSION_ID):
+            return httpx.Response(200, json=detail_envelope())
+        return httpx.Response(200, json=list_envelope())
+
+    client = WindyDebugSessionClientV1(
+        "https://platform.test",
+        "debug-token",
+        transport=httpx.MockTransport(handler),
+    )
+
+    listed = await client.list()
+    detail = await client.get(SESSION_ID)
+
+    assert listed.sessions[0].id == SESSION_ID
+    assert detail and detail.messages[1].content == "只读回答"
+    assert [request.method for request in requests] == ["GET", "GET"]
+    assert all(
+        request.headers["authorization"] == "Bearer debug-token" for request in requests
+    )
+
+
+async def test_service_overlays_imported_projection_and_keeps_local_sessions() -> None:
+    client = FakeClient()
+    service = WindyDebugSessionServiceV1(client)
+    local = await service.create_session(
+        app_name="canonical_debug",
+        user_id="user",
+        session_id="local-session",
+        state={"topic": "local"},
+    )
+
+    listed = await service.list_sessions(app_name="canonical_debug", user_id="user")
+    imported = await service.get_session(
+        app_name="canonical_debug",
+        user_id="user",
+        session_id=SESSION_ID,
+    )
+
+    assert {session.id for session in listed.sessions} == {
+        local.id,
+        SESSION_ID,
+    }
+    assert imported
+    assert imported.state[IMPORTED_SESSION_STATE_KEY] is True
+    assert [event.content.role for event in imported.events if event.content] == [
+        "user",
+        "model",
+    ]
+    await service.delete_session(
+        app_name="canonical_debug", user_id="user", session_id=SESSION_ID
+    )
+    after_delete = await service.list_sessions(
+        app_name="canonical_debug", user_id="user"
+    )
+    assert [session.id for session in after_delete.sessions] == [local.id]
+
+
+def test_list_contract_accepts_all_sessions_after_platform_drains_pages() -> None:
+    envelope = DebugSessionListEnvelopeV1.model_validate(
+        {
+            "schemaVersion": 1,
+            "sessions": [
+                {
+                    **summary(),
+                    "id": f"wdbg1_{index:043d}",
+                    "title": f"历史研判 {index}",
+                }
+                for index in range(101)
+            ],
+            "truncated": False,
+        }
+    )
+
+    assert len(envelope.sessions) == 101
+
+
+async def test_imported_projection_rejects_mutation_and_follow_up() -> None:
+    service = WindyDebugSessionServiceV1(FakeClient())
+    imported = await service.get_session(
+        app_name="canonical_debug",
+        user_id="user",
+        session_id=SESSION_ID,
+    )
+    assert imported
+
+    with pytest.raises(ImportedDebugSessionReadOnlyError, match="只读投影"):
+        await service.append_event(
+            imported,
+            Event(
+                author="user",
+                content=types.Content(role="user", parts=[types.Part(text="继续追问")]),
+            ),
+        )
+    with pytest.raises(ImportedDebugSessionReadOnlyError, match="保留值"):
+        await service.create_session(
+            app_name="canonical_debug",
+            user_id="user",
+            session_id=SESSION_ID,
+        )
+
+
+@pytest.mark.parametrize(
+    "error",
+    [
+        pytest.param(httpx.ConnectError("offline"), id="connect-error"),
+        pytest.param(ValueError("provider failed"), id="provider-exception"),
+    ],
+)
+async def test_remote_failure_does_not_break_normal_local_sessions(
+    error: Exception,
+) -> None:
+    service = WindyDebugSessionServiceV1(FailingListClient(error))
+    local = await service.create_session(
+        app_name="canonical_debug", user_id="user", session_id="local-session"
+    )
+
+    listed = await service.list_sessions(app_name="canonical_debug", user_id="user")
+
+    assert [session.id for session in listed.sessions] == [local.id]
+
+
+class FakeClient:
+    async def list(self) -> DebugSessionListEnvelopeV1:
+        return DebugSessionListEnvelopeV1.model_validate(list_envelope())
+
+    async def get(self, session_id: str) -> DebugSessionDetailV1 | None:
+        if session_id != SESSION_ID:
+            return None
+        return DebugSessionDetailV1.model_validate(detail_envelope()["session"])
+
+
+class FailingListClient(FakeClient):
+    def __init__(self, error: Exception) -> None:
+        self._error = error
+
+    async def list(self) -> DebugSessionListEnvelopeV1:
+        raise self._error
+
+
+def list_envelope() -> dict[str, object]:
+    return {
+        "schemaVersion": 1,
+        "sessions": [summary()],
+        "truncated": False,
+    }
+
+
+def detail_envelope() -> dict[str, object]:
+    return {
+        "schemaVersion": 1,
+        "session": {
+            **summary(),
+            "messages": [
+                {
+                    "sequence": 1,
+                    "role": "user",
+                    "content": "历史问题",
+                    "createdAt": "2026-07-31T01:00:00.000Z",
+                },
+                {
+                    "sequence": 2,
+                    "role": "assistant",
+                    "content": "只读回答",
+                    "createdAt": "2026-07-31T01:00:01.000Z",
+                },
+            ],
+        },
+    }
+
+
+def summary() -> dict[str, object]:
+    return {
+        "id": SESSION_ID,
+        "title": "历史研判",
+        "scopeLabel": "当前范围",
+        "updatedAt": "2026-07-31T01:00:01.000Z",
+        "revision": "2",
+    }

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

@@ -12,6 +12,7 @@ from adk_web_agents.canonical_debug.agent import (
     TOOL_NAME,
     CanonicalDebugLlm,
     build_root_agent,
+    ensure_debug_session_writable,
 )
 from southwind_agent_server.adk_debug import (
     MAX_EVENT_FRAME_BYTES,
@@ -21,6 +22,9 @@ from southwind_agent_server.adk_debug import (
     load_text_operation_debug_config,
     sse_events,
 )
+from southwind_agent_server.adk_debug_sessions import (
+    ImportedDebugSessionReadOnlyError,
+)
 
 OPERATION = TextOperationDebugConfig("customer.copilot.global")
 
@@ -104,6 +108,7 @@ async def test_dispatcher_renders_result_and_bounded_event_summary() -> None:
     model = CanonicalDebugLlm(OPERATION)
     request = LlmRequest(
         contents=[
+            types.Content(role="user", parts=[types.Part(text="查测试数据")]),
             types.Content(
                 role="user",
                 parts=[
@@ -118,7 +123,7 @@ async def test_dispatcher_renders_result_and_bounded_event_summary() -> None:
                         )
                     )
                 ],
-            )
+            ),
         ]
     )
 
@@ -131,6 +136,41 @@ async def test_dispatcher_renders_result_and_bounded_event_summary() -> None:
     )
 
 
+async def test_dispatcher_ignores_previous_turn_tool_response() -> None:
+    model = CanonicalDebugLlm(OPERATION)
+    request = LlmRequest(
+        contents=[
+            types.Content(role="user", parts=[types.Part(text="第一轮问题")]),
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part(
+                        function_response=types.FunctionResponse(
+                            name=TOOL_NAME,
+                            response={
+                                "runId": "run_previous",
+                                "answer": "上一轮回答",
+                                "events": [],
+                            },
+                        )
+                    )
+                ],
+            ),
+            types.Content(role="model", parts=[types.Part(text="上一轮回答")]),
+            types.Content(role="user", parts=[types.Part(text="第二轮问题")]),
+        ]
+    )
+
+    responses = [response async for response in model.generate_content_async(request)]
+
+    response = responses[0]
+    assert response.content and response.content.parts
+    call = response.content.parts[0].function_call
+    assert call
+    assert call.name == TOOL_NAME
+    assert call.args == {"question": "第二轮问题"}
+
+
 async def test_unconfigured_project_fails_closed_without_tool() -> None:
     model = CanonicalDebugLlm(None)
     request = LlmRequest(
@@ -145,6 +185,13 @@ async def test_unconfigured_project_fails_closed_without_tool() -> None:
     assert build_root_agent(None).tools == []
 
 
+def test_imported_session_follow_up_fails_closed() -> None:
+    with pytest.raises(ImportedDebugSessionReadOnlyError, match="只读投影"):
+        ensure_debug_session_writable(True)
+
+    ensure_debug_session_writable(False)
+
+
 def test_project_config_selects_only_operation_key(tmp_path: Path) -> None:
     path = tmp_path / "adk-web-debug.json"
     path.write_text(

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

@@ -49,12 +49,64 @@ async def test_provider_stream_and_health_use_bounded_safe_protocol() -> None:
         (),
     )
     assert turn.text_deltas == ["你", "好"]
-    assert turn.usage == {
-        "source": "provider-reported",
-        "inputTokens": 2,
-        "outputTokens": 2,
-        "totalTokens": 4,
-    }
+    assert turn.usage.source == "provider-reported"
+    assert turn.usage.input_tokens == 2
+    assert turn.usage.output_tokens == 2
+    assert turn.usage.total_tokens == 4
+    assert turn.usage.cached_input_tokens is None
+    assert turn.usage.cache_status == "unknown"
+    assert turn.usage.first_token_latency_ms is not None
+
+
+async def test_provider_reports_cache_reasoning_model_without_fabricating() -> None:
+    async def handler(_request: httpx.Request) -> httpx.Response:
+        return sse_response(
+            [
+                {
+                    "model": "provider-model-v2",
+                    "choices": [{"delta": {"content": "完成"}}],
+                    "usage": {
+                        "prompt_tokens": 10,
+                        "completion_tokens": 4,
+                        "total_tokens": 14,
+                        "prompt_tokens_details": {"cached_tokens": 6},
+                        "completion_tokens_details": {"reasoning_tokens": 3},
+                    },
+                }
+            ]
+        )
+
+    turn = await create_provider(httpx.MockTransport(handler)).complete_turn(
+        [{"role": "user", "content": "hi"}], ()
+    )
+
+    assert turn.reported_model == "provider-model-v2"
+    assert turn.usage.cached_input_tokens == 6
+    assert turn.usage.reasoning_tokens == 3
+    assert turn.usage.cache_status == "hit"
+
+
+async def test_provider_rejects_impossible_cached_token_fact() -> None:
+    async def handler(_request: httpx.Request) -> httpx.Response:
+        return sse_response(
+            [
+                {
+                    "choices": [{"delta": {"content": "完成"}}],
+                    "usage": {
+                        "prompt_tokens": 2,
+                        "prompt_tokens_details": {"cached_tokens": 3},
+                    },
+                }
+            ]
+        )
+
+    turn = await create_provider(httpx.MockTransport(handler)).complete_turn(
+        [{"role": "user", "content": "hi"}], ()
+    )
+
+    assert turn.usage.input_tokens == 2
+    assert turn.usage.cached_input_tokens is None
+    assert turn.usage.cache_status == "unknown"
 
 
 async def test_provider_error_never_leaks_body_or_secret() -> None:

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

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from southwind_agent_server.postgres_report_status import (
+    start_or_resume_run,
+)
+
+
+async def test_start_or_resume_abandons_only_unfinished_running_attempts() -> None:
+    connection = FakeConnection()
+
+    abandoned = await start_or_resume_run(
+        cast(Any, connection),
+        "run_1",
+        200.0,
+    )
+
+    assert abandoned == 2
+    assert len(connection.queries) == 2
+    query, parameters = connection.queries[1]
+    assert "set outcome = 'abandoned'" in query
+    assert "outcome = 'running'" in query
+    assert "finished_at is null" in query
+    assert parameters == (200.0, 200.0, "run_1")
+
+
+class FakeConnection:
+    def __init__(self) -> None:
+        self.queries: list[tuple[str, tuple[object, ...]]] = []
+
+    def transaction(self) -> FakeTransaction:
+        return FakeTransaction()
+
+    async def execute(
+        self,
+        query: str,
+        parameters: tuple[object, ...],
+    ) -> FakeCursor:
+        self.queries.append((query, parameters))
+        return FakeCursor(2 if "set outcome = 'abandoned'" in query else 1)
+
+
+class FakeTransaction:
+    async def __aenter__(self) -> None:
+        return None
+
+    async def __aexit__(
+        self,
+        exception_type: object,
+        exception: object,
+        traceback: object,
+    ) -> None:
+        return None
+
+
+class FakeCursor:
+    def __init__(self, rowcount: int) -> None:
+        self.rowcount = rowcount