create-windy 0.8.2 → 0.9.1

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

@@ -1,134 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-from dataclasses import dataclass, field
-from typing import Protocol
-
-from .contracts import (
-    AgentErrorCode,
-    JsonValue,
-    LongSessionContext,
-    ModelCoordinatePin,
-    ProviderDataPolicy,
-    ProviderEgress,
-    RuntimeLimits,
-    RuntimeToolDefinition,
-    ToolNetworkPolicy,
-)
-from .report_types import UsageFacts
-
-
-@dataclass(frozen=True)
-class PreparedArtifact:
-    media_type: str
-    data_url: str
-    byte_size: int
-    sha256: str
-
-
-@dataclass(frozen=True)
-class EngineRunRequest:
-    run_id: str
-    operation_key: str
-    input: JsonValue
-    input_modalities: tuple[str, ...] = ("text",)
-    required_capabilities: tuple[str, ...] = ()
-    artifacts: tuple[PreparedArtifact, ...] = ()
-    instructions: str = ""
-    user_prompt: str = ""
-    output_schema_key: str = ""
-    output_schema: dict[str, JsonValue] | None = None
-    allowed_tools: tuple[RuntimeToolDefinition, ...] = ()
-    limits: RuntimeLimits = field(default_factory=RuntimeLimits)
-    provider_egress: ProviderEgress = field(default_factory=ProviderEgress)
-    provider_data_policy: ProviderDataPolicy = field(default_factory=ProviderDataPolicy)
-    tool_network_policy: ToolNetworkPolicy = field(default_factory=ToolNetworkPolicy)
-    model_pin: ModelCoordinatePin | None = None
-    execution_grant: str = ""
-    tool_host_url: str = ""
-    long_session: LongSessionContext | None = None
-    prompt_version: str = "legacy"
-
-
-@dataclass(frozen=True)
-class OutputDelta:
-    text: str
-
-
-@dataclass(frozen=True)
-class ToolRequested:
-    tool_call_id: str
-    tool_key: str
-
-
-@dataclass(frozen=True)
-class ApprovalRequired:
-    work_item_id: str
-    tool_call_id: str
-
-
-@dataclass(frozen=True)
-class ApprovalResolved:
-    work_item_id: str
-    tool_call_id: str
-    outcome: str
-
-
-@dataclass(frozen=True)
-class ToolCompleted:
-    tool_call_id: str
-
-
-@dataclass(frozen=True)
-class UsageReported:
-    attempt_sequence: int
-    usage: UsageFacts
-
-
-@dataclass(frozen=True)
-class EngineCompleted:
-    output: JsonValue
-
-
-type EngineSignal = (
-    OutputDelta
-    | ToolRequested
-    | ApprovalRequired
-    | ApprovalResolved
-    | ToolCompleted
-    | UsageReported
-    | EngineCompleted
-)
-
-
-class SafeEngineError(Exception):
-    def __init__(
-        self,
-        code: AgentErrorCode,
-        message: str,
-        *,
-        retryable: bool,
-    ) -> None:
-        super().__init__(message)
-        self.code = code
-        self.safe_message = message
-        self.retryable = retryable
-
-
-class AgentEngineAdapter(Protocol):
-    """Internal engine seam. HTTP DTO and engine-private types must not cross it."""
-
-    @property
-    def engine_id(self) -> str: ...
-
-    def supports(self, operation_key: str) -> bool: ...
-
-    @property
-    def capabilities(self) -> tuple[str, ...]: ...
-
-    @property
-    def input_modalities(self) -> tuple[str, ...]: ...
-
-    def execute(self, request: EngineRunRequest) -> AsyncIterator[EngineSignal]: ...
-
-    async def cancel(self, run_id: str) -> None: ...

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

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Protocol, runtime_checkable
-
-from .engine import AgentEngineAdapter
-
-
-@dataclass(frozen=True)
-class EngineCapacity:
-    max_concurrent_runs: int
-    max_queue_depth: int
-
-
-@runtime_checkable
-class ResourceLimitedEngine(Protocol):
-    @property
-    def max_concurrent_runs(self) -> int: ...
-
-    @property
-    def max_queue_depth(self) -> int: ...
-
-
-def engine_capacity(engine: AgentEngineAdapter) -> EngineCapacity:
-    if not isinstance(engine, ResourceLimitedEngine):
-        return EngineCapacity(1, 0)
-    concurrent = engine.max_concurrent_runs
-    queued = engine.max_queue_depth
-    if concurrent < 1 or queued < 0:
-        raise ValueError("Agent Engine 容量声明无效")
-    return EngineCapacity(concurrent, queued)

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

