create-windy 0.8.2 → 0.9.1

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

@@ -1,307 +0,0 @@
-from __future__ import annotations
-
-from datetime import UTC, datetime
-from typing import Literal
-from urllib.parse import urlsplit, urlunsplit
-
-import httpx
-from pydantic import BaseModel, ConfigDict, Field
-
-from .context_message_digest import message_content_digest
-from .context_version_contracts import (
-    CommittedContext,
-    ContextVersionPort,
-    PreparedContext,
-    PreparedSource,
-)
-from .contracts import JsonValue, LongSessionContext
-from .engine import SafeEngineError
-
-__all__ = [
-    "CommittedContext",
-    "ContextVersionPort",
-    "HttpContextVersionPort",
-    "PreparedContext",
-    "PreparedSource",
-    "UnavailableContextVersionPort",
-    "context_unavailable",
-]
-
-
-def _to_camel(value: str) -> str:
-    first, *rest = value.split("_")
-    return first + "".join(part.capitalize() for part in rest)
-
-
-class _CanonicalModel(BaseModel):
-    model_config = ConfigDict(
-        alias_generator=_to_camel, populate_by_name=True, extra="forbid"
-    )
-
-
-class _Validity(_CanonicalModel):
-    status: str
-    checked_at: str
-    expires_at: str | None = None
-    reason: str | None = None
-
-
-class _ResolvedReference(_CanonicalModel):
-    module_key: str = Field(min_length=1)
-    kind: str = Field(min_length=1)
-    id: str = Field(min_length=1)
-    version: str = Field(min_length=1)
-    sequence: int = Field(ge=1)
-    digest: str = Field(pattern=r"^[a-f0-9]{64}$")
-    validity: _Validity
-
-
-class _PreparedSource(_CanonicalModel):
-    reference: _ResolvedReference
-    content: JsonValue
-    role: Literal["system", "user", "assistant", "tool"] = "system"
-
-
-class _PrepareResponse(_CanonicalModel):
-    preparation_id: str = Field(min_length=1, max_length=160)
-    sources: list[_PreparedSource] = Field(min_length=1, max_length=128)
-
-
-class _CommitResponse(_CanonicalModel):
-    context_version_id: str = Field(min_length=1)
-    digest: str = Field(pattern=r"^[a-f0-9]{64}$")
-    status: Literal["active"]
-    provider_request_digest: str = Field(pattern=r"^[a-f0-9]{64}$")
-
-
-class _AbortResponse(_CanonicalModel):
-    status: Literal["aborted", "absent"]
-
-
-class HttpContextVersionPort:
-    """Two-phase, fail-closed callback to the authoritative Context Builder."""
-
-    def __init__(
-        self, base_url: str, internal_token: str, *, timeout_seconds: float = 10
-    ) -> None:
-        self._url = _endpoint(base_url)
-        self._token = internal_token
-        self._timeout = timeout_seconds
-
-    async def prepare(
-        self,
-        binding: LongSessionContext,
-        run_id: str,
-        model_attempt_id: str,
-        authorization_grant: str,
-    ) -> PreparedContext:
-        request = _base_request(binding, run_id, model_attempt_id, authorization_grant)
-        request.update({"contractVersion": 2, "phase": "prepare"})
-        try:
-            response = _PrepareResponse.model_validate_json(await self._post(request))
-            return _validated_preparation(binding, response)
-        except SafeEngineError:
-            raise
-        except Exception as error:
-            raise _unavailable() from error
-
-    async def commit(
-        self,
-        preparation: PreparedContext,
-        binding: LongSessionContext,
-        run_id: str,
-        model_attempt_id: str,
-        authorization_grant: str,
-        governed_envelope: dict[str, JsonValue],
-    ) -> CommittedContext:
-        request = _base_request(binding, run_id, model_attempt_id, authorization_grant)
-        request.update(
-            {
-                "contractVersion": 2,
-                "phase": "commit",
-                "preparationId": preparation.preparation_id,
-                "governedEnvelope": governed_envelope,
-            }
-        )
-        try:
-            response = _CommitResponse.model_validate_json(await self._post(request))
-            provider = governed_envelope.get("provider")
-            expected = (
-                provider.get("requestDigest") if isinstance(provider, dict) else None
-            )
-            if response.provider_request_digest != expected:
-                raise _unavailable()
-            return CommittedContext(response.context_version_id, response.digest)
-        except SafeEngineError:
-            raise
-        except Exception as error:
-            raise _unavailable() from error
-
-    async def abort(
-        self,
-        preparation: PreparedContext,
-        binding: LongSessionContext,
-        run_id: str,
-        model_attempt_id: str,
-        authorization_grant: str,
-    ) -> None:
-        request = _base_request(binding, run_id, model_attempt_id, authorization_grant)
-        request.update(
-            {
-                "contractVersion": 2,
-                "phase": "abort",
-                "preparationId": preparation.preparation_id,
-            }
-        )
-        try:
-            _AbortResponse.model_validate_json(await self._post(request))
-        except Exception as error:
-            raise _unavailable() from error
-
-    async def _post(self, request: dict[str, object]) -> bytes:
-        content = bytearray()
-        async with httpx.AsyncClient(
-            timeout=self._timeout, follow_redirects=False
-        ) as client:
-            async with client.stream(
-                "POST",
-                self._url,
-                headers={
-                    "authorization": f"Bearer {self._token}",
-                    "content-type": "application/json",
-                },
-                json=request,
-            ) as response:
-                if response.status_code != 200:
-                    raise _unavailable()
-                async for chunk in response.aiter_bytes():
-                    content.extend(chunk)
-                    if len(content) > 2 * 1_024 * 1_024:
-                        raise _unavailable()
-        return bytes(content)
-
-
-class UnavailableContextVersionPort:
-    async def prepare(self, *args: object) -> PreparedContext:
-        del args
-        raise _unavailable()
-
-    async def commit(self, *args: object) -> CommittedContext:
-        del args
-        raise _unavailable()
-
-    async def abort(self, *args: object) -> None:
-        del args
-        raise _unavailable()
-
-
-def _base_request(
-    binding: LongSessionContext,
-    run_id: str,
-    model_attempt_id: str,
-    authorization_grant: str,
-) -> dict[str, object]:
-    return {
-        "sessionId": binding.session_id,
-        "turnId": binding.turn_id,
-        "runId": run_id,
-        "modelAttemptId": model_attempt_id,
-        "authorizationGrant": authorization_grant,
-        **({"caseId": binding.case_id} if binding.case_id else {}),
-        "sources": [source.model_dump(by_alias=True) for source in binding.sources],
-    }
-
-
-def _validated_preparation(
-    binding: LongSessionContext,
-    response: _PrepareResponse,
-) -> PreparedContext:
-    requested = {
-        (source.module_key, source.kind, source.id) for source in binding.sources
-    }
-    returned = [
-        (source.reference.module_key, source.reference.kind, source.reference.id)
-        for source in response.sources
-    ]
-    coordinates = [
-        (
-            source.reference.module_key,
-            source.reference.kind,
-            source.reference.id,
-            source.reference.version,
-            source.reference.sequence,
-        )
-        for source in response.sources
-    ]
-    if not requested.issubset(returned) or len(coordinates) != len(set(coordinates)):
-        raise _unavailable()
-    now = datetime.now(UTC)
-    sources: list[PreparedSource] = []
-    for source in response.sources:
-        reference = source.reference
-        if (
-            reference.validity.status != "valid"
-            or _invalid_timestamp(reference.validity.checked_at)
-            or _expired(reference.validity.expires_at, now)
-            or message_content_digest(source.role, source.content) != reference.digest
-        ):
-            raise _unavailable()
-        sources.append(
-            PreparedSource(
-                reference.module_key,
-                reference.kind,
-                reference.id,
-                reference.version,
-                reference.sequence,
-                reference.digest,
-                reference.validity.model_dump(by_alias=True, exclude_none=True),
-                source.content,
-                source.role,
-            )
-        )
-    return PreparedContext(response.preparation_id, tuple(sources))
-
-
-def _expired(value: str | None, now: datetime) -> bool:
-    if value is None:
-        return False
-    try:
-        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError:
-        return True
-    return parsed.tzinfo is None or parsed <= now
-
-
-def _invalid_timestamp(value: str) -> bool:
-    try:
-        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError:
-        return True
-    return parsed.tzinfo is None
-
-
-def _endpoint(raw: str) -> str:
-    parts = urlsplit(raw.strip())
-    if (
-        parts.scheme not in {"http", "https"}
-        or not parts.hostname
-        or parts.username
-        or parts.password
-        or parts.query
-        or parts.fragment
-    ):
-        raise ValueError("AGENT_CONTEXT_HOST_URL 无效")
-    path = f"{parts.path.rstrip('/')}/api/internal/agent/context-versions"
-    return urlunsplit((parts.scheme, parts.netloc, path, "", ""))
-
-
-def context_unavailable() -> SafeEngineError:
-    return _unavailable()
-
-
-def _unavailable() -> SafeEngineError:
-    return SafeEngineError(
-        "RUNTIME_UNAVAILABLE",
-        "长期 Session Context 暂不可用",
-        retryable=True,
-    )

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

