create-windy 0.8.3 → 0.9.1

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"]

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

@@ -1,199 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, replace
-
-from .attempt_context_projection import (
-    AttemptContextPreparation,
-    governed_envelope,
-)
-from .context_version_port import (
-    ContextVersionPort,
-    PreparedSource,
-    context_unavailable,
-)
-from .contracts import JsonValue, LongSessionContext
-from .engine import EngineRunRequest, PreparedArtifact
-from .openai_provider import OpenAiCompatibleProvider
-from .provider_governance import GovernedAttempt, ProviderRequestGovernance
-from .provider_output_guidance import tool_output_messages
-
-
-@dataclass(frozen=True)
-class GovernedProviderAttempt:
-    governed: GovernedAttempt
-    provider_request: bytes
-
-
-async def govern_provider_attempt(
-    port: ContextVersionPort,
-    governance: ProviderRequestGovernance,
-    provider: OpenAiCompatibleProvider,
-    request: EngineRunRequest,
-    attempt_sequence: int,
-    model_attempt_id: str | None,
-    messages: list[dict[str, JsonValue]],
-    max_output_tokens: int | None = None,
-) -> GovernedProviderAttempt:
-    preparation = await prepare_attempt_context(
-        port,
-        request.long_session,
-        request.run_id,
-        model_attempt_id,
-        request.execution_grant,
-        messages,
-    )
-    try:
-        attempt_messages = preparation.messages if preparation else messages
-        governed = governance.authorize(
-            deployment_key=provider.config.deployment_key,
-            operation_key=request.operation_key,
-            run_id=request.run_id,
-            attempt=attempt_sequence,
-            messages=attempt_messages,
-            tools=request.allowed_tools,
-            policy=request.provider_data_policy,
-            input_value=request.input,
-            artifact_bytes=sum(artifact.byte_size for artifact in request.artifacts),
-            output_schema=request.output_schema,
-            measure=lambda current_messages, tools, schema: len(
-                provider.request_body(
-                    current_messages,
-                    tools,
-                    request.output_schema_key,
-                    schema,
-                    max_output_tokens,
-                )
-            ),
-        )
-        if governed.tools:
-            governed = replace(
-                governed,
-                messages=tool_output_messages(
-                    governed.messages, governed.output_schema
-                ),
-            )
-        provider_request = provider.request_body(
-            governed.messages,
-            governed.tools,
-            request.output_schema_key,
-            governed.output_schema,
-            max_output_tokens,
-        )
-        await commit_attempt_context(
-            port,
-            preparation,
-            request.long_session,
-            request.run_id,
-            model_attempt_id,
-            request.execution_grant,
-            governed.messages,
-            provider_request,
-            provider.config.deployment_key,
-            provider.config.model,
-            request.prompt_version,
-            request.artifacts,
-        )
-        return GovernedProviderAttempt(governed, provider_request)
-    except BaseException:
-        await abort_attempt_context(
-            port,
-            preparation,
-            request.long_session,
-            request.run_id,
-            model_attempt_id,
-            request.execution_grant,
-        )
-        raise
-
-
-async def prepare_attempt_context(
-    port: ContextVersionPort,
-    binding: LongSessionContext | None,
-    run_id: str,
-    model_attempt_id: str | None,
-    authorization_grant: str,
-    messages: list[dict[str, JsonValue]],
-) -> AttemptContextPreparation | None:
-    if binding is None:
-        return None
-    if model_attempt_id is None or not authorization_grant.strip():
-        raise context_unavailable()
-    context = await port.prepare(
-        binding,
-        run_id,
-        model_attempt_id,
-        authorization_grant,
-    )
-    insertion_start = 1 if messages and messages[0].get("role") == "system" else 0
-    injected = [_source_message(source) for source in context.sources]
-    return AttemptContextPreparation(
-        context,
-        [*messages[:insertion_start], *injected, *messages[insertion_start:]],
-        insertion_start,
-    )
-
-
-async def commit_attempt_context(
-    port: ContextVersionPort,
-    preparation: AttemptContextPreparation | None,
-    binding: LongSessionContext | None,
-    run_id: str,
-    model_attempt_id: str | None,
-    authorization_grant: str,
-    governed_messages: list[dict[str, JsonValue]],
-    provider_request: bytes,
-    deployment_key: str,
-    model: str,
-    prompt_version: str,
-    artifacts: tuple[PreparedArtifact, ...],
-) -> None:
-    if binding is None:
-        return
-    if preparation is None or model_attempt_id is None:
-        raise context_unavailable()
-    envelope = governed_envelope(
-        preparation,
-        run_id,
-        model_attempt_id,
-        governed_messages,
-        provider_request,
-        deployment_key,
-        model,
-        prompt_version,
-        artifacts,
-    )
-    await port.commit(
-        preparation.context,
-        binding,
-        run_id,
-        model_attempt_id,
-        authorization_grant,
-        envelope,
-    )
-
-
-async def abort_attempt_context(
-    port: ContextVersionPort,
-    preparation: AttemptContextPreparation | None,
-    binding: LongSessionContext | None,
-    run_id: str,
-    model_attempt_id: str | None,
-    authorization_grant: str,
-) -> None:
-    if binding is None or preparation is None or model_attempt_id is None:
-        return
-    try:
-        await port.abort(
-            preparation.context,
-            binding,
-            run_id,
-            model_attempt_id,
-            authorization_grant,
-        )
-    except Exception:
-        # Preparations are never active and have a bounded Server-side TTL.
-        return
-
-
-def _source_message(source: PreparedSource) -> dict[str, JsonValue]:
-    return {"role": source.role, "content": source.content}

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