@@ -1,2 +0,0 @@
-DIRECT_ENGINE_ID = "windy.direct.openai-compatible.v1"
-HISTORICAL_ADK_ENGINE_ID = "google.adk.v2"

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

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-from typing import cast
-
-from .contracts import JsonValue, StartRunRequest
-
-
-def resolved_release(request: StartRunRequest) -> dict[str, JsonValue]:
-    release = cast(dict[str, JsonValue], request.release.model_dump(by_alias=True))
-    if release["releaseId"] == "legacy":
-        operation_digest = hashlib.sha256(request.operation_key.encode()).hexdigest()
-        release["releaseId"] = f"legacy_{operation_digest[:40]}"
-    return release
-
-
-def request_fingerprint(request: StartRunRequest) -> str:
-    encoded = json.dumps(
-        {
-            "operationKey": request.operation_key,
-            "input": request.input,
-            "artifacts": [
-                {
-                    "sha256": artifact.sha256,
-                    "mediaType": artifact.media_type,
-                    "byteSize": artifact.byte_size,
-                }
-                for artifact in request.artifacts
-            ],
-            "requiredCapabilities": sorted(request.required_capabilities),
-            "inputModalities": sorted(request.input_modalities),
-            "outputSchemaKey": request.output_schema_key,
-            "outputSchema": request.output_schema,
-            "release": resolved_release(request),
-            "readinessPin": (
-                request.readiness_pin.model_dump(by_alias=True)
-                if request.readiness_pin
-                else None
-            ),
-            "modelPin": (
-                request.model_pin.model_dump(by_alias=True)
-                if request.model_pin
-                else None
-            ),
-            "limits": request.limits.model_dump(by_alias=True),
-            "allowedTools": [
-                tool.model_dump(by_alias=True) for tool in request.allowed_tools
-            ],
-            "providerEgress": request.provider_egress.model_dump(by_alias=True),
-            "providerDataPolicy": request.provider_data_policy.model_dump(
-                by_alias=True
-            ),
-            "toolNetworkPolicy": request.tool_network_policy.model_dump(by_alias=True),
-            "executionGrant": request.execution_grant,
-        },
-        ensure_ascii=False,
-        separators=(",", ":"),
-        sort_keys=True,
-    ).encode()
-    return hashlib.sha256(encoded).hexdigest()

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

