create-windy 0.8.2 → 0.9.1

package/template/apps/agent-server/install-python-dependencies.sh

@@ -1,92 +0,0 @@
-#!/bin/sh
-set -eu
-
-index_url="${WINDY_PYPI_INDEX_URL:-}"
-total_timeout_seconds="${WINDY_PYPI_TOTAL_TIMEOUT_SECONDS:-}"
-
-case "$index_url" in
-  http://* | https://*) ;;
-  *)
-    echo "Agent Server Python index 必须是 credential-free HTTP(S) URL" >&2
-    exit 64
-    ;;
-esac
-case "$index_url" in
-  *"@"* | *"?"* | *"#"*)
-    echo "Agent Server Python index 不得内嵌 credential、query 或 fragment" >&2
-    exit 64
-    ;;
-esac
-
-index_address="${index_url#*://}"
-index_host="${index_address%%/*}"
-case "$index_address" in
-  "" | *[!A-Za-z0-9._~:/%-]*)
-    echo "Agent Server Python index 含有不安全字符" >&2
-    exit 64
-    ;;
-esac
-case "$index_host" in
-  "" | *[!A-Za-z0-9.:-]*)
-    echo "Agent Server Python index host 无效" >&2
-    exit 64
-    ;;
-esac
-case "$total_timeout_seconds" in
-  "" | *[!0-9]*)
-    echo "WINDY_PYPI_TOTAL_TIMEOUT_SECONDS 必须是 1 到 600 的整数" >&2
-    exit 64
-    ;;
-esac
-if [ "$total_timeout_seconds" -lt 1 ] || [ "$total_timeout_seconds" -gt 600 ]; then
-  echo "WINDY_PYPI_TOTAL_TIMEOUT_SECONDS 必须是 1 到 600 的整数" >&2
-  exit 64
-fi
-
-trusted_host=""
-insecure_host=""
-case "$index_url" in
-  http://*)
-    trusted_host="$index_host"
-    insecure_host="$index_host"
-    ;;
-esac
-
-run_uv_network() {
-  operation="$1"
-  shift
-  if ! timeout --kill-after=5s "${total_timeout_seconds}s" env \
-    UV_DEFAULT_INDEX="$index_url" \
-    UV_INSECURE_HOST="$insecure_host" \
-    UV_CONCURRENT_DOWNLOADS=1 \
-    UV_HTTP_TIMEOUT=30 \
-    UV_HTTP_RETRIES=2 \
-    UV_NO_PROGRESS=1 \
-    sh -c 'attempt=1; while [ "$attempt" -le 3 ]; do "$@" && exit 0; if [ "$attempt" -lt 3 ]; then echo "[windy] Python 网络操作失败，2 秒后重试" >&2; sleep 2; fi; attempt=$((attempt + 1)); done; exit 1' windy-python "$@"; then
-    echo "Agent Server Python index 不可用或总时限已到：${operation}失败" >&2
-    exit 70
-  fi
-}
-
-case "${1:-}" in
-  install-uv)
-    if ! timeout --kill-after=5s "${total_timeout_seconds}s" env \
-      PIP_INDEX_URL="$index_url" \
-      PIP_TRUSTED_HOST="$trusted_host" \
-      pip install --no-cache-dir --timeout 30 --retries 2 uv==0.9.27; then
-      echo "Agent Server Python index 不可用或总时限已到：无法安装 uv" >&2
-      exit 70
-    fi
-    ;;
-  lock)
-    run_uv_network "lock index 刷新" uv lock
-    ;;
-  sync)
-    shift
-    run_uv_network "依赖同步" uv sync "$@"
-    ;;
-  *)
-    echo "未知的 Agent Server Python 安装阶段" >&2
-    exit 64
-    ;;
-esac

package/template/apps/agent-server/pyproject.toml

