create-windy 0.8.3 → 0.9.1

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

@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import cast
-
-from .contracts import JsonValue, ProviderDataPolicy
-from .engine import SafeEngineError
-from .provider_governance import (
-    GovernanceDenied,
-    ProviderRequestGovernance,
-    field_for_message,
-    govern_message,
-    govern_value,
-)
-
-
-def govern_client_completion(
-    governance: ProviderRequestGovernance,
-    *,
-    deployment_key: str,
-    operation_key: str,
-    run_id: str,
-    attempt: int,
-    messages: list[dict[str, JsonValue]],
-    tools: list[dict[str, JsonValue]],
-    policy: ProviderDataPolicy,
-) -> tuple[list[dict[str, JsonValue]], list[dict[str, JsonValue]]]:
-    rules = {rule.field: rule for rule in policy.envelope_fields}
-    classified: set[str] = set()
-    redacted = False
-    try:
-        governed_messages: list[dict[str, JsonValue]] = []
-        for message in messages:
-            field = field_for_message(message)
-            rule = rules.get(field)
-            if rule is None:
-                raise GovernanceDenied(f"Provider 未授权发送字段：{field}")
-            classified.add(rule.classification)
-            value, changed = govern_message(message, rule.dlp_action)
-            redacted = redacted or changed
-            governed_messages.append(cast(dict[str, JsonValue], value))
-        governed_tools = tools
-        if tools:
-            rule = rules.get("tool-definitions")
-            if rule is None:
-                raise GovernanceDenied("Provider 未授权发送字段：tool-definitions")
-            classified.add(rule.classification)
-            value, changed = govern_value(tools, rule.dlp_action)
-            redacted = redacted or changed
-            governed_tools = cast(list[dict[str, JsonValue]], value)
-        sent_bytes = len(
-            json.dumps(
-                {"messages": governed_messages, "tools": governed_tools},
-                ensure_ascii=False,
-                separators=(",", ":"),
-            ).encode()
-        )
-        governance.record_client(
-            deployment_key=deployment_key,
-            operation_key=operation_key,
-            run_id=run_id,
-            attempt=attempt,
-            classified=classified,
-            sent_bytes=sent_bytes,
-            decision="redact" if redacted else "allow",
-        )
-        return governed_messages, governed_tools
-    except GovernanceDenied:
-        governance.record_client(
-            deployment_key=deployment_key,
-            operation_key=operation_key,
-            run_id=run_id,
-            attempt=attempt,
-            classified=classified,
-            sent_bytes=0,
-            decision="reject",
-        )
-        raise SafeEngineError(
-            "FORBIDDEN",
-            "Provider 请求被字段治理策略拒绝",
-            retryable=False,
-        ) from None

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

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import AsyncIterator, Callable
-from typing import TYPE_CHECKING, Annotated, cast
-
-from fastapi import FastAPI, Header, Request
-from fastapi.responses import JSONResponse, StreamingResponse
-
-from .client_completion_contracts import ClientCompletionRequest
-from .client_completion_runtime import ClientCompletionRuntime
-from .engine import AgentEngineAdapter, SafeEngineError
-from .http_helpers import authorized, safe_error
-
-if TYPE_CHECKING:
-    from .client_completion_runtime import PreparedClientCompletion
-
-
-def install_client_completion_routes(
-    application: FastAPI,
-    engine: AgentEngineAdapter,
-    internal_token: str | None,
-) -> None:
-    @application.get("/api/internal/client-agent/health", response_model=None)
-    async def client_completion_health(
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> dict[str, str] | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        factory = runtime_factory(engine)
-        if factory is None:
-            return safe_error(
-                503,
-                "RUNTIME_UNAVAILABLE",
-                "Client Agent Provider 尚未配置",
-                True,
-            )
-        try:
-            factory().deployment_digest()
-        except SafeEngineError as error:
-            return safe_error(503, error.code, error.safe_message, error.retryable)
-        return {"status": "ready"}
-
-    @application.post(
-        "/api/internal/client-agent/chat/completions",
-        response_model=None,
-    )
-    async def client_completion(
-        body: ClientCompletionRequest,
-        request: Request,
-        authorization: Annotated[str | None, Header()] = None,
-    ) -> StreamingResponse | JSONResponse:
-        if not authorized(authorization, internal_token):
-            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
-        factory = runtime_factory(engine)
-        if factory is None:
-            return safe_error(
-                503,
-                "RUNTIME_UNAVAILABLE",
-                "Client Agent Provider 尚未配置",
-                True,
-            )
-        try:
-            runtime = factory()
-            prepared = runtime.prepare(body)
-        except SafeEngineError as error:
-            return safe_error(
-                403 if error.code == "FORBIDDEN" else 503,
-                error.code,
-                error.safe_message,
-                error.retryable,
-            )
-        return StreamingResponse(
-            completion_events(runtime, prepared, request),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-store, no-transform",
-                "X-Accel-Buffering": "no",
-            },
-        )
-
-
-async def completion_events(
-    runtime: ClientCompletionRuntime,
-    prepared: object,
-    request: Request,
-) -> AsyncIterator[str]:
-    typed = cast("PreparedClientCompletion", prepared)
-    yield event(
-        "windy.meta",
-        {"deploymentDigest": typed.deployment_digest},
-    )
-    try:
-        async for chunk in runtime.stream(typed):
-            if await request.is_disconnected():
-                return
-            yield event(None, chunk)
-        yield "data: [DONE]\n\n"
-    except SafeEngineError as error:
-        yield event(
-            "windy.error",
-            {
-                "code": error.code,
-                "message": error.safe_message,
-                "retryable": error.retryable,
-            },
-        )
-
-
-def event(name: str | None, value: object) -> str:
-    prefix = f"event: {name}\n" if name else ""
-    return f"{prefix}data: {json.dumps(value, ensure_ascii=False)}\n\n"
-
-
-def runtime_factory(
-    engine: AgentEngineAdapter,
-) -> Callable[[], ClientCompletionRuntime] | None:
-    return cast(
-        Callable[[], ClientCompletionRuntime] | None,
-        getattr(engine, "client_completion_runtime", None),
-    )

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