@@ -1,203 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-from typing import cast
-
-from .context_message_digest import (
-    bytes_digest,
-    canonical_json_digest,
-    message_content_digest,
-)
-from .context_version_port import PreparedContext, context_unavailable
-from .contracts import JsonValue
-from .engine import PreparedArtifact
-
-
-@dataclass(frozen=True)
-class AttemptContextPreparation:
-    context: PreparedContext
-    messages: list[dict[str, JsonValue]]
-    insertion_start: int
-
-
-def governed_envelope(
-    preparation: AttemptContextPreparation,
-    run_id: str,
-    model_attempt_id: str,
-    messages: list[dict[str, JsonValue]],
-    provider_request: bytes,
-    deployment_key: str,
-    model: str,
-    prompt_version: str,
-    artifacts: tuple[PreparedArtifact, ...],
-) -> dict[str, JsonValue]:
-    payload = _provider_payload(provider_request, messages, model)
-    source_start = preparation.insertion_start
-    source_end = source_start + len(preparation.context.sources)
-    message_entries: list[JsonValue] = []
-    for ordinal, message in enumerate(messages):
-        recovery_content = _recovery_content(message, artifacts)
-        message_entries.append(
-            {
-                "ordinal": ordinal,
-                "role": cast(str, message.get("role")),
-                "content": recovery_content,
-                # digest covers actual governed Provider content; recoveryDigest
-                # covers the encrypted, ArtifactRef-only recovery projection.
-                "digest": _message_digest(message),
-                "recoveryDigest": message_content_digest(
-                    cast(str, message.get("role")), recovery_content
-                ),
-                "origins": _message_origins(
-                    preparation,
-                    run_id,
-                    model_attempt_id,
-                    prompt_version,
-                    artifacts,
-                    ordinal,
-                    message,
-                    source_start,
-                    source_end,
-                ),
-            }
-        )
-    return {
-        "provider": {
-            "deploymentKey": deployment_key,
-            "model": model,
-            "requestDigest": bytes_digest(provider_request),
-            "toolsDigest": canonical_json_digest(payload.get("tools")),
-            "outputSchemaDigest": canonical_json_digest(payload.get("response_format")),
-        },
-        "messages": message_entries,
-    }
-
-
-def _message_origins(
-    preparation: AttemptContextPreparation,
-    run_id: str,
-    model_attempt_id: str,
-    prompt_version: str,
-    artifacts: tuple[PreparedArtifact, ...],
-    ordinal: int,
-    message: dict[str, JsonValue],
-    source_start: int,
-    source_end: int,
-) -> list[JsonValue]:
-    if source_start <= ordinal < source_end:
-        source = preparation.context.sources[ordinal - source_start]
-        return [
-            {
-                "type": "context-source",
-                "sourceId": source.id,
-                "sourceVersion": source.version,
-                "digest": source.digest,
-                "source": source.reference(),
-            }
-        ]
-    role = message.get("role")
-    digest = _message_digest(message)
-    if ordinal == 0 and role == "system":
-        return [
-            {
-                "type": "instructions",
-                "sourceId": f"{run_id}:instructions",
-                "sourceVersion": prompt_version,
-                "digest": digest,
-            }
-        ]
-    if role == "user":
-        origins: list[JsonValue] = [
-            {
-                "type": "user-prompt",
-                "sourceId": f"{run_id}:user-prompt",
-                "sourceVersion": run_id,
-                "digest": digest,
-            }
-        ]
-        for artifact in artifacts:
-            origins.append(
-                {
-                    "type": "artifact",
-                    "sourceId": artifact.sha256,
-                    "sourceVersion": artifact.sha256,
-                    "digest": artifact.sha256,
-                }
-            )
-        return origins
-    if role == "assistant":
-        return [
-            {
-                "type": "provider-output",
-                "sourceId": f"{run_id}:message:{ordinal}",
-                "sourceVersion": model_attempt_id,
-                "digest": digest,
-            }
-        ]
-    if role == "tool" and isinstance(message.get("tool_call_id"), str):
-        return [
-            {
-                "type": "tool-receipt",
-                "sourceId": message["tool_call_id"],
-                "sourceVersion": model_attempt_id,
-                "digest": digest,
-            }
-        ]
-    raise context_unavailable()
-
-
-def _recovery_content(
-    message: dict[str, JsonValue],
-    artifacts: tuple[PreparedArtifact, ...],
-) -> JsonValue:
-    content = message.get("content")
-    if not isinstance(content, list):
-        return content
-    known = {artifact.data_url: artifact for artifact in artifacts}
-    projected: list[JsonValue] = []
-    for part in content:
-        if not isinstance(part, dict):
-            raise context_unavailable()
-        if part.get("type") == "text" and isinstance(part.get("text"), str):
-            projected.append(part)
-            continue
-        image = part.get("image_url")
-        url = image.get("url") if isinstance(image, dict) else None
-        artifact = known.get(url) if isinstance(url, str) else None
-        if part.get("type") != "image_url" or artifact is None:
-            raise context_unavailable()
-        projected.append(
-            {
-                "type": "artifact_ref",
-                "sha256": artifact.sha256,
-                "mediaType": artifact.media_type,
-                "byteSize": artifact.byte_size,
-            }
-        )
-    return projected
-
-
-def _provider_payload(
-    raw: bytes,
-    messages: list[dict[str, JsonValue]],
-    model: str,
-) -> dict[str, JsonValue]:
-    try:
-        value = json.loads(raw)
-    except (UnicodeDecodeError, json.JSONDecodeError):
-        raise context_unavailable() from None
-    if (
-        not isinstance(value, dict)
-        or value.get("messages") != messages
-        or value.get("model") != model
-    ):
-        raise context_unavailable()
-    return cast(dict[str, JsonValue], value)
-
-
-def _message_digest(message: dict[str, JsonValue]) -> str:
-    role = message.get("role")
-    if role not in {"system", "user", "assistant", "tool"} or "content" not in message:
-        raise context_unavailable()
-    return canonical_json_digest(cast(JsonValue, message))

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

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal, Self
-
-from pydantic import Field, model_validator
-
-from .contracts import CanonicalModel, JsonValue, ProviderDataPolicy
-
-
-class NamedFunction(CanonicalModel):
-    name: str = Field(pattern=r"^[A-Za-z0-9_-]{1,64}$")
-
-
-class NamedToolChoice(CanonicalModel):
-    type: Literal["function"]
-    function: NamedFunction
-
-
-class ClientCompletionRequest(CanonicalModel):
-    client_run_id: str = Field(min_length=1, max_length=80)
-    operation_key: str = Field(min_length=1, max_length=200)
-    deployment_key: str = Field(min_length=1, max_length=200)
-    model_alias: str = Field(pattern=r"^[A-Za-z0-9._-]{1,80}$")
-    attempt: int = Field(ge=1, le=128)
-    messages: list[dict[str, JsonValue]] = Field(min_length=1, max_length=128)
-    tools: list[dict[str, JsonValue]] = Field(default_factory=list, max_length=64)
-    tool_choice: Literal["auto", "none"] | NamedToolChoice | None = None
-    parallel_tool_calls: Literal[False] = False
-    provider_data_policy: ProviderDataPolicy
-    max_response_bytes: int = Field(ge=1_024, le=16_777_216)
-
-    @model_validator(mode="after")
-    def validate_openai_envelope(self) -> Self:
-        for message in self.messages:
-            if message.get("role") not in {"system", "user", "assistant", "tool"}:
-                raise ValueError("消息角色无效")
-            content = message.get("content")
-            if content is not None and not isinstance(content, str):
-                raise ValueError("消息 content 无效")
-        names: set[str] = set()
-        for tool in self.tools:
-            function = tool.get("function")
-            if tool.get("type") != "function" or not isinstance(function, dict):
-                raise ValueError("Tool 定义无效")
-            name = function.get("name")
-            parameters = function.get("parameters")
-            if (
-                not isinstance(name, str)
-                or not name
-                or name in names
-                or not isinstance(parameters, dict)
-                or parameters.get("type") != "object"
-            ):
-                raise ValueError("Tool Function 定义无效")
-            names.add(name)
-        if (
-            isinstance(self.tool_choice, NamedToolChoice)
-            and self.tool_choice.function.name not in names
-        ):
-            raise ValueError("命名 Tool Choice 不存在")
-        return self