create-windy 0.6.11 → 0.6.14

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

@@ -1,325 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import re
-from datetime import datetime
-from typing import Literal, Protocol, cast, override
-
-import httpx
-from google.adk.events.event import Event
-from google.adk.sessions.base_session_service import (
-    BaseSessionService,
-    GetSessionConfig,
-    ListSessionsResponse,
-)
-from google.adk.sessions.in_memory_session_service import InMemorySessionService
-from google.adk.sessions.session import Session
-from google.genai import types
-from pydantic import BaseModel, ConfigDict, Field, ValidationError
-
-from .config import normalize_base_url
-
-CANONICAL_DEBUG_APP = "canonical_debug"
-CANONICAL_DEBUG_USER = "user"
-IMPORTED_SESSION_ID_PREFIX = "wdbg1_"
-IMPORTED_SESSION_ID_PATTERN = re.compile(r"^wdbg1_[A-Za-z0-9_-]{43}$")
-IMPORTED_SESSION_STATE_KEY = "__windy_debug_session_v1__"
-MAX_MESSAGES = 64
-MAX_TOTAL_MESSAGE_CHARS = 128_000
-logger = logging.getLogger(__name__)
-
-
-class ImportedDebugSessionReadOnlyError(RuntimeError):
-    pass
-
-
-class _StrictModel(BaseModel):
-    model_config = ConfigDict(extra="forbid", strict=True)
-
-
-class DebugSessionSummaryV1(_StrictModel):
-    id: str = Field(pattern=r"^wdbg1_[A-Za-z0-9_-]{43}$")
-    title: str = Field(min_length=1, max_length=200)
-    scopeLabel: str | None = Field(default=None, min_length=1, max_length=120)
-    updatedAt: str = Field(min_length=1, max_length=40)
-    revision: str = Field(min_length=1, max_length=200)
-
-
-class DebugSessionMessageV1(_StrictModel):
-    sequence: int = Field(ge=0)
-    role: Literal["user", "assistant"]
-    content: str = Field(min_length=1, max_length=16_000)
-    createdAt: str = Field(min_length=1, max_length=40)
-
-
-class DebugSessionDetailV1(DebugSessionSummaryV1):
-    messages: list[DebugSessionMessageV1] = Field(max_length=MAX_MESSAGES)
-
-
-class DebugSessionListEnvelopeV1(_StrictModel):
-    schemaVersion: Literal[1]
-    sessions: list[DebugSessionSummaryV1]
-    truncated: bool
-
-
-class DebugSessionDetailEnvelopeV1(_StrictModel):
-    schemaVersion: Literal[1]
-    session: DebugSessionDetailV1
-
-
-class DebugSessionClientPortV1(Protocol):
-    async def list(self) -> DebugSessionListEnvelopeV1: ...
-
-    async def get(self, session_id: str) -> DebugSessionDetailV1 | None: ...
-
-
-class WindyDebugSessionClientV1:
-    def __init__(
-        self,
-        base_url: str,
-        bearer_token: str,
-        *,
-        transport: httpx.AsyncBaseTransport | None = None,
-    ) -> None:
-        self._base_url = normalize_base_url(base_url)
-        self._bearer_token = bearer_token.strip()
-        self._transport = transport
-        if not self._bearer_token:
-            raise RuntimeError("ADK_DEBUG_PLATFORM_TOKEN 未配置，拒绝读取调试会话")
-
-    @classmethod
-    def from_environment(cls) -> WindyDebugSessionClientV1:
-        return cls(
-            os.environ.get("ADK_DEBUG_PLATFORM_URL", "http://server:9747"),
-            os.environ.get("ADK_DEBUG_PLATFORM_TOKEN", ""),
-        )
-
-    async def list(self) -> DebugSessionListEnvelopeV1:
-        value = await self._get("api/agent/debug/sessions/v1")
-        try:
-            envelope = DebugSessionListEnvelopeV1.model_validate(value)
-            for session in envelope.sessions:
-                parse_timestamp(session.updatedAt)
-            return envelope
-        except (ValidationError, ValueError) as error:
-            raise RuntimeError("平台调试会话列表响应无效") from error
-
-    async def get(self, session_id: str) -> DebugSessionDetailV1 | None:
-        if not IMPORTED_SESSION_ID_PATTERN.fullmatch(session_id):
-            raise RuntimeError("平台调试会话 ID 无效")
-        value = await self._get(
-            f"api/agent/debug/sessions/v1/{session_id}",
-            allow_not_found=True,
-        )
-        if value is None:
-            return None
-        try:
-            session = DebugSessionDetailEnvelopeV1.model_validate(value).session
-            validate_detail(session)
-            return session
-        except (ValidationError, ValueError) as error:
-            raise RuntimeError("平台调试会话详情响应无效") from error
-
-    async def _get(self, path: str, *, allow_not_found: bool = False) -> object | None:
-        headers = {
-            "authorization": f"Bearer {self._bearer_token}",
-            "user-agent": "Windy-ADK-Web-Dev",
-        }
-        async with httpx.AsyncClient(
-            base_url=f"{self._base_url}/",
-            headers=headers,
-            timeout=httpx.Timeout(15),
-            transport=self._transport,
-        ) as client:
-            response = await client.get(path)
-        if allow_not_found and response.status_code == 404:
-            return None
-        if not response.is_success:
-            raise RuntimeError("平台调试会话读取失败")
-        try:
-            return cast(object, response.json())
-        except ValueError as error:
-            raise RuntimeError("平台调试会话响应不是有效 JSON") from error
-
-
-class WindyDebugSessionServiceV1(BaseSessionService):
-    """Keep normal ADK sessions local and overlay live read-only projections."""
-
-    def __init__(
-        self,
-        client: DebugSessionClientPortV1,
-        local: InMemorySessionService | None = None,
-    ) -> None:
-        self._client = client
-        self._local = (
-            local if local is not None else InMemorySessionService()  # type: ignore[no-untyped-call]
-        )
-        self._deleted_imports: set[str] = set()
-
-    @override
-    async def create_session(
-        self,
-        *,
-        app_name: str,
-        user_id: str,
-        state: dict[str, object] | None = None,
-        session_id: str | None = None,
-    ) -> Session:
-        if session_id and session_id.startswith(IMPORTED_SESSION_ID_PREFIX):
-            raise ImportedDebugSessionReadOnlyError("导入的业务会话 ID 为只读保留值")
-        return await self._local.create_session(
-            app_name=app_name,
-            user_id=user_id,
-            state=state,
-            session_id=session_id,
-        )
-
-    @override
-    async def get_session(
-        self,
-        *,
-        app_name: str,
-        user_id: str,
-        session_id: str,
-        config: GetSessionConfig | None = None,
-    ) -> Session | None:
-        if not self._is_imported_request(app_name, user_id, session_id):
-            return await self._local.get_session(
-                app_name=app_name,
-                user_id=user_id,
-                session_id=session_id,
-                config=config,
-            )
-        if session_id in self._deleted_imports:
-            return None
-        detail = await self._client.get(session_id)
-        return project_detail(detail, config) if detail else None
-
-    @override
-    async def list_sessions(
-        self, *, app_name: str, user_id: str | None = None
-    ) -> ListSessionsResponse:
-        local = await self._local.list_sessions(app_name=app_name, user_id=user_id)
-        if app_name != CANONICAL_DEBUG_APP or user_id != CANONICAL_DEBUG_USER:
-            return local
-        try:
-            remote = await self._client.list()
-        except Exception:
-            # Discovery is best-effort; cancellation and other BaseException values
-            # still propagate instead of being mistaken for an offline platform.
-            logger.warning("平台调试会话不可用，仅返回本地 ADK 会话")
-            return local
-        imported = [
-            project_summary(session)
-            for session in remote.sessions
-            if session.id not in self._deleted_imports
-        ]
-        return ListSessionsResponse(sessions=[*local.sessions, *imported])
-
-    @override
-    async def delete_session(
-        self, *, app_name: str, user_id: str, session_id: str
-    ) -> None:
-        if self._is_imported_request(app_name, user_id, session_id):
-            self._deleted_imports.add(session_id)
-            return
-        await self._local.delete_session(
-            app_name=app_name, user_id=user_id, session_id=session_id
-        )
-
-    @override
-    async def append_event(self, session: Session, event: Event) -> Event:
-        if session.state.get(IMPORTED_SESSION_STATE_KEY) is True:
-            raise ImportedDebugSessionReadOnlyError(
-                "导入的业务会话是实时只读投影；请新建本地会话继续提问"
-            )
-        return await self._local.append_event(session=session, event=event)
-
-    @override
-    async def get_user_state(self, *, app_name: str, user_id: str) -> dict[str, object]:
-        return await self._local.get_user_state(app_name=app_name, user_id=user_id)
-
-    @staticmethod
-    def _is_imported_request(app_name: str, user_id: str, session_id: str) -> bool:
-        return (
-            app_name == CANONICAL_DEBUG_APP
-            and user_id == CANONICAL_DEBUG_USER
-            and IMPORTED_SESSION_ID_PATTERN.fullmatch(session_id) is not None
-        )
-
-
-def project_summary(value: DebugSessionSummaryV1) -> Session:
-    return Session(
-        id=value.id,
-        app_name=CANONICAL_DEBUG_APP,
-        user_id=CANONICAL_DEBUG_USER,
-        state=imported_state(value),
-        events=[],
-        last_update_time=parse_timestamp(value.updatedAt),
-    )
-
-
-def project_detail(
-    value: DebugSessionDetailV1,
-    config: GetSessionConfig | None,
-) -> Session:
-    events = [project_message(value.id, message) for message in value.messages]
-    if config and config.after_timestamp is not None:
-        events = [
-            event for event in events if event.timestamp >= config.after_timestamp
-        ]
-    if config and config.num_recent_events is not None:
-        events = (
-            [] if config.num_recent_events == 0 else events[-config.num_recent_events :]
-        )
-    return Session(
-        id=value.id,
-        app_name=CANONICAL_DEBUG_APP,
-        user_id=CANONICAL_DEBUG_USER,
-        state=imported_state(value),
-        events=events,
-        last_update_time=parse_timestamp(value.updatedAt),
-    )
-
-
-def project_message(session_id: str, value: DebugSessionMessageV1) -> Event:
-    role = "user" if value.role == "user" else "model"
-    return Event(
-        id=f"{session_id}-{value.sequence}",
-        invocation_id=f"{session_id}-projection",
-        author="user" if value.role == "user" else CANONICAL_DEBUG_APP,
-        content=types.Content(role=role, parts=[types.Part(text=value.content)]),
-        timestamp=parse_timestamp(value.createdAt),
-    )
-
-
-def imported_state(value: DebugSessionSummaryV1) -> dict[str, object]:
-    display_name = (
-        f"{value.title} · {value.scopeLabel}" if value.scopeLabel else value.title
-    )
-    return {
-        IMPORTED_SESSION_STATE_KEY: True,
-        "__session_metadata__": {"displayName": display_name},
-    }
-
-
-def validate_detail(value: DebugSessionDetailV1) -> None:
-    parse_timestamp(value.updatedAt)
-    total_chars = 0
-    previous_sequence = -1
-    for message in value.messages:
-        parse_timestamp(message.createdAt)
-        if message.sequence <= previous_sequence:
-            raise ValueError("调试会话消息顺序无效")
-        previous_sequence = message.sequence
-        total_chars += len(message.content)
-    if total_chars > MAX_TOTAL_MESSAGE_CHARS:
-        raise ValueError("调试会话消息总量超过上限")
-
-
-def parse_timestamp(value: str) -> float:
-    parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    if parsed.tzinfo is None:
-        raise ValueError("调试会话时间必须包含时区")
-    return parsed.timestamp()

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

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from .engine import SafeEngineError
-
-
-@dataclass
-class AdkFailureState:
-    failure: SafeEngineError | None = None
-
-    def capture(self, error: SafeEngineError) -> None:
-        self.failure = error

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

