create-windy 0.6.11 → 0.6.14

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

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from typing import Any, cast
-
-from google.adk.tools.base_tool import BaseTool
-from google.adk.tools.tool_context import ToolContext
-from google.genai import types
-
-from .adk_failure import AdkFailureState
-from .contracts import JsonValue, RuntimeToolDefinition
-from .engine import (
-    ApprovalRequired,
-    ApprovalResolved,
-    EngineRunRequest,
-    EngineSignal,
-    SafeEngineError,
-)
-from .openai_engine_validation import cancelled
-from .tool_host import (
-    ToolApprovalPending,
-    ToolApprovalResolved,
-    ToolHostClient,
-    ToolInvocation,
-    canonical_tool_call_id,
-)
-
-
-class ApprovalSignalState:
-    def __init__(self) -> None:
-        self.queue: asyncio.Queue[EngineSignal] = asyncio.Queue()
-
-
-class GovernedTool(BaseTool):
-    """ADK declaration whose only execution path is the governed Tool Host."""
-
-    def __init__(
-        self,
-        definition: RuntimeToolDefinition,
-        request: EngineRunRequest,
-        tool_host: ToolHostClient,
-        cancellation: asyncio.Event,
-        failures: AdkFailureState,
-        approvals: ApprovalSignalState,
-    ) -> None:
-        super().__init__(
-            name=definition.key,
-            description=definition.description,
-        )
-        self._request = request
-        self._tool_host = tool_host
-        self._cancellation = cancellation
-        self._failures = failures
-        self._approvals = approvals
-
-    def _get_declaration(self) -> types.FunctionDeclaration:
-        return types.FunctionDeclaration(
-            name=self.name,
-            description=self.description,
-            parameters_json_schema={
-                "type": "object",
-                "additionalProperties": True,
-            },
-        )
-
-    async def run_async(
-        self,
-        *,
-        args: dict[str, Any],
-        tool_context: ToolContext,
-    ) -> JsonValue:
-        try:
-            cancelled(self._cancellation)
-            call_id = tool_context.function_call_id
-            if not call_id:
-                raise SafeEngineError(
-                    "TOOL_DENIED",
-                    "Agent Tool Call 缺少稳定标识",
-                    retryable=False,
-                )
-            stable_call_id = canonical_tool_call_id(
-                self._request.run_id,
-                self.name,
-                cast(dict[str, JsonValue], args),
-            )
-            invocation = ToolInvocation(
-                self._request.run_id,
-                stable_call_id,
-                self.name,
-                cast(dict[str, JsonValue], args),
-                self._request.execution_grant,
-            )
-            approval: ToolApprovalPending | None = None
-            while True:
-                cancelled(self._cancellation)
-                try:
-                    result = await self._tool_host.execute(
-                        self._request.tool_host_url,
-                        invocation,
-                    )
-                    if approval:
-                        await self._approvals.queue.put(
-                            ApprovalResolved(
-                                approval.work_item_id,
-                                stable_call_id,
-                                "approved",
-                            )
-                        )
-                    break
-                except ToolApprovalPending as pending:
-                    if approval is None:
-                        approval = pending
-                        await self._approvals.queue.put(
-                            ApprovalRequired(
-                                pending.work_item_id,
-                                stable_call_id,
-                            )
-                        )
-                    elif approval.work_item_id != pending.work_item_id:
-                        raise SafeEngineError(
-                            "TOOL_DENIED",
-                            "Agent Tool 审批标识漂移",
-                            retryable=False,
-                        ) from None
-                    await asyncio.sleep(2)
-                except ToolApprovalResolved as resolved:
-                    await self._approvals.queue.put(
-                        ApprovalResolved(
-                            resolved.work_item_id,
-                            stable_call_id,
-                            resolved.outcome,
-                        )
-                    )
-                    raise SafeEngineError(
-                        "TOOL_DENIED",
-                        "Agent Tool 审批未通过",
-                        retryable=False,
-                    ) from None
-            cancelled(self._cancellation)
-            return result
-        except SafeEngineError as error:
-            self._failures.capture(error)
-            raise

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