@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-from collections.abc import AsyncGenerator
-from dataclasses import dataclass
-from typing import cast
-
-import httpx
-
-from .client_completion_contracts import ClientCompletionRequest, NamedToolChoice
-from .client_completion_governance import govern_client_completion
-from .contracts import JsonValue
-from .engine import SafeEngineError
-from .openai_provider import OpenAiCompatibleProvider, ProviderTurn, consume_chunk
-from .provider_governance import ProviderRequestGovernance
-
-
-@dataclass(frozen=True)
-class PreparedClientCompletion:
-    deployment_digest: str
-    model_alias: str
-    body: bytes
-    max_response_bytes: int
-
-
-class ClientCompletionRuntime:
-    def __init__(
-        self,
-        provider: OpenAiCompatibleProvider,
-        governance: ProviderRequestGovernance,
-    ) -> None:
-        self._provider = provider
-        self._governance = governance
-
-    def prepare(self, request: ClientCompletionRequest) -> PreparedClientCompletion:
-        config = self._provider.config
-        if request.deployment_key != config.deployment_key:
-            raise SafeEngineError(
-                "MODEL_ROUTE_UNAVAILABLE",
-                "Client Agent Deployment 不可用",
-                retryable=False,
-            )
-        governed_messages, governed_tools = govern_client_completion(
-            self._governance,
-            deployment_key=config.deployment_key,
-            operation_key=request.operation_key,
-            run_id=request.client_run_id,
-            attempt=request.attempt,
-            messages=request.messages,
-            tools=request.tools,
-            policy=request.provider_data_policy,
-        )
-        payload: dict[str, JsonValue] = {
-            "model": config.model,
-            "messages": cast(JsonValue, governed_messages),
-            "stream": True,
-            "stream_options": {"include_usage": True},
-            "parallel_tool_calls": False,
-        }
-        if governed_tools:
-            payload["tools"] = cast(JsonValue, governed_tools)
-        if request.tool_choice is not None:
-            payload["tool_choice"] = cast(
-                JsonValue,
-                request.tool_choice.model_dump(by_alias=True)
-                if isinstance(request.tool_choice, NamedToolChoice)
-                else request.tool_choice,
-            )
-        body = json.dumps(
-            payload,
-            ensure_ascii=False,
-            separators=(",", ":"),
-        ).encode()
-        return PreparedClientCompletion(
-            deployment_digest=self.deployment_digest(),
-            model_alias=request.model_alias,
-            body=body,
-            max_response_bytes=min(
-                request.max_response_bytes,
-                config.max_response_bytes,
-            ),
-        )
-
-    async def stream(
-        self,
-        prepared: PreparedClientCompletion,
-    ) -> AsyncGenerator[dict[str, JsonValue]]:
-        consumed = 0
-        turn = ProviderTurn()
-        async with self._provider._client() as client:
-            try:
-                async with client.stream(
-                    "POST",
-                    "/chat/completions",
-                    content=prepared.body,
-                    headers={"content-type": "application/json"},
-                ) as response:
-                    if not response.is_success:
-                        await self._provider._bounded_stream(response)
-                        raise SafeEngineError(
-                            "RATE_LIMITED"
-                            if response.status_code == 429
-                            else "PROVIDER_UNAVAILABLE",
-                            "模型服务限流"
-                            if response.status_code == 429
-                            else "模型服务暂不可用",
-                            retryable=response.status_code == 429
-                            or response.status_code >= 500,
-                        )
-                    async for line in response.aiter_lines():
-                        consumed += len(line.encode()) + 1
-                        if consumed > prepared.max_response_bytes:
-                            raise SafeEngineError(
-                                "BUDGET_EXCEEDED",
-                                "模型响应超过会话上限",
-                                retryable=False,
-                            )
-                        if not line.startswith("data:"):
-                            continue
-                        data = line.removeprefix("data:").strip()
-                        if not data or data == "[DONE]":
-                            continue
-                        chunk = json.loads(data)
-                        consume_chunk(chunk, turn)
-                        if not isinstance(chunk, dict):
-                            raise TypeError
-                        normalized = cast(dict[str, JsonValue], chunk)
-                        normalized["model"] = prepared.model_alias
-                        yield normalized
-            except SafeEngineError:
-                raise
-            except httpx.HTTPError:
-                raise SafeEngineError(
-                    "PROVIDER_UNAVAILABLE",
-                    "模型服务暂不可用",
-                    retryable=True,
-                ) from None
-            except (KeyError, TypeError, ValueError, json.JSONDecodeError):
-                raise SafeEngineError(
-                    "PROVIDER_UNAVAILABLE",
-                    "模型返回协议无效",
-                    retryable=True,
-                ) from None
-
-    def deployment_digest(self) -> str:
-        config = self._provider.config
-        canonical = json.dumps(
-            {
-                "deploymentKey": config.deployment_key,
-                "model": config.model,
-                "deploymentIdentity": config.readiness_deployment_identity,
-                "releaseDigest": config.readiness_release_digest,
-            },
-            sort_keys=True,
-            separators=(",", ":"),
-        ).encode()
-        return f"sha256:{hashlib.sha256(canonical).hexdigest()}"

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