@@ -1,51 +0,0 @@
-[project]
-name = "southwind-agent-server"
-version = "0.1.0"
-description = "Southwind AI canonical Agent Runtime server"
-requires-python = ">=3.12,<3.13"
-dependencies = [
-  "cryptography==49.0.0",
-  "fastapi==0.139.2",
-  "httpx==0.28.1",
-  "jsonschema==4.26.0",
-  "opentelemetry-api==1.42.1",
-  "opentelemetry-exporter-otlp-proto-http==1.42.1",
-  "opentelemetry-sdk==1.42.1",
-  "pillow==12.3.0",
-  "psycopg[binary,pool]==3.3.4",
-  "pydantic==2.13.4",
-  "uvicorn==0.51.0",
-]
-
-[dependency-groups]
-dev = [
-  "mypy==2.3.0",
-  "pytest==9.1.1",
-  "pytest-asyncio==1.4.0",
-  "ruff==0.15.22",
-  "types-jsonschema==4.26.0.20260518",
-]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-pythonpath = [".", "src"]
-testpaths = ["tests"]
-
-[tool.ruff]
-line-length = 88
-target-version = "py312"
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "UP", "B", "ASYNC"]
-
-[tool.mypy]
-python_version = "3.12"
-strict = true
-files = ["src", "tests"]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/southwind_agent_server"]

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

@@ -1,5 +0,0 @@
-"""Southwind AI Agent Server."""
-
-from .app import create_app
-
-__all__ = ["create_app"]

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

