create-windy 0.8.2 → 0.9.1

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

@@ -1,137 +0,0 @@
-from __future__ import annotations
-
-from .store import CanonicalEvent, RunRecord
-
-
-def project_run_trajectory(record: RunRecord | None) -> dict[str, object]:
-    if record is None:
-        return {"available": False, "events": []}
-    projected: list[dict[str, object]] = []
-    tool_keys: dict[str, str] = {}
-    output: dict[str, object] | None = None
-    for event in record.events:
-        event_type = text(event.get("type"))
-        sequence = integer(event.get("sequence"))
-        if not event_type or sequence is None:
-            continue
-        if event_type == "output.delta":
-            delta = event.get("text")
-            if not isinstance(delta, str):
-                continue
-            if output is None:
-                output = item(sequence, event_type, "模型生成输出")
-                output.update(
-                    {
-                        "sequenceEnd": sequence,
-                        "deltaCount": 0,
-                        "outputCharacters": 0,
-                    }
-                )
-                projected.append(output)
-            output["sequenceEnd"] = sequence
-            delta_count = integer(output.get("deltaCount"), 0)
-            output_characters = integer(output.get("outputCharacters"), 0)
-            if delta_count is None or output_characters is None:
-                continue
-            output["deltaCount"] = delta_count + 1
-            output["outputCharacters"] = output_characters + len(delta)
-            continue
-        output = None
-        current = event_item(event_type, sequence, event, tool_keys)
-        if current is not None:
-            projected.append(current)
-    return {"available": True, "events": projected}
-
-
-def event_item(
-    event_type: str,
-    sequence: int,
-    event: CanonicalEvent,
-    tool_keys: dict[str, str],
-) -> dict[str, object] | None:
-    if event_type in {"run.started", "run.resumed"}:
-        return item(
-            sequence,
-            event_type,
-            "开始执行" if event_type == "run.started" else "恢复执行",
-        )
-    if event_type == "input.prepared":
-        result = item(sequence, event_type, "输入已准备")
-        result["artifactCount"] = integer(event.get("artifactCount"), 0)
-        modalities = event.get("inputModalities")
-        result["inputModalities"] = (
-            [value for value in modalities if isinstance(value, str)]
-            if isinstance(modalities, list)
-            else []
-        )
-        return result
-    if event_type == "tool.requested":
-        call_id = text(event.get("toolCallId"))
-        tool_key = text(event.get("toolKey"))
-        if call_id and tool_key:
-            tool_keys[call_id] = tool_key
-        result = item(sequence, event_type, "请求 Tool")
-        if tool_key:
-            result["toolKey"] = tool_key
-        return result
-    if event_type in {"tool.completed", "approval.required", "approval.resolved"}:
-        result = item(
-            sequence,
-            event_type,
-            {
-                "tool.completed": "Tool 已完成",
-                "approval.required": "等待审批",
-                "approval.resolved": "审批已处理",
-            }[event_type],
-        )
-        call_id = text(event.get("toolCallId"))
-        tool_key = tool_keys.get(call_id or "")
-        if tool_key:
-            result["toolKey"] = tool_key
-        outcome = text(event.get("outcome"))
-        if event_type == "approval.resolved" and outcome:
-            result["approvalOutcome"] = outcome
-        return result
-    if event_type == "usage.reported":
-        result = item(sequence, event_type, "Provider 用量已上报")
-        attempt = integer(event.get("attemptSequence"))
-        usage = event.get("usage")
-        total = integer(usage.get("totalTokens")) if isinstance(usage, dict) else None
-        if attempt is not None:
-            result["attemptSequence"] = attempt
-        if total is not None:
-            result["totalTokens"] = total
-        return result
-    if event_type in {"run.completed", "run.cancelled", "run.failed"}:
-        result = item(
-            sequence,
-            event_type,
-            {
-                "run.completed": "执行完成",
-                "run.cancelled": "执行已取消",
-                "run.failed": "执行失败",
-            }[event_type],
-        )
-        error = event.get("error")
-        code = text(error.get("code")) if isinstance(error, dict) else None
-        if code:
-            result["errorCode"] = code
-        return result
-    return None
-
-
-def item(sequence: int, event_type: str, title: str) -> dict[str, object]:
-    return {
-        "sequence": sequence,
-        "sequenceEnd": sequence,
-        "type": event_type,
-        "title": title,
-    }
-
-
-def text(value: object) -> str | None:
-    return value if isinstance(value, str) and value else None
-
-
-def integer(value: object, fallback: int | None = None) -> int | None:
-    return value if isinstance(value, int) and value >= 0 else fallback

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

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-
-from .engine import AgentEngineAdapter, EngineRunRequest, EngineSignal, SafeEngineError
-from .vlm_readiness import unavailable_vlm_snapshot
-
-
-class UnavailableEngineAdapter(AgentEngineAdapter):
-    """Explicit fail-closed runtime used when no Provider deployment is configured."""
-
-    ENGINE_ID = "windy.unavailable.v1"
-
-    @property
-    def engine_id(self) -> str:
-        return self.ENGINE_ID
-
-    @property
-    def configured(self) -> bool:
-        return False
-
-    @property
-    def capabilities(self) -> tuple[str, ...]:
-        return ()
-
-    @property
-    def input_modalities(self) -> tuple[str, ...]:
-        return ("text",)
-
-    @property
-    def max_concurrent_runs(self) -> int:
-        return 1
-
-    @property
-    def max_queue_depth(self) -> int:
-        return 0
-
-    def supports(self, operation_key: str) -> bool:
-        return bool(operation_key.strip())
-
-    async def execute(
-        self,
-        request: EngineRunRequest,
-    ) -> AsyncIterator[EngineSignal]:
-        del request
-        raise SafeEngineError(
-            "RUNTIME_UNAVAILABLE",
-            "Agent Provider 尚未配置",
-            retryable=False,
-        )
-        if False:
-            yield
-
-    async def cancel(self, run_id: str) -> None:
-        del run_id
-
-    async def readiness(self) -> dict[str, object]:
-        return unavailable_vlm_snapshot(configured=False)

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

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import json
-from collections.abc import Awaitable
-from typing import Protocol
-
-from .config import OpenAiCompatibleConfig
-from .contracts import JsonValue, RuntimeToolDefinition
-from .engine import SafeEngineError
-
-_PROBE_IMAGE = (
-    "data:image/png;base64,"
-    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/"
-    "pLvAAAAAElFTkSuQmCC"
-)
-_PROBE_PROMPT = '观察图片的主色。只返回 JSON：{\\"color\\":\\"red\\"}。'
-
-
-class ProbeTurn(Protocol):
-    @property
-    def text(self) -> str: ...
-
-    @property
-    def reported_model(self) -> str | None: ...
-
-
-class VisionProbeClient(Protocol):
-    config: OpenAiCompatibleConfig
-
-    def complete_turn(
-        self,
-        messages: list[dict[str, JsonValue]],
-        tools: tuple[RuntimeToolDefinition, ...],
-        output_schema_key: str = "",
-        output_schema: dict[str, JsonValue] | None = None,
-    ) -> Awaitable[ProbeTurn]: ...
-
-
-async def probe_vision(client: VisionProbeClient) -> None:
-    """Exercises the configured VLM with a bounded synthetic image."""
-    if not {"text-generation", "vision"}.issubset(client.config.capabilities) or not {
-        "text",
-        "image",
-    }.issubset(client.config.input_modalities):
-        raise SafeEngineError(
-            "RUNTIME_UNAVAILABLE",
-            "VLM 输入能力尚未配置",
-            retryable=False,
-        )
-    turn = await client.complete_turn(
-        [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": _PROBE_PROMPT},
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": _PROBE_IMAGE, "detail": "low"},
-                    },
-                ],
-            }
-        ],
-        (),
-        "windy.vlm-readiness.v1",
-        {
-            "type": "object",
-            "additionalProperties": False,
-            "properties": {"color": {"type": "string", "const": "red"}},
-            "required": ["color"],
-        },
-    )
-    try:
-        value = json.loads(turn.text)
-    except (TypeError, json.JSONDecodeError):
-        value = None
-    if value != {"color": "red"}:
-        raise SafeEngineError(
-            "PROVIDER_UNAVAILABLE",
-            "VLM 合成图片探测未通过",
-            retryable=False,
-        )
-    if turn.reported_model != client.config.model:
-        raise SafeEngineError(
-            "PROVIDER_UNAVAILABLE",
-            "VLM 合成图片探测的模型版本不匹配",
-            retryable=False,
-        )

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

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-from .contracts import StartRunRequest
-from .engine import SafeEngineError
-from .readiness_pin import readiness_pin_matches
-
-
-def requires_vision_readiness(request: StartRunRequest) -> bool:
-    return (
-        "vision" in request.required_capabilities or "image" in request.input_modalities
-    )
-
-
-async def require_vision_readiness(
-    engine: object,
-    request: StartRunRequest,
-) -> None:
-    """Fail closed immediately before every vision provider execution."""
-    if not requires_vision_readiness(request):
-        return
-    if not request.readiness_pin or not await readiness_pin_matches(
-        engine, request.readiness_pin.model_dump(by_alias=True)
-    ):
-        raise SafeEngineError(
-            "RUNTIME_UNAVAILABLE",
-            "VLM Runtime 当前不可用",
-            retryable=True,
-        )

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