@@ -1,297 +0,0 @@
-from __future__ import annotations
-
-from math import isfinite
-from typing import Literal, Self
-
-from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
-
-type JsonValue = (
-    str | int | float | bool | None | list[JsonValue] | dict[str, JsonValue]
-)
-type RunStatus = Literal[
-    "accepted",
-    "running",
-    "awaiting-approval",
-    "completed",
-    "failed",
-    "cancelled",
-]
-type InputModality = Literal["text", "image", "audio", "video", "document"]
-type AgentErrorCode = Literal[
-    "OPERATION_NOT_FOUND",
-    "OPERATION_DISABLED",
-    "INVALID_INPUT",
-    "FORBIDDEN",
-    "LICENSE_NOT_ALLOWED",
-    "RUNTIME_UNAVAILABLE",
-    "MODEL_ROUTE_UNAVAILABLE",
-    "PROVIDER_UNAVAILABLE",
-    "RATE_LIMITED",
-    "BUDGET_EXCEEDED",
-    "TOOL_DENIED",
-    "APPROVAL_REQUIRED",
-    "OUTPUT_VALIDATION_FAILED",
-    "RUN_CONFLICT",
-    "RUN_TIMEOUT",
-    "RUN_CANCELLED",
-    "STREAM_INTERRUPTED",
-]
-
-
-def to_camel(value: str) -> str:
-    first, *rest = value.split("_")
-    return first + "".join(part.capitalize() for part in rest)
-
-
-class CanonicalModel(BaseModel):
-    model_config = ConfigDict(
-        alias_generator=to_camel,
-        populate_by_name=True,
-        extra="forbid",
-    )
-
-
-class RuntimeToolDefinition(CanonicalModel):
-    key: str = Field(min_length=1)
-    label: str = Field(min_length=1)
-    description: str = Field(min_length=1)
-    approval: Literal["none", "required"] = "none"
-    idempotency: Literal["none", "supported", "required"] = "supported"
-    approval_timeout_seconds: int | None = Field(default=None, ge=1, le=604_800)
-
-
-class RuntimeLimits(CanonicalModel):
-    max_duration_seconds: int = Field(default=60, ge=1, le=300)
-    max_input_bytes: int = Field(default=1_048_576, ge=1_024, le=67_108_864)
-    max_output_bytes: int = Field(default=1_048_576, ge=1_024, le=16_777_216)
-    max_artifacts: int | None = Field(default=None, ge=1, le=16)
-    max_pixels_per_artifact: int | None = Field(default=None, ge=1, le=100_000_000)
-    max_model_attempts: int | None = Field(default=None, ge=1, le=500)
-    max_tool_calls: int | None = Field(default=None, ge=0, le=100_000)
-    max_subagents: int | None = Field(default=None, ge=0, le=10_000)
-    max_parallelism: int | None = Field(default=None, ge=1, le=256)
-    max_input_tokens: int | None = Field(default=None, ge=1, le=2_147_483_647)
-    max_output_tokens: int | None = Field(default=None, ge=1, le=2_147_483_647)
-    max_cost_micros: int | None = Field(default=None, ge=0, le=9_007_199_254_740_991)
-
-
-class ModelCoordinatePin(CanonicalModel):
-    deployment_key: str = Field(min_length=1, max_length=160)
-    model: str = Field(min_length=1, max_length=240)
-
-
-class ProviderEgress(CanonicalModel):
-    mode: Literal["forbidden", "configured-endpoint"] = "forbidden"
-    deployment_key: str | None = None
-
-    @model_validator(mode="after")
-    def validate_deployment(self) -> Self:
-        if self.mode == "configured-endpoint":
-            if not self.deployment_key or not self.deployment_key.strip():
-                raise ValueError("Provider Deployment Key 缺失")
-        elif self.deployment_key is not None:
-            raise ValueError("禁止出网时不能指定 Provider Deployment")
-        return self
-
-
-type ProviderDataField = Literal[
-    "instructions",
-    "user-prompt",
-    "tool-definitions",
-    "artifact-content",
-    "output-schema",
-    "provider-output",
-    "tool-results",
-]
-type ContextSourceKind = Literal[
-    "system-instruction",
-    "operation-instruction",
-    "recent-event",
-    "skill",
-    "artifact-summary",
-    "working-context",
-    "session-summary",
-    "user-preference",
-    "case-memory-candidate",
-    "verified-fact-reference",
-]
-
-
-class ProviderFieldPolicy(CanonicalModel):
-    field: ProviderDataField
-    classification: Literal["public", "internal", "sensitive"]
-    dlp_action: Literal["reject", "redact"]
-
-
-class ProviderInputFieldPolicy(CanonicalModel):
-    json_pointer: str = Field(pattern=r"^/[^/]+(?:/[^/]+)*$")
-    classification: Literal["public", "internal", "sensitive"]
-    dlp_action: Literal["reject", "redact"]
-
-
-class ProviderDataPolicy(CanonicalModel):
-    input_fields: list[ProviderInputFieldPolicy] = Field(default_factory=list)
-    envelope_fields: list[ProviderFieldPolicy] = Field(default_factory=list)
-
-    @model_validator(mode="after")
-    def validate_fields(self) -> Self:
-        names = [rule.field for rule in self.envelope_fields]
-        pointers = [rule.json_pointer for rule in self.input_fields]
-        if len(names) != len(set(names)) or len(pointers) != len(set(pointers)):
-            raise ValueError("Provider 字段发送规则重复")
-        return self
-
-
-class ToolNetworkPolicy(CanonicalModel):
-    mode: Literal["forbidden"] = "forbidden"
-
-
-class RuntimeArtifact(CanonicalModel):
-    value: str = Field(min_length=1)
-    media_type: str = Field(min_length=1)
-    byte_size: int = Field(ge=1)
-    sha256: str = Field(pattern=r"^[a-f0-9]{64}$")
-
-
-class RuntimeRelease(CanonicalModel):
-    release_id: str = Field(min_length=1, max_length=80)
-    operation_version: str = Field(min_length=1, max_length=80)
-    workflow_version: str = Field(min_length=1, max_length=80)
-    prompt_version: str = Field(min_length=1, max_length=80)
-    route_version: str = Field(min_length=1, max_length=80)
-    output_schema_version: str = Field(min_length=1, max_length=80)
-    tool_schema_version: str = Field(min_length=1, max_length=80)
-    manifest_digest: str = Field(pattern=r"^[a-f0-9]{64}$")
-
-
-class VlmReadinessPin(CanonicalModel):
-    key: str = Field(min_length=1, max_length=160)
-    identity: str = Field(
-        pattern=(
-            r"^windy-deployment-v1_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-"
-            r"[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
-        )
-    )
-    release_digest: str = Field(pattern=r"^sha256:[a-f0-9]{64}$")
-    offers_digest: str = Field(pattern=r"^sha256:[a-f0-9]{64}$")
-
-
-class RunReportingContext(CanonicalModel):
-    """Trusted platform metadata for reporting, never an authorization fact."""
-
-    actor_id: str = Field(min_length=1, max_length=64)
-    actor_type: str = Field(min_length=1, max_length=32)
-    department_id: str | None = Field(default=None, max_length=64)
-
-
-class ContextSourceRequest(CanonicalModel):
-    module_key: str = Field(min_length=1, max_length=160)
-    kind: ContextSourceKind
-    id: str = Field(min_length=1, max_length=200)
-
-
-class LongSessionContext(CanonicalModel):
-    session_id: str = Field(pattern=r"^session_[A-Za-z0-9_-]+$", max_length=80)
-    turn_id: str = Field(pattern=r"^turn_[A-Za-z0-9_-]+$", max_length=96)
-    case_id: str | None = Field(default=None, min_length=1, max_length=160)
-    sources: list[ContextSourceRequest] = Field(min_length=1, max_length=100)
-
-
-def legacy_release() -> RuntimeRelease:
-    return RuntimeRelease(
-        release_id="legacy",
-        operation_version="legacy",
-        workflow_version="legacy",
-        prompt_version="legacy",
-        route_version="legacy",
-        output_schema_version="legacy",
-        tool_schema_version="legacy",
-        manifest_digest="0" * 64,
-    )
-
-
-class StartRunRequest(CanonicalModel):
-    kind: Literal["agent"] = "agent"
-    operation_key: str = Field(min_length=1)
-    input: JsonValue
-    input_modalities: list[InputModality] = Field(
-        default_factory=lambda: default_modalities(),
-        min_length=1,
-    )
-    required_capabilities: list[str] = Field(default_factory=list, max_length=32)
-    artifacts: list[RuntimeArtifact] = Field(default_factory=list, max_length=16)
-    instructions: str = ""
-    user_prompt: str = ""
-    output_schema_key: str = ""
-    output_schema: dict[str, JsonValue] | None = None
-    allowed_tools: list[RuntimeToolDefinition] = Field(default_factory=list)
-    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)
-    execution_grant: str = ""
-    tool_host_url: str = ""
-    readiness_pin: VlmReadinessPin | None = None
-    model_pin: ModelCoordinatePin | None = None
-    release: RuntimeRelease = Field(default_factory=legacy_release)
-    trace_id: str = Field(default="", max_length=160)
-    reporting: RunReportingContext | None = None
-    long_session: LongSessionContext | None = None
-
-
-class StartRunResponse(CanonicalModel):
-    run_id: str
-    status: RunStatus
-    events_url: str
-
-
-class RunStatusResponse(CanonicalModel):
-    run_id: str
-    status: RunStatus
-    last_sequence: int = Field(ge=0)
-    terminal_event: dict[str, JsonValue] | None = None
-
-
-class RunResultResponse(CanonicalModel):
-    run_id: str
-    status: Literal["completed"]
-    output: JsonValue
-
-
-class CancelRunRequest(CanonicalModel):
-    reason: str | None = None
-
-
-class CancelRunResponse(CanonicalModel):
-    run_id: str
-    status: RunStatus
-
-
-class AgentError(CanonicalModel):
-    code: AgentErrorCode
-    message: str
-    request_id: str
-    retryable: bool
-
-
-class EvaluationResultRequest(CanonicalModel):
-    release_id: str = Field(min_length=1, max_length=80)
-    evaluation_set_key: str = Field(min_length=1, max_length=160)
-    evaluation_set_version: str = Field(min_length=1, max_length=80)
-    metrics: dict[str, float] = Field(min_length=1, max_length=100)
-
-    @field_validator("metrics")
-    @classmethod
-    def validate_metrics(cls, metrics: dict[str, float]) -> dict[str, float]:
-        if not all(isfinite(value) for value in metrics.values()):
-            raise ValueError("评估指标必须是有限数值")
-        return metrics
-
-
-class EvaluationResultResponse(CanonicalModel):
-    evaluation_id: str
-    release_id: str
-
-
-def default_modalities() -> list[InputModality]:
-    return ["text"]

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

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections.abc import AsyncIterator
-
-from .engine import (
-    EngineCompleted,
-    EngineRunRequest,
-    EngineSignal,
-    OutputDelta,
-    UsageReported,
-)
-from .engine_identity import DIRECT_ENGINE_ID
-from .report_types import UsageFacts
-
-
-class DeterministicEngineAdapter:
-    """Deterministic test adapter. It never calls a model or remote service."""
-
-    operations = frozenset({"test.echo", "test.wait", "test.fail"})
-    engine_id = DIRECT_ENGINE_ID
-
-    def __init__(self) -> None:
-        self._cancellations: dict[str, asyncio.Event] = {}
-
-    @property
-    def capabilities(self) -> tuple[str, ...]:
-        return ("text-generation",)
-
-    @property
-    def input_modalities(self) -> tuple[str, ...]:
-        return ("text",)
-
-    def supports(self, operation_key: str) -> bool:
-        return operation_key in self.operations
-
-    async def execute(
-        self,
-        request: EngineRunRequest,
-    ) -> AsyncIterator[EngineSignal]:
-        cancellation = self._cancellations.setdefault(request.run_id, asyncio.Event())
-        try:
-            if request.operation_key == "test.fail":
-                raise RuntimeError("upstream-secret-body")
-            if request.operation_key == "test.wait":
-                await cancellation.wait()
-                return
-
-            text = "deterministic"
-            if isinstance(request.input, dict):
-                input_text = request.input.get("text")
-                if isinstance(input_text, str):
-                    text = input_text
-            yield OutputDelta(text)
-            yield UsageReported(1, UsageFacts())
-            yield EngineCompleted(request.input)
-        finally:
-            self._cancellations.pop(request.run_id, None)
-
-    async def cancel(self, run_id: str) -> None:
-        cancellation = self._cancellations.get(run_id)
-        if cancellation is not None:
-            cancellation.set()