@@ -1,344 +0,0 @@
-from __future__ import annotations
-
-import os
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from typing import Annotated, cast
-
-from fastapi import FastAPI, Header, Query, Request
-from fastapi.exceptions import RequestValidationError
-from fastapi.responses import JSONResponse, StreamingResponse
-from pydantic import ValidationError
-
-from .artifact_input import ArtifactLoader
-from .client_completion_routes import install_client_completion_routes
-from .contracts import (
-    CancelRunRequest,
-    CancelRunResponse,
-    EvaluationResultRequest,
-    EvaluationResultResponse,
-    JsonValue,
-    RunResultResponse,
-    RunStatusResponse,
-    StartRunRequest,
-    StartRunResponse,
-)
-from .engine import AgentEngineAdapter, SafeEngineError
-from .engine_capacity import engine_capacity
-from .health_routes import install_health_routes
-from .http_helpers import (
-    authorized,
-    parse_cursor,
-    provider_governance_snapshot,
-    safe_error,
-)
-from .report_routes import create_report_router
-from .report_store import AgentRuntimeReportStore
-from .runtime_compatibility import (
-    OFFER_DIGEST_HEADER,
-    PROTOCOL_HEADER,
-    RuntimeCompatibilityError,
-    validate_runtime_compatibility_pin,
-)
-from .runtime_factory import (
-    default_engine,
-    default_report_store,
-    default_store,
-)
-from .service import AgentRunService
-from .service_errors import OperationNotFoundError, RunNotFoundError
-from .sqlite_store import RunStoreCapacityError
-from .sse import event_stream
-from .store import IdempotencyConflictError, ReleaseNotFoundError, RunStore
-from .telemetry import configure_telemetry
-from .vision_requirement import require_vision_readiness
-
-
-def create_app(
-    engine: AgentEngineAdapter | None = None,
-    *,
-    heartbeat_seconds: float = 15.0,
-    internal_token: str | None = None,
-    store: RunStore | None = None,
-    report_store: AgentRuntimeReportStore | None = None,
-) -> FastAPI:
-    configure_telemetry()
-    runtime_report_store = report_store or default_report_store()
-    runtime_engine = engine or default_engine(runtime_report_store)
-    capacity = engine_capacity(runtime_engine)
-    runtime = AgentRunService(
-        runtime_engine,
-        store or default_store(),
-        runtime_report_store,
-        (
-            ArtifactLoader(
-                os.environ.get(
-                    "AI_ARTIFACT_URL",
-                    "http://server:9747/api/internal/ai/artifacts",
-                ),
-                internal_token,
-            )
-            if internal_token
-            else None
-        ),
-        max_concurrent_runs=capacity.max_concurrent_runs,
-        max_queue_depth=capacity.max_queue_depth,
-    )
-
-    @asynccontextmanager
-    async def lifespan(_application: FastAPI) -> AsyncIterator[None]:
-        await runtime.recover()
-        try:
-            yield
-        finally:
-            await runtime.close()
-
-    application = FastAPI(
-        title="Southwind AI Agent Server",
-        version="0.1.0",
-        lifespan=lifespan,
-    )
-    application.include_router(
-        create_report_router(runtime_report_store, runtime.store, internal_token)
-    )
-
-    install_health_routes(application, runtime, runtime_engine, internal_token)
-    install_client_completion_routes(application, runtime_engine, internal_token)
-
-    @application.get("/health/provider-governance", response_model=None)
-    async def provider_governance_health(
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> dict[str, int | float | str | None] | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        health = getattr(runtime_engine, "governance_health", None)
-        if not health:
-            return safe_error(
-                503,
-                "RUNTIME_UNAVAILABLE",
-                "Provider 字段治理尚未配置",
-                True,
-            )
-        return provider_governance_snapshot(
-            cast(dict[str, int | float | str | None], health())
-        )
-
-    @application.exception_handler(OperationNotFoundError)
-    async def operation_not_found(
-        _request: Request,
-        _error: OperationNotFoundError,
-    ) -> JSONResponse:
-        return safe_error(404, "OPERATION_NOT_FOUND", "Agent Operation 不存在", False)
-
-    @application.exception_handler(RunNotFoundError)
-    async def run_not_found(
-        _request: Request,
-        _error: RunNotFoundError,
-    ) -> JSONResponse:
-        return safe_error(404, "RUN_CONFLICT", "Agent Run 不存在", False)
-
-    @application.exception_handler(IdempotencyConflictError)
-    async def idempotency_conflict(
-        _request: Request,
-        _error: IdempotencyConflictError,
-    ) -> JSONResponse:
-        return safe_error(409, "RUN_CONFLICT", "幂等键已用于其他请求", False)
-
-    @application.exception_handler(ReleaseNotFoundError)
-    async def release_not_found(
-        _request: Request,
-        _error: ReleaseNotFoundError,
-    ) -> JSONResponse:
-        return safe_error(404, "RUN_CONFLICT", "Agent Release 不存在", False)
-
-    @application.exception_handler(RunStoreCapacityError)
-    async def run_store_capacity(
-        _request: Request,
-        _error: RunStoreCapacityError,
-    ) -> JSONResponse:
-        return safe_error(
-            429,
-            "BUDGET_EXCEEDED",
-            "Agent Run 存储容量已满",
-            True,
-        )
-
-    @application.exception_handler(SafeEngineError)
-    async def safe_engine_error(
-        _request: Request,
-        error: SafeEngineError,
-    ) -> JSONResponse:
-        status = 403 if error.code == "FORBIDDEN" else 503
-        if error.code in {"INVALID_INPUT", "BUDGET_EXCEEDED"}:
-            status = 400
-        return safe_error(
-            status,
-            error.code,
-            error.safe_message,
-            error.retryable,
-        )
-
-    @application.exception_handler(ValidationError)
-    async def validation_error(
-        _request: Request,
-        _error: ValidationError,
-    ) -> JSONResponse:
-        return safe_error(400, "INVALID_INPUT", "请求格式无效", False)
-
-    @application.exception_handler(RequestValidationError)
-    async def request_validation_error(
-        _request: Request,
-        _error: RequestValidationError,
-    ) -> JSONResponse:
-        return safe_error(400, "INVALID_INPUT", "请求格式无效", False)
-
-    @application.post("/api/agent/runs", response_model=StartRunResponse)
-    async def start_run(
-        request: StartRunRequest,
-        idempotency_key: Annotated[str, Header(alias="Idempotency-Key")],
-        authorization: Annotated[str | None, Header()] = None,
-        runtime_protocol: Annotated[str | None, Header(alias=PROTOCOL_HEADER)] = None,
-        runtime_offer_digest: Annotated[
-            str | None, Header(alias=OFFER_DIGEST_HEADER)
-        ] = None,
-    ) -> StartRunResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        if not idempotency_key.strip():
-            return safe_error(400, "INVALID_INPUT", "幂等键不能为空", False)
-        try:
-            validate_runtime_compatibility_pin(
-                runtime_protocol,
-                runtime_offer_digest,
-                runtime_engine.engine_id,
-            )
-        except RuntimeCompatibilityError:
-            return safe_error(
-                409,
-                "RUNTIME_UNAVAILABLE",
-                "Agent Runtime compatibility pin 不匹配",
-                False,
-            )
-        try:
-            await require_vision_readiness(runtime_engine, request)
-        except SafeEngineError as error:
-            return safe_error(503, error.code, error.safe_message, error.retryable)
-        record = await runtime.start(
-            request,
-            idempotency_key,
-        )
-        return StartRunResponse(
-            run_id=record.run_id,
-            status=record.status,
-            events_url=f"/api/agent/runs/{record.run_id}/events",
-        )
-
-    @application.get(
-        "/api/agent/runs/{run_id}",
-        response_model=RunStatusResponse,
-    )
-    async def get_run_status(
-        run_id: str,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> RunStatusResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        record = await runtime.get(run_id)
-        terminal_event = cast(
-            dict[str, JsonValue] | None,
-            record.events[-1] if record.terminal and record.events else None,
-        )
-        return RunStatusResponse(
-            run_id=record.run_id,
-            status=record.status,
-            last_sequence=len(record.events),
-            terminal_event=terminal_event,
-        )
-
-    @application.get("/api/agent/runs/{run_id}/events", response_model=None)
-    async def get_events(
-        run_id: str,
-        after: Annotated[int | None, Query(ge=0)] = None,
-        last_event_id: Annotated[str | None, Header(alias="Last-Event-ID")] = None,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> StreamingResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        await runtime.get(run_id)
-        try:
-            cursor = parse_cursor(after, last_event_id)
-        except ValueError:
-            return safe_error(400, "INVALID_INPUT", "事件游标无效", False)
-        return StreamingResponse(
-            event_stream(runtime, run_id, cursor, heartbeat_seconds),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache, no-transform",
-                "X-Accel-Buffering": "no",
-            },
-        )
-
-    @application.get(
-        "/api/agent/runs/{run_id}/result",
-        response_model=RunResultResponse,
-    )
-    async def get_result(
-        run_id: str,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> RunResultResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        record = await runtime.get(run_id)
-        if record.status == "completed":
-            return RunResultResponse(
-                run_id=record.run_id,
-                status="completed",
-                output=record.output,
-            )
-        if record.status == "cancelled":
-            return safe_error(409, "RUN_CANCELLED", "Agent Run 已取消", False)
-        if record.status == "failed":
-            return safe_error(409, "RUNTIME_UNAVAILABLE", "Agent Run 执行失败", True)
-        return safe_error(409, "RUN_CONFLICT", "Agent Run 尚未完成", True)
-
-    @application.post(
-        "/api/agent/runs/{run_id}/cancel",
-        response_model=CancelRunResponse,
-    )
-    async def cancel_run(
-        run_id: str,
-        _request: CancelRunRequest,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> CancelRunResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        record = await runtime.cancel(run_id)
-        return CancelRunResponse(run_id=record.run_id, status=record.status)
-
-    @application.post(
-        "/api/agent/evaluations",
-        response_model=EvaluationResultResponse,
-    )
-    async def record_evaluation(
-        request: EvaluationResultRequest,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> EvaluationResultResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        evaluation_id = await runtime.record_evaluation(
-            request.release_id,
-            request.evaluation_set_key,
-            request.evaluation_set_version,
-            request.metrics,
-        )
-        return EvaluationResultResponse(
-            evaluation_id=evaluation_id,
-            release_id=request.release_id,
-        )
-
-    application.state.run_service = runtime
-    application.state.report_store = runtime_report_store
-    return application
-
-
-app = create_app(internal_token=os.environ.get("AGENT_SERVER_INTERNAL_TOKEN"))

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

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-from .store import RunRecord, RunStore
-
-
-async def resolve_pending_approval(
-    store: RunStore,
-    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 store.append(
-            record.run_id,
-            "approval.resolved",
-            {
-                "workItemId": work_item_id,
-                "toolCallId": tool_call_id,
-                "outcome": outcome,
-            },
-        )

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

@@ -1,153 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import base64
-import hashlib
-from collections.abc import Sequence
-from io import BytesIO
-from urllib.parse import urlsplit
-
-import httpx
-from PIL import Image, UnidentifiedImageError
-
-from .config import private_hostname
-from .contracts import RuntimeArtifact, RuntimeLimits
-from .engine import PreparedArtifact, SafeEngineError
-
-_IMAGE_TYPES = frozenset({"image/jpeg", "image/png", "image/webp"})
-
-
-class ArtifactLoader:
-    def __init__(
-        self,
-        artifact_url: str,
-        internal_token: str,
-        *,
-        transport: httpx.AsyncBaseTransport | None = None,
-    ) -> None:
-        self.artifact_url = validate_artifact_url(artifact_url)
-        self.internal_token = internal_token
-        self.transport = transport
-
-    async def prepare(
-        self,
-        artifacts: list[RuntimeArtifact],
-        modalities: Sequence[str],
-        limits: RuntimeLimits,
-    ) -> tuple[PreparedArtifact, ...]:
-        if not artifacts:
-            return ()
-        if (
-            "image" not in modalities
-            or limits.max_artifacts is None
-            or limits.max_pixels_per_artifact is None
-        ):
-            raise invalid("Agent Operation 未授权图片输入")
-        if len(artifacts) > limits.max_artifacts:
-            raise budget("图片数量超过 Operation 上限")
-        declared = sum(item.byte_size for item in artifacts)
-        if declared > limits.max_input_bytes:
-            raise budget("图片总大小超过 Operation 上限")
-        prepared: list[PreparedArtifact] = []
-        total = 0
-        for artifact in artifacts:
-            if artifact.media_type.lower() not in _IMAGE_TYPES:
-                raise invalid("Agent Vision 仅接受 JPEG、PNG 或 WebP")
-            raw = await self._download(artifact, limits.max_input_bytes - total)
-            item = await asyncio.to_thread(
-                sanitize_image,
-                raw,
-                limits.max_pixels_per_artifact,
-            )
-            total += item.byte_size
-            if total > limits.max_input_bytes:
-                raise budget("归一化图片总大小超过 Operation 上限")
-            prepared.append(item)
-        return tuple(prepared)
-
-    async def _download(self, artifact: RuntimeArtifact, remaining: int) -> bytes:
-        body = bytearray()
-        digest = hashlib.sha256()
-        try:
-            async with httpx.AsyncClient(
-                timeout=httpx.Timeout(60, connect=5),
-                transport=self.transport,
-            ) as client:
-                async with client.stream(
-                    "GET",
-                    self.artifact_url,
-                    headers={
-                        "authorization": f"Bearer {self.internal_token}",
-                        "x-ai-artifact-ref": artifact.value,
-                    },
-                ) as response:
-                    response.raise_for_status()
-                    if response.headers.get("content-type", "").split(";")[0] != (
-                        artifact.media_type
-                    ):
-                        raise invalid("Artifact MIME 不一致")
-                    async for chunk in response.aiter_bytes():
-                        body.extend(chunk)
-                        digest.update(chunk)
-                        if len(body) > min(artifact.byte_size, remaining):
-                            raise budget("Artifact 内容超过声明上限")
-        except SafeEngineError:
-            raise
-        except Exception as error:
-            raise SafeEngineError(
-                "RUNTIME_UNAVAILABLE",
-                "Agent Runtime 无法读取图片 Artifact",
-                retryable=True,
-            ) from error
-        if len(body) != artifact.byte_size or digest.hexdigest() != artifact.sha256:
-            raise invalid("Artifact 完整性校验失败")
-        return bytes(body)
-
-
-def sanitize_image(raw: bytes, max_pixels: int) -> PreparedArtifact:
-    try:
-        with Image.open(BytesIO(raw)) as source:
-            width, height = source.size
-            if width <= 0 or height <= 0 or width * height > max_pixels:
-                raise budget("图片像素超过 Operation 上限")
-            source.load()
-            normalized = source.convert(
-                "RGBA" if source.has_transparency_data else "RGB"
-            )
-            target = BytesIO()
-            normalized.save(target, format="PNG", optimize=False)
-    except SafeEngineError:
-        raise
-    except (Image.DecompressionBombError, UnidentifiedImageError, OSError):
-        raise invalid("图片内容损坏或格式不受支持") from None
-    body = target.getvalue()
-    digest = hashlib.sha256(body).hexdigest()
-    return PreparedArtifact(
-        media_type="image/png",
-        data_url=f"data:image/png;base64,{base64.b64encode(body).decode()}",
-        byte_size=len(body),
-        sha256=digest,
-    )
-
-
-def validate_artifact_url(raw: str) -> str:
-    parsed = urlsplit(raw.strip())
-    if (
-        parsed.scheme not in {"http", "https"}
-        or not parsed.hostname
-        or parsed.username
-        or parsed.password
-        or parsed.query
-        or parsed.fragment
-        or not private_hostname(parsed.hostname.lower())
-    ):
-        raise ValueError("Agent Artifact URL 必须是固定本地或内网地址")
-    return raw.rstrip("/")
-
-
-def invalid(message: str) -> SafeEngineError:
-    return SafeEngineError("INVALID_INPUT", message, retryable=False)
-
-
-def budget(message: str) -> SafeEngineError:
-    return SafeEngineError("BUDGET_EXCEEDED", message, retryable=False)

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

@@ -1,8 +0,0 @@
-"""Production ASGI entrypoint with operational logging installed."""
-
-from .app import app
-from .structured_logging import configure_agent_logging
-
-configure_agent_logging()
-
-__all__ = ["app"]