@@ -1,304 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-from collections.abc import AsyncGenerator
-
-from google.adk.models.base_llm import BaseLlm
-from google.adk.models.llm_request import LlmRequest
-from google.adk.models.llm_response import LlmResponse
-from google.genai import types
-from pydantic import PrivateAttr
-
-from .adk_failure import AdkFailureState
-from .contracts import JsonValue
-from .engine import EngineRunRequest, SafeEngineError
-from .multimodal import attach_artifacts
-from .openai_engine_validation import (
-    attempt_outcome,
-    cancelled,
-    parse_arguments,
-)
-from .openai_provider import OpenAiCompatibleProvider, ProviderTurn
-from .provider_governance import ProviderRequestGovernance
-from .report_lifecycle import (
-    finish_attempt_report_safely,
-    start_attempt_report_safely,
-)
-from .report_store import (
-    AgentRuntimeReportStore,
-    InMemoryAgentRuntimeReportStore,
-)
-from .report_types import UsageFacts
-
-
-class GovernedOpenAiLlm(BaseLlm):
-    """ADK model bridge that preserves Southwind's provider governance."""
-
-    _request: EngineRunRequest = PrivateAttr()
-    _provider: OpenAiCompatibleProvider = PrivateAttr()
-    _governance: ProviderRequestGovernance = PrivateAttr()
-    _cancellation: asyncio.Event = PrivateAttr()
-    _failures: AdkFailureState = PrivateAttr()
-    _report_store: AgentRuntimeReportStore = PrivateAttr()
-    _attempt: int = PrivateAttr(default=0)
-
-    def __init__(
-        self,
-        request: EngineRunRequest,
-        provider: OpenAiCompatibleProvider,
-        governance: ProviderRequestGovernance,
-        cancellation: asyncio.Event,
-        failures: AdkFailureState,
-        report_store: AgentRuntimeReportStore | None = None,
-    ) -> None:
-        super().__init__(model=provider.config.model)
-        self._request = request
-        self._provider = provider
-        self._governance = governance
-        self._cancellation = cancellation
-        self._failures = failures
-        self._report_store = report_store or InMemoryAgentRuntimeReportStore()
-
-    async def generate_content_async(
-        self,
-        llm_request: LlmRequest,
-        stream: bool = False,
-    ) -> AsyncGenerator[LlmResponse, None]:
-        del stream
-        report_attempt = None
-        finalized = False
-        turn: ProviderTurn | None = None
-        try:
-            cancelled(self._cancellation)
-            self._attempt += 1
-            if self._attempt > self._provider.config.max_tool_rounds:
-                raise SafeEngineError(
-                    "BUDGET_EXCEEDED",
-                    "Agent Tool 调用轮次超过上限",
-                    retryable=False,
-                )
-            report_attempt = await start_attempt_report_safely(
-                self._report_store,
-                self._request.run_id,
-                self._attempt,
-                self._provider.config.deployment_key,
-                self._provider.config.model,
-            )
-            attempt_sequence = (
-                report_attempt.sequence if report_attempt else self._attempt
-            )
-            messages = attach_artifacts(
-                adk_messages(llm_request, self._request.instructions),
-                self._request.artifacts,
-            )
-            governed = self._governance.authorize(
-                deployment_key=self._provider.config.deployment_key,
-                operation_key=self._request.operation_key,
-                run_id=self._request.run_id,
-                attempt=attempt_sequence,
-                messages=messages,
-                tools=self._request.allowed_tools,
-                policy=self._request.provider_data_policy,
-                input_value=self._request.input,
-                artifact_bytes=sum(
-                    artifact.byte_size for artifact in self._request.artifacts
-                ),
-                output_schema=self._request.output_schema,
-                measure=lambda values, tools, schema: len(
-                    self._provider.request_body(
-                        values,
-                        tools,
-                        self._request.output_schema_key,
-                        schema,
-                    )
-                ),
-            )
-            turn = await self._provider.complete_turn(
-                governed.messages,
-                governed.tools,
-                self._request.output_schema_key,
-                governed.output_schema,
-            )
-            cancelled(self._cancellation)
-            validate_tool_calls(
-                turn,
-                {tool.key for tool in self._request.allowed_tools},
-            )
-            await finish_attempt_report_safely(
-                self._report_store,
-                report_attempt,
-                "completed",
-                turn.usage,
-                reported_model=turn.reported_model,
-            )
-            finalized = True
-            async for response in responses_for_turn(
-                turn,
-                attempt_sequence,
-            ):
-                yield response
-        except SafeEngineError as error:
-            if not finalized:
-                await finish_attempt_report_safely(
-                    self._report_store,
-                    report_attempt,
-                    attempt_outcome(error),
-                    turn.usage if turn else UsageFacts(),
-                    reported_model=turn.reported_model if turn else None,
-                    safe_error_code=error.code,
-                )
-            self._failures.capture(error)
-            raise
-        except Exception:
-            if not finalized:
-                await finish_attempt_report_safely(
-                    self._report_store,
-                    report_attempt,
-                    "failed",
-                    turn.usage if turn else UsageFacts(),
-                    reported_model=turn.reported_model if turn else None,
-                    safe_error_code="RUNTIME_UNAVAILABLE",
-                )
-            raise
-
-
-def adk_messages(
-    request: LlmRequest,
-    instructions: str,
-) -> list[dict[str, JsonValue]]:
-    result: list[dict[str, JsonValue]] = [{"role": "system", "content": instructions}]
-    for content in request.contents:
-        parts = content.parts or []
-        calls = [part.function_call for part in parts if part.function_call]
-        responses = [part.function_response for part in parts if part.function_response]
-        text = "".join(
-            part.text or "" for part in parts if not part.thought and part.text
-        )
-        if calls:
-            result.append(
-                {
-                    "role": "assistant",
-                    "content": text or None,
-                    "tool_calls": [
-                        {
-                            "id": call.id or "",
-                            "type": "function",
-                            "function": {
-                                "name": call.name or "",
-                                "arguments": json.dumps(
-                                    call.args or {},
-                                    ensure_ascii=False,
-                                    separators=(",", ":"),
-                                ),
-                            },
-                        }
-                        for call in calls
-                    ],
-                }
-            )
-        elif responses:
-            result.extend(tool_response_messages(responses))
-        elif text:
-            result.append(
-                {
-                    "role": "assistant" if content.role == "model" else "user",
-                    "content": text,
-                }
-            )
-    return result
-
-
-def tool_response_messages(
-    responses: list[types.FunctionResponse],
-) -> list[dict[str, JsonValue]]:
-    return [
-        {
-            "role": "tool",
-            "tool_call_id": response.id or "",
-            "content": json.dumps(
-                response.response or {},
-                ensure_ascii=False,
-                separators=(",", ":"),
-            ),
-        }
-        for response in responses
-    ]
-
-
-def validate_tool_calls(turn: ProviderTurn, allowed: set[str]) -> None:
-    for call in turn.tool_calls:
-        if not call.call_id or not call.name or call.name not in allowed:
-            raise SafeEngineError(
-                "TOOL_DENIED",
-                "模型请求了未授权 Tool",
-                retryable=False,
-            )
-        parse_arguments(call.arguments)
-
-
-async def responses_for_turn(
-    turn: ProviderTurn,
-    attempt_sequence: int,
-) -> AsyncGenerator[LlmResponse, None]:
-    usage = turn.usage.event_value()
-    metadata = {
-        "southwindUsage": usage,
-        "southwindAttemptSequence": attempt_sequence,
-    }
-    if turn.tool_calls:
-        yield LlmResponse(
-            content=types.Content(
-                role="model",
-                parts=[
-                    types.Part(
-                        function_call=types.FunctionCall(
-                            id=call.call_id,
-                            name=call.name,
-                            args=parse_arguments(call.arguments),
-                        )
-                    )
-                    for call in turn.tool_calls
-                ],
-            ),
-            partial=False,
-            custom_metadata=metadata,
-            usage_metadata=adk_usage(usage),
-        )
-        return
-    for delta in turn.text_deltas:
-        yield LlmResponse(
-            content=types.Content(
-                role="model",
-                parts=[types.Part(text=delta)],
-            ),
-            partial=True,
-        )
-    yield LlmResponse(
-        content=types.Content(
-            role="model",
-            parts=[types.Part(text=turn.text)],
-        ),
-        partial=False,
-        custom_metadata=metadata,
-        usage_metadata=adk_usage(usage),
-    )
-
-
-def adk_usage(
-    usage: dict[str, str | int],
-) -> types.GenerateContentResponseUsageMetadata | None:
-    input_tokens = usage.get("inputTokens")
-    output_tokens = usage.get("outputTokens")
-    total_tokens = usage.get("totalTokens")
-    if not any(
-        isinstance(value, int) for value in (input_tokens, output_tokens, total_tokens)
-    ):
-        return None
-    return types.GenerateContentResponseUsageMetadata(
-        prompt_token_count=input_tokens if isinstance(input_tokens, int) else None,
-        candidates_token_count=(
-            output_tokens if isinstance(output_tokens, int) else None
-        ),
-        total_token_count=total_tokens if isinstance(total_tokens, int) else None,
-    )