@@ -1,247 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-import re
-import time
-from collections.abc import Awaitable, Callable
-from datetime import UTC, datetime, timedelta
-from typing import Protocol, cast
-
-from .config import OpenAiCompatibleConfig
-from .engine import SafeEngineError
-
-_DEPLOYMENT_IDENTITY = re.compile(
-    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}$"
-)
-
-
-class VisionProbeProvider(Protocol):
-    def probe_vision(self) -> Awaitable[None]: ...
-
-
-class VlmReadinessProbe:
-    """Produces a V1 Agent/VLM snapshot only after bounded image inference."""
-
-    def __init__(
-        self,
-        config: OpenAiCompatibleConfig,
-        provider: VisionProbeProvider,
-        *,
-        wall_clock: Callable[[], datetime] = lambda: datetime.now(UTC),
-        monotonic_clock: Callable[[], float] = time.monotonic,
-    ) -> None:
-        self.config = config
-        self.provider = provider
-        self.wall_clock = wall_clock
-        self.monotonic_clock = monotonic_clock
-
-    async def inspect(self) -> dict[str, object]:
-        checked_at = self._now()
-        if not self._configured():
-            return self._not_configured(checked_at)
-        started = self.monotonic_clock()
-        try:
-            await self.provider.probe_vision()
-        except SafeEngineError as error:
-            return self._failed(
-                checked_at,
-                started,
-                "RESOURCE_UNAVAILABLE" if error.retryable else "UNHEALTHY",
-                error.retryable,
-            )
-        except Exception:
-            return self._failed(checked_at, started, "CONNECTION_FAILED", True)
-        observed_at = self._now()
-        valid_until = checked_at + timedelta(seconds=self.config.readiness_ttl_seconds)
-        if observed_at >= valid_until:
-            return self._failed(checked_at, started, "TIMEOUT", True)
-        offers = self._offers()
-        deployment = self._deployment(offers)
-        return {
-            "schemaVersion": 1,
-            "status": "ready",
-            "configured": True,
-            "runtimeKind": "agent",
-            "observedAt": _time(observed_at),
-            "downstreamProbe": {
-                "status": "passed",
-                "checkedAt": _time(checked_at),
-                "validUntil": _time(valid_until),
-                "latencyMs": _latency(started, self.monotonic_clock),
-                "deploymentIdentity": deployment["identity"],
-                "releaseDigest": deployment["releaseDigest"],
-                "offersDigest": deployment["offersDigest"],
-            },
-            "deployment": deployment,
-            "offers": offers,
-            "unavailableReasons": [],
-        }
-
-    def _configured(self) -> bool:
-        return (
-            {"text-generation", "vision"}.issubset(self.config.capabilities)
-            and {"text", "image"}.issubset(self.config.input_modalities)
-            and bool(
-                self.config.readiness_deployment_identity
-                and _DEPLOYMENT_IDENTITY.fullmatch(
-                    self.config.readiness_deployment_identity
-                )
-            )
-            and _valid_digest(self.config.readiness_release_digest)
-        )
-
-    def _offers(self) -> list[dict[str, object]]:
-        return [
-            {
-                "variant": "vision",
-                "capabilities": ["text-generation", "vision"],
-                "inputModalities": ["text", "image"],
-                "outputModalities": ["text"],
-                "limits": {
-                    "maxDurationSeconds": self.config.max_duration_seconds,
-                    "maxInputBytes": self.config.max_input_bytes,
-                    "maxOutputBytes": self.config.max_response_bytes,
-                    "maxArtifacts": self.config.max_artifacts,
-                    "maxPixelsPerArtifact": self.config.max_pixels_per_artifact,
-                    "maxConcurrentRuns": self.config.max_concurrent_runs,
-                    "maxQueueDepth": self.config.max_queue_depth,
-                },
-            }
-        ]
-
-    def _deployment(self, offers: list[dict[str, object]]) -> dict[str, str]:
-        return {
-            "key": self.config.deployment_key,
-            "identity": self.config.readiness_deployment_identity or "",
-            "releaseDigest": self.config.readiness_release_digest or "",
-            "offersDigest": offers_digest(offers),
-        }
-
-    def _not_configured(self, observed_at: datetime) -> dict[str, object]:
-        return {
-            "schemaVersion": 1,
-            "status": "unavailable",
-            "configured": False,
-            "runtimeKind": "agent",
-            "observedAt": _time(observed_at),
-            "downstreamProbe": {"status": "not-run", "reason": "NOT_CONFIGURED"},
-            "deployment": None,
-            "offers": [],
-            "unavailableReasons": [
-                {"code": "RUNTIME_NOT_CONFIGURED", "retryable": False}
-            ],
-        }
-
-    def _failed(
-        self, checked_at: datetime, started: float, code: str, retryable: bool
-    ) -> dict[str, object]:
-        return {
-            "schemaVersion": 1,
-            "status": "unavailable",
-            "configured": True,
-            "runtimeKind": "agent",
-            "observedAt": _time(self._now()),
-            "downstreamProbe": {
-                "status": "failed",
-                "checkedAt": _time(checked_at),
-                "latencyMs": _latency(started, self.monotonic_clock),
-                "failureCode": code,
-                "retryable": retryable,
-            },
-            "deployment": self._deployment(self._offers()),
-            "offers": [],
-            "unavailableReasons": [
-                {
-                    "code": "DOWNSTREAM_PROBE_FAILED",
-                    "retryable": retryable,
-                    "subject": code,
-                }
-            ],
-        }
-
-    def _now(self) -> datetime:
-        return self.wall_clock().astimezone(UTC)
-
-
-def _valid_digest(value: str | None) -> bool:
-    return bool(value and len(value) == 71 and value.startswith("sha256:")) and all(
-        char in "0123456789abcdef" for char in (value or "")[7:]
-    )
-
-
-def offers_digest(offers: list[dict[str, object]]) -> str:
-    canonical = sorted(
-        (
-            {
-                "variant": offer["variant"],
-                "capabilities": sorted(cast(list[str], offer["capabilities"])),
-                "inputModalities": sorted(cast(list[str], offer["inputModalities"])),
-                "outputModalities": sorted(cast(list[str], offer["outputModalities"])),
-                "limits": offer["limits"],
-            }
-            for offer in offers
-        ),
-        key=lambda offer: str(offer["variant"]),
-    )
-    body = json.dumps(canonical, ensure_ascii=False, separators=(",", ":"))
-    return "sha256:" + hashlib.sha256(body.encode()).hexdigest()
-
-
-def unavailable_vlm_snapshot(
-    *,
-    configured: bool,
-    failure_code: str | None = None,
-    retryable: bool = True,
-) -> dict[str, object]:
-    """Build the public V1 fallback used when the VLM adapter itself faults."""
-    observed_at = _time(datetime.now(UTC))
-    if not configured:
-        return {
-            "schemaVersion": 1,
-            "status": "unavailable",
-            "configured": False,
-            "runtimeKind": "agent",
-            "observedAt": observed_at,
-            "downstreamProbe": {"status": "not-run", "reason": "NOT_CONFIGURED"},
-            "deployment": None,
-            "offers": [],
-            "unavailableReasons": [
-                {"code": "RUNTIME_NOT_CONFIGURED", "retryable": False}
-            ],
-        }
-    code = failure_code or "CONNECTION_FAILED"
-    return {
-        "schemaVersion": 1,
-        "status": "unavailable",
-        "configured": True,
-        "runtimeKind": "agent",
-        "observedAt": observed_at,
-        "downstreamProbe": {
-            "status": "failed",
-            "checkedAt": observed_at,
-            "latencyMs": 0,
-            "failureCode": code,
-            "retryable": retryable,
-        },
-        "deployment": None,
-        "offers": [],
-        "unavailableReasons": [
-            {
-                "code": "DOWNSTREAM_PROBE_FAILED",
-                "retryable": retryable,
-                "subject": code,
-            }
-        ],
-    }
-
-
-def _time(value: datetime) -> str:
-    return (
-        value.astimezone(UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
-    )
-
-
-def _latency(started: float, clock: Callable[[], float]) -> int:
-    return max(0, int((clock() - started) * 1_000))

package/template/apps/agent-server/tests/__init__.py

@@ -1 +0,0 @@
-"""Agent Server test package."""

package/template/apps/agent-server/tests/openai_provider_test_support.py

@@ -1,131 +0,0 @@
-from __future__ import annotations
-
-import json
-import tempfile
-
-import httpx
-
-from southwind_agent_server.config import (
-    EnvironmentSecretResolver,
-    OpenAiCompatibleConfig,
-    SecretRef,
-)
-from southwind_agent_server.contracts import (
-    ProviderDataPolicy,
-    ProviderEgress,
-    ProviderFieldPolicy,
-    ProviderInputFieldPolicy,
-    RuntimeLimits,
-    RuntimeToolDefinition,
-    ToolNetworkPolicy,
-)
-from southwind_agent_server.engine import EngineRunRequest
-from southwind_agent_server.openai_provider import OpenAiCompatibleProvider
-from southwind_agent_server.provider_audit import ProviderAuditStore
-from southwind_agent_server.provider_governance import ProviderRequestGovernance
-
-
-def create_provider(
-    transport: httpx.AsyncBaseTransport,
-) -> OpenAiCompatibleProvider:
-    environment = {"QWEN_API_KEY": "server-secret"}
-    return OpenAiCompatibleProvider(
-        OpenAiCompatibleConfig(
-            base_url="https://provider.test/v1",
-            model="qwen-compatible",
-            api_key_ref=SecretRef("env", "QWEN_API_KEY"),
-            https_host_allowlist=("provider.test",),
-        ),
-        EnvironmentSecretResolver(environment),
-        transport=transport,
-    )
-
-
-def runtime_request(tool_key: str) -> EngineRunRequest:
-    return EngineRunRequest(
-        run_id="run_1",
-        operation_key="business.answer",
-        input={"question": "记录"},
-        instructions="回答业务问题。",
-        user_prompt="有多少记录？",
-        allowed_tools=(
-            RuntimeToolDefinition(
-                key=tool_key,
-                label="查询记录",
-                description="查询当前数据范围内的记录。",
-            ),
-        ),
-        limits=RuntimeLimits(
-            max_duration_seconds=60,
-            max_output_bytes=4096,
-        ),
-        provider_egress=ProviderEgress(
-            mode="configured-endpoint",
-            deployment_key="ai.openai-compatible",
-        ),
-        provider_data_policy=provider_data_policy(),
-        tool_network_policy=ToolNetworkPolicy(mode="forbidden"),
-        execution_grant="grant_1",
-        tool_host_url="http://server:9747",
-    )
-
-
-def provider_data_policy() -> ProviderDataPolicy:
-    return ProviderDataPolicy(
-        input_fields=[
-            ProviderInputFieldPolicy(
-                json_pointer="/question",
-                classification="internal",
-                dlp_action="redact",
-            )
-        ],
-        envelope_fields=[
-            ProviderFieldPolicy(
-                field="instructions",
-                classification="internal",
-                dlp_action="reject",
-            ),
-            ProviderFieldPolicy(
-                field="user-prompt",
-                classification="internal",
-                dlp_action="redact",
-            ),
-            ProviderFieldPolicy(
-                field="tool-definitions",
-                classification="internal",
-                dlp_action="reject",
-            ),
-            ProviderFieldPolicy(
-                field="provider-output",
-                classification="internal",
-                dlp_action="redact",
-            ),
-            ProviderFieldPolicy(
-                field="tool-results",
-                classification="sensitive",
-                dlp_action="redact",
-            ),
-        ],
-    )
-
-
-def governance(path: str | None = None) -> ProviderRequestGovernance:
-    path = (
-        path
-        or tempfile.NamedTemporaryFile(
-            suffix=".sqlite3",
-            delete=False,
-        ).name
-    )
-    return ProviderRequestGovernance(ProviderAuditStore(path, retention_days=90))
-
-
-def sse_response(chunks: list[object]) -> httpx.Response:
-    body = "".join(
-        f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n" for chunk in chunks
-    )
-    return httpx.Response(
-        200,
-        headers={"content-type": "text/event-stream"},
-        content=f"{body}data: [DONE]\n\n",
-    )