@@ -1,307 +0,0 @@
-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, canonical_tool_call_id
-
-
-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 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": "你好"}
-
-
-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": canonical_tool_call_id(
-                "run_1",
-                "business.records.list",
-                {"page": 2},
-            ),
-            "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_debug_result_polling.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-
-import httpx
-import pytest
-
-from southwind_agent_server.adk_debug import CanonicalRunDebugClient
-
-OPERATION_KEY = "customer.copilot.global"
-
-
-async def test_client_waits_for_result_after_stream_closes() -> None:
-    result_attempts = 0
-    started_runs = 0
-
-    async def handler(request: httpx.Request) -> httpx.Response:
-        nonlocal result_attempts, started_runs
-        if request.url.path == "/api/agent/runs":
-            started_runs += 1
-            return httpx.Response(200, json={"runId": "run_race"})
-        if request.url.path.endswith("/events"):
-            return httpx.Response(
-                200,
-                content=(
-                    b'event: run.started\ndata: {"sequence":1,"type":"run.started"}\n\n'
-                ),
-            )
-        if request.url.path.endswith("/result"):
-            result_attempts += 1
-            if result_attempts < 3:
-                return httpx.Response(
-                    409,
-                    json={"code": "RUN_CONFLICT", "retryable": True},
-                )
-            return httpx.Response(
-                200,
-                json={
-                    "runId": "run_race",
-                    "status": "completed",
-                    "output": {"text": "稍后可读"},
-                },
-            )
-        raise AssertionError(request.url)
-
-    client = CanonicalRunDebugClient(
-        OPERATION_KEY,
-        "https://platform.test",
-        "developer-token",
-        transport=httpx.MockTransport(handler),
-        result_poll_interval_seconds=0.001,
-    )
-
-    result = await client.run("验证竞态")
-
-    assert result["answer"] == "稍后可读"
-    events = result["events"]
-    assert isinstance(events, list) and {"type": "run.completed"} in events
-    assert started_runs == 1
-    assert result_attempts == 3
-
-
-@pytest.mark.parametrize(
-    ("payload", "timeout_seconds", "delay_seconds", "message"),
-    [
-        (
-            {
-                "code": "RUN_CANCELLED",
-                "message": "secret-upstream-body",
-                "retryable": False,
-            },
-            5,
-            0,
-            "永久失败",
-        ),
-        (
-            {
-                "code": "RUN_CONFLICT",
-                "message": "Agent Run 尚未完成",
-                "retryable": True,
-            },
-            0.01,
-            0,
-            "等待超时",
-        ),
-        (
-            {
-                "code": "RUN_CONFLICT",
-                "message": "slow-secret-upstream-body",
-                "retryable": True,
-            },
-            0.01,
-            0.05,
-            "等待超时",
-        ),
-    ],
-)
-async def test_client_bounds_result_polling_and_hides_error_content(
-    payload: dict[str, object],
-    timeout_seconds: float,
-    delay_seconds: float,
-    message: str,
-) -> None:
-    requests: list[httpx.Request] = []
-
-    async def handler(request: httpx.Request) -> httpx.Response:
-        requests.append(request)
-        if request.url.path == "/api/agent/runs":
-            return httpx.Response(200, json={"runId": "run_terminal"})
-        if request.url.path.endswith("/events"):
-            return httpx.Response(
-                200,
-                content=(
-                    b"event: run.completed\ndata: "
-                    b'{"sequence":1,"type":"run.completed"}\n\n'
-                ),
-            )
-        if request.url.path.endswith("/result"):
-            await asyncio.sleep(delay_seconds)
-            return httpx.Response(409, json=payload)
-        raise AssertionError(request.url)
-
-    client = CanonicalRunDebugClient(
-        OPERATION_KEY,
-        "https://platform.test",
-        "developer-token",
-        transport=httpx.MockTransport(handler),
-        result_poll_timeout_seconds=timeout_seconds,
-        result_poll_interval_seconds=0.001,
-    )
-
-    with pytest.raises(RuntimeError, match=message) as failure:
-        await client.run("验证结果失败")
-
-    error_message = str(failure.value)
-    assert "secret-upstream-body" not in error_message
-    assert "slow-secret-upstream-body" not in error_message
-    assert sum(request.url.path == "/api/agent/runs" for request in requests) == 1
-    assert sum(request.url.path.endswith("/result") for request in requests) >= 1