@@ -1,93 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Annotated, cast
-
-from fastapi import FastAPI, Header
-from fastapi.responses import JSONResponse
-
-from .http_helpers import authorized, safe_error
-from .runtime_compatibility import COMPATIBILITY_PATH, runtime_compatibility_offer
-from .service import AgentRunService
-from .vlm_readiness import unavailable_vlm_snapshot
-
-
-def install_health_routes(
-    application: FastAPI,
-    runtime: AgentRunService,
-    engine: object,
-    internal_token: str | None,
-) -> None:
-    @application.get("/health/live")
-    async def live() -> dict[str, str]:
-        return {"status": "live"}
-
-    @application.get("/health/ready", response_model=None)
-    async def ready() -> dict[str, object] | JSONResponse:
-        try:
-            await runtime.probe()
-            return {"status": "ready"}
-        except Exception:
-            return safe_error(
-                503,
-                "RUNTIME_UNAVAILABLE",
-                "Agent Run 存储暂不可用",
-                True,
-            )
-
-    @application.get("/health/vlm-ready", response_model=None)
-    async def vlm_ready() -> dict[str, object] | JSONResponse:
-        readiness = getattr(engine, "readiness", None)
-        if not readiness:
-            return JSONResponse(
-                unavailable_vlm_snapshot(configured=False), status_code=503
-            )
-        try:
-            await runtime.probe()
-            snapshot = await readiness()
-            status = 200 if snapshot.get("status") == "ready" else 503
-            return JSONResponse(snapshot, status_code=status)
-        except Exception:
-            return JSONResponse(
-                unavailable_vlm_snapshot(
-                    configured=True,
-                    failure_code="CONNECTION_FAILED",
-                ),
-                status_code=503,
-            )
-
-    @application.get("/health/model-coordinate", response_model=None)
-    async def model_coordinate(
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> dict[str, str] | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        coordinate = cast(
-            Callable[[], dict[str, str]] | None,
-            getattr(engine, "model_coordinate", None),
-        )
-        if coordinate is None:
-            return safe_error(
-                503,
-                "MODEL_ROUTE_UNAVAILABLE",
-                "Agent Runtime Model coordinate 不可用",
-                True,
-            )
-        try:
-            await runtime.probe()
-            return coordinate()
-        except Exception:
-            return safe_error(
-                503,
-                "MODEL_ROUTE_UNAVAILABLE",
-                "Agent Runtime Model coordinate 不可用",
-                True,
-            )
-
-    @application.get(COMPATIBILITY_PATH, response_model=None)
-    async def runtime_compatibility(
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> dict[str, object] | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        return runtime_compatibility_offer(runtime.engine.engine_id)

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

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import hmac
-import uuid
-
-from fastapi.responses import JSONResponse
-
-from .contracts import AgentError
-
-
-def provider_governance_snapshot(
-    value: dict[str, int | float | str | None],
-) -> dict[str, int | float | str | None]:
-    allowed = (
-        "status",
-        "retentionDays",
-        "retainedRecords",
-        "rejectedAttempts",
-        "redactedAttempts",
-        "lastAttemptAt",
-        "lastPurgeAt",
-        "lastDeletedRecords",
-        "totalDeletedRecords",
-    )
-    return {key: value.get(key) for key in allowed}
-
-
-def authorized(provided: str | None, expected: str | None) -> bool:
-    if expected is None:
-        return True
-    if not expected or not provided or not provided.startswith("Bearer "):
-        return False
-    return hmac.compare_digest(provided.removeprefix("Bearer "), expected)
-
-
-def parse_cursor(after: int | None, last_event_id: str | None) -> int:
-    header_cursor = 0
-    if last_event_id is not None:
-        if not last_event_id.isdigit():
-            raise ValueError
-        header_cursor = int(last_event_id)
-    return max(after or 0, header_cursor)
-
-
-def safe_error(
-    status_code: int,
-    code: str,
-    message: str,
-    retryable: bool,
-) -> JSONResponse:
-    error = AgentError.model_validate(
-        {
-            "code": code,
-            "message": message,
-            "requestId": f"request_{uuid.uuid4().hex}",
-            "retryable": retryable,
-        }
-    )
-    return JSONResponse(
-        status_code=status_code,
-        content=error.model_dump(by_alias=True),
-    )

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

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-
-
-def lease_failed(task: asyncio.Task[None]) -> bool:
-    return task.done() and not task.cancelled() and task.exception() is not None
-
-
-def cancel_on_lease_loss(
-    lease_task: asyncio.Task[None],
-    execution_task: asyncio.Task[None],
-) -> None:
-    if lease_failed(lease_task):
-        execution_task.cancel()

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

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-
-from jsonschema import SchemaError, ValidationError, validate
-
-from .contracts import JsonValue
-from .engine import PreparedArtifact, SafeEngineError
-
-
-def attach_artifacts(
-    messages: list[dict[str, JsonValue]],
-    artifacts: tuple[PreparedArtifact, ...],
-) -> list[dict[str, JsonValue]]:
-    if not artifacts:
-        return messages
-    result = [dict(message) for message in messages]
-    for message in result:
-        if message.get("role") != "user":
-            continue
-        text = message.get("content")
-        if not isinstance(text, str):
-            raise invalid("Agent Vision 用户消息结构无效")
-        parts: list[JsonValue] = [{"type": "text", "text": text}]
-        parts.extend(
-            {
-                "type": "image_url",
-                "image_url": {"url": artifact.data_url, "detail": "auto"},
-            }
-            for artifact in artifacts
-        )
-        message["content"] = parts
-        return result
-    raise invalid("Agent Vision 缺少用户消息")
-
-
-def response_format(
-    output_schema_key: str,
-    output_schema: dict[str, JsonValue] | None,
-) -> JsonValue | None:
-    if output_schema is None:
-        return None
-    name = re.sub(r"[^a-zA-Z0-9_-]", "_", output_schema_key)[:64]
-    if not name:
-        raise invalid("结构化输出 Schema Key 无效")
-    return {
-        "type": "json_schema",
-        "json_schema": {
-            "name": name,
-            "strict": True,
-            "schema": output_schema,
-        },
-    }
-
-
-def final_output(
-    text: str,
-    output_schema: dict[str, JsonValue] | None,
-) -> JsonValue:
-    if output_schema is None:
-        return {"text": text}
-    try:
-        value: JsonValue = json.loads(text)
-        validate(instance=value, schema=output_schema)
-        return value
-    except (json.JSONDecodeError, SchemaError, ValidationError):
-        raise SafeEngineError(
-            "OUTPUT_VALIDATION_FAILED",
-            "模型结构化输出不符合 Operation Schema",
-            retryable=False,
-        ) from None
-
-
-def invalid(message: str) -> SafeEngineError:
-    return SafeEngineError("INVALID_INPUT", message, retryable=False)