create-windy 0.6.12 → 0.6.14

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

@@ -1,333 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections.abc import AsyncIterator
-from typing import cast
-
-from google.adk.agents import LlmAgent
-from google.adk.agents.run_config import RunConfig, StreamingMode
-from google.adk.events import Event
-from google.adk.runners import Runner
-from google.adk.sessions import InMemorySessionService
-from google.genai import types
-
-from .adk_failure import AdkFailureState
-from .adk_model import GovernedOpenAiLlm
-from .adk_tools import ApprovalSignalState, GovernedTool
-from .engine import (
-    AgentEngineAdapter,
-    EngineCompleted,
-    EngineRunRequest,
-    EngineSignal,
-    OutputDelta,
-    SafeEngineError,
-    ToolCompleted,
-    ToolRequested,
-    UsageReported,
-)
-from .multimodal import final_output
-from .openai_engine_validation import cancelled, validate_runtime_request
-from .openai_provider import OpenAiCompatibleProvider
-from .provider_governance import ProviderRequestGovernance
-from .report_store import AgentRuntimeReportStore
-from .report_types import CacheStatus, UsageFacts, UsageSource
-from .tool_host import ToolHostClient, canonical_tool_call_id
-from .vlm_readiness import VlmReadinessProbe, unavailable_vlm_snapshot
-
-
-class AdkEngineAdapter(AgentEngineAdapter):
-    """Google ADK Runner implementation behind the stable engine seam."""
-
-    def __init__(
-        self,
-        provider: OpenAiCompatibleProvider | None = None,
-        tool_host: ToolHostClient | None = None,
-        governance: ProviderRequestGovernance | None = None,
-        report_store: AgentRuntimeReportStore | None = None,
-    ) -> None:
-        self._provider = provider
-        self._tool_host = tool_host
-        self._governance = governance
-        self._report_store = report_store
-        self._cancellations: dict[str, asyncio.Event] = {}
-
-    @property
-    def capabilities(self) -> tuple[str, ...]:
-        return self._provider.config.capabilities if self._provider else ()
-
-    @property
-    def input_modalities(self) -> tuple[str, ...]:
-        return self._provider.config.input_modalities if self._provider else ()
-
-    @property
-    def max_concurrent_runs(self) -> int:
-        return self._provider.config.max_concurrent_runs if self._provider else 1
-
-    @property
-    def max_queue_depth(self) -> int:
-        return self._provider.config.max_queue_depth if self._provider else 0
-
-    def supports(self, operation_key: str) -> bool:
-        return bool(operation_key.strip())
-
-    async def execute(
-        self,
-        request: EngineRunRequest,
-    ) -> AsyncIterator[EngineSignal]:
-        provider, tool_host, governance = self._configured()
-        validate_runtime_request(
-            request,
-            provider.config.deployment_key,
-            provider.config.capabilities,
-            provider.config.input_modalities,
-        )
-        cancellation = self._cancellations.setdefault(
-            request.run_id,
-            asyncio.Event(),
-        )
-        output = ""
-        output_bytes = 0
-        failures = AdkFailureState()
-        approvals = ApprovalSignalState()
-        event_failure: SafeEngineError | None = None
-        tool_call_ids: dict[str, str] = {}
-        try:
-            session_service = InMemorySessionService()  # type: ignore[no-untyped-call]
-            await session_service.create_session(
-                app_name="southwind_runtime",
-                user_id="platform",
-                session_id=request.run_id,
-            )
-            runner = Runner(
-                app_name="southwind_runtime",
-                agent=LlmAgent(
-                    name="southwind_operation",
-                    model=GovernedOpenAiLlm(
-                        request,
-                        provider,
-                        governance,
-                        cancellation,
-                        failures,
-                        self._report_store,
-                    ),
-                    instruction=request.instructions,
-                    tools=[
-                        GovernedTool(
-                            tool,
-                            request,
-                            tool_host,
-                            cancellation,
-                            failures,
-                            approvals,
-                        )
-                        for tool in request.allowed_tools
-                    ],
-                ),
-                session_service=session_service,
-            )
-            events = runner.run_async(
-                user_id="platform",
-                session_id=request.run_id,
-                new_message=types.Content(
-                    role="user",
-                    parts=[types.Part(text=request.user_prompt)],
-                ),
-                run_config=RunConfig(
-                    streaming_mode=StreamingMode.SSE,
-                    max_llm_calls=provider.config.max_tool_rounds,
-                ),
-            )
-            async for item in merge_adk_events(events, approvals.queue):
-                if not isinstance(item, Event):
-                    yield item
-                    continue
-                event = item
-                cancelled(cancellation)
-                if event.error_code:
-                    event_failure = failures.failure or SafeEngineError(
-                        "PROVIDER_UNAVAILABLE",
-                        "模型服务暂不可用",
-                        retryable=True,
-                    )
-                    continue
-                async for signal in signals_for_event(
-                    event,
-                    request,
-                    tool_call_ids,
-                ):
-                    if isinstance(signal, OutputDelta):
-                        output_bytes += len(signal.text.encode())
-                        if output_bytes > request.limits.max_output_bytes:
-                            raise SafeEngineError(
-                                "BUDGET_EXCEEDED",
-                                "Agent 输出超过 Operation 上限",
-                                retryable=False,
-                            )
-                        output += signal.text
-                    yield signal
-            if event_failure is not None:
-                raise event_failure
-            cancelled(cancellation)
-            yield EngineCompleted(final_output(output, request.output_schema))
-        except SafeEngineError:
-            raise
-        except asyncio.CancelledError:
-            raise SafeEngineError(
-                "RUN_CANCELLED",
-                "Agent Run 已取消",
-                retryable=False,
-            ) from None
-        except Exception:
-            raise SafeEngineError(
-                "RUNTIME_UNAVAILABLE",
-                "Agent Runtime 执行失败",
-                retryable=True,
-            ) from None
-        finally:
-            self._cancellations.pop(request.run_id, None)
-
-    async def cancel(self, run_id: str) -> None:
-        cancellation = self._cancellations.get(run_id)
-        if cancellation is not None:
-            cancellation.set()
-
-    async def health(self) -> None:
-        self._configured()
-
-    async def readiness(self) -> dict[str, object]:
-        if not self._provider:
-            return unavailable_vlm_snapshot(configured=False)
-        return await VlmReadinessProbe(self._provider.config, self._provider).inspect()
-
-    def governance_health(self) -> dict[str, int | float | str | None]:
-        _, _, governance = self._configured()
-        return governance.health()
-
-    def _configured(
-        self,
-    ) -> tuple[
-        OpenAiCompatibleProvider,
-        ToolHostClient,
-        ProviderRequestGovernance,
-    ]:
-        if not self._provider or not self._tool_host or not self._governance:
-            raise SafeEngineError(
-                "RUNTIME_UNAVAILABLE",
-                "Agent Runtime 尚未配置",
-                retryable=True,
-            )
-        return self._provider, self._tool_host, self._governance
-
-
-async def signals_for_event(
-    event: Event,
-    request: EngineRunRequest,
-    tool_call_ids: dict[str, str],
-) -> AsyncIterator[EngineSignal]:
-    for call in event.get_function_calls():
-        if not call.id or not call.name:
-            raise SafeEngineError(
-                "TOOL_DENIED",
-                "模型请求了无效 Tool",
-                retryable=False,
-            )
-        arguments = call.args if isinstance(call.args, dict) else {}
-        stable_id = canonical_tool_call_id(
-            request.run_id,
-            call.name,
-            arguments,
-        )
-        tool_call_ids[call.id] = stable_id
-        yield ToolRequested(stable_id, call.name)
-    for response in event.get_function_responses():
-        if not response.id:
-            raise SafeEngineError(
-                "TOOL_DENIED",
-                "Agent Tool 响应缺少稳定标识",
-                retryable=False,
-            )
-        response_tool_call_id = tool_call_ids.get(response.id)
-        if not response_tool_call_id:
-            raise SafeEngineError(
-                "TOOL_DENIED",
-                "Agent Tool 响应与请求不匹配",
-                retryable=False,
-            )
-        yield ToolCompleted(response_tool_call_id)
-    if event.partial and event.content:
-        for part in event.content.parts or []:
-            if part.text and not part.thought:
-                yield OutputDelta(part.text)
-    usage = southwind_usage(event)
-    attempt_sequence = southwind_attempt_sequence(event)
-    if usage is not None and attempt_sequence is not None:
-        yield UsageReported(attempt_sequence, usage)
-
-
-def southwind_usage(event: Event) -> UsageFacts | None:
-    metadata = event.custom_metadata or {}
-    value = metadata.get("southwindUsage")
-    if not isinstance(value, dict):
-        return None
-    source = value.get("source")
-    cache_status = value.get("cacheStatus")
-    if source not in {"provider-reported", "estimated", "unknown"}:
-        return None
-    if cache_status not in {"hit", "miss", "unknown"}:
-        return None
-    return UsageFacts(
-        source=cast(UsageSource, source),
-        cache_status=cast(CacheStatus, cache_status),
-        input_tokens=measurement(value.get("inputTokens")),
-        output_tokens=measurement(value.get("outputTokens")),
-        cached_input_tokens=measurement(value.get("cachedInputTokens")),
-        reasoning_tokens=measurement(value.get("reasoningTokens")),
-        total_tokens=measurement(value.get("totalTokens")),
-        first_token_latency_ms=measurement(value.get("firstTokenLatencyMs")),
-    )
-
-
-def southwind_attempt_sequence(event: Event) -> int | None:
-    value = (event.custom_metadata or {}).get("southwindAttemptSequence")
-    return value if isinstance(value, int) and value > 0 else None
-
-
-def measurement(value: object) -> int | None:
-    return (
-        value
-        if isinstance(value, int) and not isinstance(value, bool) and value >= 0
-        else None
-    )
-
-
-async def merge_adk_events(
-    events: AsyncIterator[Event],
-    approval_queue: asyncio.Queue[EngineSignal],
-) -> AsyncIterator[Event | EngineSignal]:
-    iterator = events.__aiter__()
-    event_task: asyncio.Task[Event] = asyncio.create_task(next_event(iterator))
-    approval_task = asyncio.create_task(approval_queue.get())
-    try:
-        while True:
-            done, _ = await asyncio.wait(
-                {event_task, approval_task},
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-            if approval_task in done:
-                yield approval_task.result()
-                approval_task = asyncio.create_task(approval_queue.get())
-            if event_task in done:
-                try:
-                    yield event_task.result()
-                except StopAsyncIteration:
-                    while not approval_queue.empty():
-                        yield approval_queue.get_nowait()
-                    return
-                event_task = asyncio.create_task(next_event(iterator))
-    finally:
-        event_task.cancel()
-        approval_task.cancel()
-
-
-async def next_event(iterator: AsyncIterator[Event]) -> Event:
-    return await iterator.__anext__()

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

@@ -1,348 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-import uuid
-from collections.abc import AsyncIterator
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, cast
-
-import httpx
-
-from .config import normalize_base_url
-
-MAX_QUESTION_LENGTH = 4_000
-MAX_VISIBLE_EVENTS = 64
-MAX_EVENT_FRAME_BYTES = 64 * 1024
-DEFAULT_RESULT_POLL_TIMEOUT_SECONDS = 60.0
-DEFAULT_RESULT_POLL_INTERVAL_SECONDS = 0.5
-
-
-@dataclass(frozen=True)
-class TextOperationDebugConfig:
-    operation_key: str
-    data_actor_id: str | None = None
-
-
-def load_text_operation_debug_config(
-    path: str | Path | None = None,
-) -> TextOperationDebugConfig | None:
-    if path is None:
-        environment_key = os.environ.get("ADK_DEBUG_OPERATION_KEY", "").strip()
-        if environment_key:
-            return TextOperationDebugConfig(
-                operation_key=validate_operation_key(environment_key)
-            )
-    config_path = Path(path) if path else project_debug_config_path()
-    try:
-        value = json.loads(config_path.read_text(encoding="utf-8"))
-    except FileNotFoundError:
-        return None
-    except (OSError, UnicodeError, json.JSONDecodeError) as error:
-        raise RuntimeError("ADK Web 项目调试配置不可读") from error
-    if not isinstance(value, dict) or set(value) != {
-        "schemaVersion",
-        "textOperation",
-    }:
-        raise RuntimeError("ADK Web 项目调试配置格式无效")
-    schema_version = value.get("schemaVersion")
-    if (
-        not isinstance(schema_version, int)
-        or isinstance(schema_version, bool)
-        or schema_version != 1
-    ):
-        raise RuntimeError("ADK Web 项目调试配置版本不受支持")
-    operation = value.get("textOperation")
-    if operation is None:
-        return None
-    if not isinstance(operation, dict) or set(operation) != {
-        "key",
-        "dataActorId",
-    }:
-        raise RuntimeError("ADK Web 文本 Operation 配置格式无效")
-    return TextOperationDebugConfig(
-        operation_key=validate_identifier(
-            operation.get("key"), "ADK Web 文本 Operation Key 无效"
-        ),
-        data_actor_id=validate_identifier(
-            operation.get("dataActorId"), "ADK Web 真实开发数据用户无效"
-        ),
-    )
-
-
-def validate_operation_key(value: object) -> str:
-    return validate_identifier(value, "ADK Web 文本 Operation Key 无效")
-
-
-def validate_identifier(value: object, message: str) -> str:
-    if (
-        not isinstance(value, str)
-        or not value.strip()
-        or len(value) > 200
-        or any(character.isspace() for character in value)
-    ):
-        raise RuntimeError(message)
-    return value
-
-
-def project_debug_config_path() -> Path:
-    configured = os.environ.get("ADK_DEBUG_PROJECT_CONFIG", "").strip()
-    if configured:
-        return Path(configured)
-    return Path(__file__).resolve().parents[2] / "project" / "adk-web-debug.json"
-
-
-class CanonicalRunDebugClient:
-    def __init__(
-        self,
-        operation_key: str,
-        base_url: str,
-        bearer_token: str,
-        *,
-        transport: httpx.AsyncBaseTransport | None = None,
-        result_poll_timeout_seconds: float = DEFAULT_RESULT_POLL_TIMEOUT_SECONDS,
-        result_poll_interval_seconds: float = DEFAULT_RESULT_POLL_INTERVAL_SECONDS,
-    ) -> None:
-        self._operation_key = operation_key
-        self._base_url = normalize_base_url(base_url)
-        self._bearer_token = bearer_token.strip()
-        self._transport = transport
-        if not 0 <= result_poll_timeout_seconds <= 120:
-            raise ValueError("result_poll_timeout_seconds 必须在 0 到 120 秒之间")
-        if not 0 < result_poll_interval_seconds <= 1:
-            raise ValueError("result_poll_interval_seconds 必须大于 0 且不超过 1 秒")
-        self._result_poll_timeout_seconds = result_poll_timeout_seconds
-        self._result_poll_interval_seconds = result_poll_interval_seconds
-        if not self._bearer_token:
-            raise RuntimeError("ADK_DEBUG_PLATFORM_TOKEN 未配置，拒绝启动真实调试 Run")
-
-    @classmethod
-    def from_environment(
-        cls,
-        operation_key: str,
-    ) -> CanonicalRunDebugClient:
-        return cls(
-            operation_key,
-            os.environ.get("ADK_DEBUG_PLATFORM_URL", "http://server:9747"),
-            os.environ.get("ADK_DEBUG_PLATFORM_TOKEN", ""),
-        )
-
-    async def run(self, question: str) -> dict[str, object]:
-        prompt = question.strip()
-        if not prompt or len(prompt) > MAX_QUESTION_LENGTH:
-            raise RuntimeError("调试问题不能为空且最长 4000 字")
-        headers = {
-            "authorization": f"Bearer {self._bearer_token}",
-            "idempotency-key": f"adk-web-{uuid.uuid4()}",
-            "user-agent": "Windy-ADK-Web-Dev",
-        }
-        async with httpx.AsyncClient(
-            base_url=f"{self._base_url}/",
-            headers=headers,
-            timeout=httpx.Timeout(120),
-            transport=self._transport,
-        ) as client:
-            started = await client.post(
-                "api/agent/runs",
-                json={
-                    "operationKey": self._operation_key,
-                    "input": {"question": prompt},
-                },
-            )
-            run_id = read_run_id(started)
-            events = await collect_compact_events(self._events(client, run_id))
-            try:
-                async with asyncio.timeout(self._result_poll_timeout_seconds):
-                    while True:
-                        result = await client.get(
-                            f"api/agent/runs/{run_id}/result",
-                            params={"operationKey": self._operation_key},
-                        )
-                        if result.is_success:
-                            break
-                        try:
-                            error = result.json()
-                        except json.JSONDecodeError:
-                            error = None
-                        if (
-                            result.status_code != 409
-                            or not isinstance(error, dict)
-                            or error.get("code") != "RUN_CONFLICT"
-                            or error.get("retryable") is not True
-                        ):
-                            raise RuntimeError("平台 Agent Run 永久失败或结果读取失败")
-                        await asyncio.sleep(self._result_poll_interval_seconds)
-            except TimeoutError as error:
-                raise RuntimeError("平台 Agent Run 结果等待超时") from error
-        answer = read_text_output(result, run_id)
-        if not any(event.get("type") == "run.completed" for event in events):
-            events = [*events[: MAX_VISIBLE_EVENTS - 1], {"type": "run.completed"}]
-        return {
-            "runId": run_id,
-            "answer": answer,
-            "events": events,
-        }
-
-    async def _events(
-        self,
-        client: httpx.AsyncClient,
-        run_id: str,
-    ) -> AsyncIterator[dict[str, object]]:
-        async with client.stream(
-            "GET",
-            f"api/agent/runs/{run_id}/events",
-            params={"operationKey": self._operation_key, "after": 0},
-        ) as response:
-            if not response.is_success:
-                raise RuntimeError("平台 Agent Run 事件读取失败")
-            async for event in sse_events(response):
-                yield summarize_event(event)
-
-
-async def sse_events(response: httpx.Response) -> AsyncIterator[dict[str, object]]:
-    buffer = bytearray()
-    async for chunk in response.aiter_bytes(chunk_size=4096):
-        buffer.extend(chunk)
-        while separator := frame_separator(buffer):
-            index, width = separator
-            if index > MAX_EVENT_FRAME_BYTES:
-                raise RuntimeError("平台 Agent Run 单个事件超过调试上限")
-            frame = bytes(buffer[:index])
-            del buffer[: index + width]
-            event = parse_sse_frame(frame)
-            if event is not None:
-                yield event
-        if len(buffer) > MAX_EVENT_FRAME_BYTES:
-            raise RuntimeError("平台 Agent Run 单个事件超过调试上限")
-    if buffer:
-        event = parse_sse_frame(bytes(buffer))
-        if event is not None:
-            yield event
-
-
-def frame_separator(buffer: bytearray) -> tuple[int, int] | None:
-    candidates = [
-        (index, len(separator))
-        for separator in (b"\n\n", b"\r\n\r\n")
-        if (index := buffer.find(separator)) >= 0
-    ]
-    return min(candidates) if candidates else None
-
-
-def parse_sse_frame(frame: bytes) -> dict[str, object] | None:
-    try:
-        lines = frame.decode("utf-8").splitlines()
-    except UnicodeDecodeError as error:
-        raise RuntimeError("平台 Agent Run 事件格式无效") from error
-    event_name = "message"
-    data: list[str] = []
-    for line in lines:
-        if not line or line.startswith(":"):
-            continue
-        if line.startswith("event:"):
-            event_name = line.removeprefix("event:").strip()
-        elif line.startswith("data:"):
-            value = line.removeprefix("data:")
-            data.append(value[1:] if value.startswith(" ") else value)
-    return parse_event(event_name, "\n".join(data)) if data else None
-
-
-def parse_event(event_name: str, data: str) -> dict[str, object]:
-    try:
-        value = json.loads(data)
-    except json.JSONDecodeError as error:
-        raise RuntimeError("平台 Agent Run 事件格式无效") from error
-    if not isinstance(value, dict) or value.get("type") != event_name:
-        raise RuntimeError("平台 Agent Run 事件格式无效")
-    return cast(dict[str, object], value)
-
-
-def summarize_event(event: dict[str, object]) -> dict[str, object]:
-    fields = ("sequence", "type", "toolKey", "toolCallId", "workItemId", "outcome")
-    return {field: event[field] for field in fields if field in event}
-
-
-def compact_events(events: list[dict[str, object]]) -> list[dict[str, object]]:
-    compactor = EventCompactor()
-    for event in events:
-        compactor.add(event)
-    return compactor.finish()
-
-
-async def collect_compact_events(
-    events: AsyncIterator[dict[str, object]],
-) -> list[dict[str, object]]:
-    compactor = EventCompactor()
-    async for event in events:
-        compactor.add(event)
-    return compactor.finish()
-
-
-@dataclass
-class EventCompactor:
-    visible: list[dict[str, object]] | None = None
-    output_deltas: int = 0
-    hidden_events: int = 0
-
-    def add(self, event: dict[str, object]) -> None:
-        if event.get("type") == "output.delta":
-            self.output_deltas += 1
-            return
-        if self.visible is None:
-            self.visible = []
-        if len(self.visible) < MAX_VISIBLE_EVENTS:
-            self.visible.append(event)
-        else:
-            self.hidden_events += 1
-
-    def finish(self) -> list[dict[str, object]]:
-        visible = list(self.visible or [])
-        while True:
-            trailers = self._trailers()
-            if len(visible) + len(trailers) <= MAX_VISIBLE_EVENTS:
-                return [*visible, *trailers]
-            visible.pop()
-            self.hidden_events += 1
-
-    def _trailers(self) -> list[dict[str, object]]:
-        trailers: list[dict[str, object]] = []
-        if self.output_deltas:
-            trailers.append({"type": "output.delta", "count": self.output_deltas})
-        if self.hidden_events:
-            trailers.append({"type": "events.truncated", "count": self.hidden_events})
-        return trailers
-
-
-def read_run_id(response: httpx.Response) -> str:
-    value = response_json(response, "平台 Agent Run 启动失败")
-    run_id = value.get("runId")
-    if not isinstance(run_id, str) or not run_id:
-        raise RuntimeError("平台 Agent Run 启动响应无效")
-    return run_id
-
-
-def read_text_output(response: httpx.Response, expected_run_id: str) -> str:
-    value = response_json(response, "平台 Agent Run 未完成")
-    if value.get("runId") != expected_run_id or value.get("status") != "completed":
-        raise RuntimeError("平台 Agent Run 结果身份或状态无效")
-    output = value.get("output")
-    if not isinstance(output, dict):
-        raise RuntimeError("平台 Agent Run 输出不符合文本调试契约")
-    text = output.get("text")
-    if not isinstance(text, str):
-        raise RuntimeError("平台 Agent Run 输出不符合文本调试契约")
-    return text
-
-
-def response_json(response: httpx.Response, message: str) -> dict[str, Any]:
-    if not response.is_success:
-        raise RuntimeError(message)
-    try:
-        value = response.json()
-    except json.JSONDecodeError as error:
-        raise RuntimeError(message) from error
-    if not isinstance(value, dict):
-        raise RuntimeError(message)
-    return cast(dict[str, Any], value)