@@ -1,267 +0,0 @@
-from __future__ import annotations
-
-import ipaddress
-import os
-import re
-from collections.abc import Mapping
-from dataclasses import dataclass
-from urllib.parse import urlsplit, urlunsplit
-
-
-@dataclass(frozen=True)
-class SecretRef:
-    provider: str
-    locator: str
-
-    def __str__(self) -> str:
-        return "[SecretRef]"
-
-
-class EnvironmentSecretResolver:
-    def __init__(self, environment: Mapping[str, str]) -> None:
-        self._environment = environment
-
-    def resolve(self, ref: SecretRef) -> str | None:
-        if ref.provider != "env":
-            raise ValueError("Secret Provider 不匹配")
-        return self._environment.get(ref.locator)
-
-
-@dataclass(frozen=True)
-class OpenAiCompatibleConfig:
-    base_url: str
-    model: str
-    api_key_ref: SecretRef | None
-    connect_timeout_seconds: float = 5.0
-    request_timeout_seconds: float = 60.0
-    max_response_bytes: int = 2 * 1024 * 1024
-    max_duration_seconds: int = 300
-    max_input_bytes: int = 67_108_864
-    max_artifacts: int = 16
-    max_pixels_per_artifact: int = 100_000_000
-    max_tool_rounds: int = 8
-    https_host_allowlist: tuple[str, ...] = ()
-    deployment_key: str = "ai.openai-compatible"
-    capabilities: tuple[str, ...] = ("text-generation",)
-    input_modalities: tuple[str, ...] = ("text",)
-    readiness_deployment_identity: str | None = None
-    readiness_release_digest: str | None = None
-    readiness_ttl_seconds: int = 60
-    max_concurrent_runs: int = 1
-    max_queue_depth: int = 0
-
-    def __post_init__(self) -> None:
-        normalized = normalize_base_url(self.base_url)
-        object.__setattr__(self, "base_url", normalized)
-        require_allowed_https_host(normalized, self.https_host_allowlist)
-
-    @classmethod
-    def from_environment(
-        cls,
-        environment: Mapping[str, str] = os.environ,
-    ) -> OpenAiCompatibleConfig | None:
-        base_url = environment.get("QWEN_API_URL", "").strip()
-        model = environment.get("QWEN_MODEL", "").strip()
-        if not base_url and not model:
-            return None
-        if not base_url or not model:
-            raise ValueError("OpenAI-compatible Endpoint 与 Model 必须同时配置")
-        return cls(
-            base_url=normalize_base_url(base_url),
-            model=model,
-            api_key_ref=(
-                SecretRef("env", "QWEN_API_KEY")
-                if environment.get("QWEN_API_KEY", "").strip()
-                else None
-            ),
-            https_host_allowlist=normalize_https_host_allowlist(
-                environment.get("AI_PROVIDER_HTTPS_HOST_ALLOWLIST", "")
-            ),
-            connect_timeout_seconds=read_milliseconds(
-                environment,
-                "AI_PROVIDER_CONNECT_TIMEOUT_MS",
-                5_000,
-                100,
-                30_000,
-            )
-            / 1_000,
-            request_timeout_seconds=read_milliseconds(
-                environment,
-                "AI_PROVIDER_REQUEST_TIMEOUT_MS",
-                60_000,
-                1_000,
-                300_000,
-            )
-            / 1_000,
-            max_response_bytes=read_integer(
-                environment,
-                "AI_PROVIDER_MAX_RESPONSE_BYTES",
-                2 * 1024 * 1024,
-                1_024,
-                16 * 1024 * 1024,
-            ),
-            max_duration_seconds=read_integer(
-                environment, "AI_PROVIDER_MAX_DURATION_SECONDS", 300, 1, 300
-            ),
-            max_input_bytes=read_integer(
-                environment,
-                "AI_PROVIDER_MAX_INPUT_BYTES",
-                67_108_864,
-                1_024,
-                67_108_864,
-            ),
-            max_artifacts=read_integer(
-                environment, "AI_PROVIDER_MAX_ARTIFACTS", 16, 1, 16
-            ),
-            max_pixels_per_artifact=read_integer(
-                environment,
-                "AI_PROVIDER_MAX_PIXELS_PER_ARTIFACT",
-                100_000_000,
-                1,
-                100_000_000,
-            ),
-            capabilities=read_csv(
-                environment,
-                "AI_PROVIDER_CAPABILITIES",
-                ("text-generation",),
-            ),
-            input_modalities=read_csv(
-                environment,
-                "AI_PROVIDER_INPUT_MODALITIES",
-                ("text",),
-            ),
-            readiness_deployment_identity=optional_value(
-                environment, "AI_PROVIDER_DEPLOYMENT_IDENTITY"
-            ),
-            readiness_release_digest=optional_value(
-                environment, "AI_PROVIDER_RELEASE_DIGEST"
-            ),
-            readiness_ttl_seconds=read_integer(
-                environment, "AI_PROVIDER_READINESS_TTL_SECONDS", 60, 1, 300
-            ),
-            max_concurrent_runs=read_integer(
-                environment, "AI_PROVIDER_MAX_CONCURRENT_RUNS", 1, 1, 1_000
-            ),
-            max_queue_depth=read_integer(
-                environment, "AI_PROVIDER_MAX_QUEUE_DEPTH", 0, 0, 10_000
-            ),
-        )
-
-
-def normalize_base_url(raw: str) -> str:
-    parsed = urlsplit(raw.strip())
-    if parsed.scheme not in {"http", "https"} or not parsed.hostname:
-        raise ValueError("OpenAI-compatible Endpoint 无效")
-    if parsed.username or parsed.password or parsed.query or parsed.fragment:
-        raise ValueError("OpenAI-compatible Endpoint 不允许凭据、查询串或片段")
-    hostname = parsed.hostname.lower()
-    if hostname in {
-        "169.254.169.254",
-        "metadata.google.internal",
-        "metadata.azure.internal",
-    }:
-        raise ValueError("OpenAI-compatible Endpoint 禁止访问云 metadata")
-    if parsed.scheme == "http" and not private_hostname(hostname):
-        raise ValueError("公网 OpenAI-compatible Endpoint 必须使用 HTTPS")
-    path = parsed.path.rstrip("/")
-    return urlunsplit((parsed.scheme, parsed.netloc, path, "", ""))
-
-
-def normalize_https_host_allowlist(raw: str) -> tuple[str, ...]:
-    hosts: list[str] = []
-    for item in raw.split(","):
-        candidate = item.strip().lower().rstrip(".")
-        if not candidate:
-            continue
-        if candidate in hosts or not valid_hostname(candidate):
-            raise ValueError("Provider HTTPS Host allowlist 无效")
-        hosts.append(candidate)
-    return tuple(hosts)
-
-
-def require_allowed_https_host(
-    base_url: str,
-    allowed_hosts: tuple[str, ...],
-) -> None:
-    endpoint = urlsplit(base_url)
-    hostname = (endpoint.hostname or "").lower().rstrip(".")
-    if endpoint.scheme == "https" and hostname not in allowed_hosts:
-        raise ValueError("OpenAI-compatible Endpoint 未命中 HTTPS Host allowlist")
-
-
-def valid_hostname(value: str) -> bool:
-    try:
-        ipaddress.ip_address(value)
-        return True
-    except ValueError:
-        return bool(
-            len(value) <= 253
-            and re.fullmatch(
-                r"(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*"
-                r"[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?",
-                value,
-            )
-        )
-
-
-def private_hostname(hostname: str) -> bool:
-    if (
-        hostname == "localhost"
-        or hostname.endswith((".localhost", ".internal", ".local"))
-        or "." not in hostname
-    ):
-        return True
-    try:
-        address = ipaddress.ip_address(hostname)
-    except ValueError:
-        return False
-    return address.is_private or address.is_loopback
-
-
-def read_milliseconds(
-    environment: Mapping[str, str],
-    key: str,
-    default: int,
-    minimum: int,
-    maximum: int,
-) -> int:
-    return read_integer(environment, key, default, minimum, maximum)
-
-
-def read_integer(
-    environment: Mapping[str, str],
-    key: str,
-    default: int,
-    minimum: int,
-    maximum: int,
-) -> int:
-    raw = environment.get(key)
-    try:
-        value = default if raw is None else int(raw)
-    except ValueError as error:
-        raise ValueError(f"{key} 必须是整数") from error
-    if not minimum <= value <= maximum:
-        raise ValueError(f"{key} 超出允许范围")
-    return value
-
-
-def read_csv(
-    environment: Mapping[str, str],
-    key: str,
-    default: tuple[str, ...],
-) -> tuple[str, ...]:
-    values = tuple(
-        dict.fromkeys(
-            item.strip()
-            for item in environment.get(key, ",".join(default)).split(",")
-            if item.strip()
-        )
-    )
-    if not values or len(values) > 32:
-        raise ValueError(f"{key} 无效")
-    return values
-
-
-def optional_value(environment: Mapping[str, str], key: str) -> str | None:
-    value = environment.get(key, "").strip()
-    return value or None

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

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-
-from .contracts import JsonValue
-
-
-def bytes_digest(value: bytes) -> str:
-    return hashlib.sha256(value).hexdigest()
-
-
-def canonical_json_digest(value: JsonValue) -> str:
-    encoded = json.dumps(
-        value,
-        ensure_ascii=False,
-        separators=(",", ":"),
-        sort_keys=True,
-    ).encode()
-    return bytes_digest(encoded)
-
-
-def message_content_digest(role: str, content: JsonValue) -> str:
-    return canonical_json_digest({"role": role, "content": content})