create-windy 0.8.3 → 0.10.0

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

@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-import re
-
-SCHEMA_VERSION = 1
-PROTOCOL_VERSION = 1
-RUNTIME_KIND = "agent"
-COMPATIBILITY_PATH = "/api/agent/runtime/compatibility"
-PROTOCOL_HEADER = "X-Windy-Agent-Runtime-Protocol"
-OFFER_DIGEST_HEADER = "X-Windy-Agent-Runtime-Offer-Digest"
-TOOL_CALLBACK_CONTRACT_VERSION = 1
-TOOL_CALLBACK_AUTHENTICATION = "windy-internal-bearer-v1"
-PROTOCOL_FEATURES = (
-    "canonical-sse-replay.v1",
-    "execution-grant-forwarding.v1",
-    "operation-release-attestation.v1",
-    "run-cancel.v1",
-    "run-lifecycle.v1",
-    "runtime-reporting.v1",
-    "tool-callback.v1",
-)
-
-_STABLE_VALUE = re.compile(r"^[a-z0-9][a-z0-9._-]{0,159}$")
-
-
-class RuntimeCompatibilityError(ValueError):
-    pass
-
-
-def runtime_compatibility_offer(engine_id: str) -> dict[str, object]:
-    if not _STABLE_VALUE.fullmatch(engine_id):
-        raise RuntimeCompatibilityError("Agent Runtime engineId invalid")
-    protocol_versions = [PROTOCOL_VERSION]
-    protocol_features = sorted(PROTOCOL_FEATURES)
-    tool_callback: dict[str, object] = {
-        "contractVersion": TOOL_CALLBACK_CONTRACT_VERSION,
-        "authentication": TOOL_CALLBACK_AUTHENTICATION,
-    }
-    release_digest = _digest(
-        {
-            "runtimeKind": RUNTIME_KIND,
-            "engineId": engine_id,
-            "protocolVersions": protocol_versions,
-        }
-    )
-    capabilities_digest = _digest(
-        {
-            "protocolFeatures": protocol_features,
-            "toolCallback": tool_callback,
-        }
-    )
-    body: dict[str, object] = {
-        "schemaVersion": SCHEMA_VERSION,
-        "runtimeKind": RUNTIME_KIND,
-        "engineId": engine_id,
-        "protocolVersions": protocol_versions,
-        "protocolFeatures": protocol_features,
-        "toolCallback": tool_callback,
-        "releaseDigest": release_digest,
-        "capabilitiesDigest": capabilities_digest,
-    }
-    return {**body, "offerDigest": _digest(body)}
-
-
-def validate_runtime_compatibility_pin(
-    protocol_header: str | None,
-    offer_digest_header: str | None,
-    engine_id: str,
-) -> None:
-    if protocol_header is None and offer_digest_header is None:
-        return
-    if protocol_header is None or offer_digest_header is None:
-        raise RuntimeCompatibilityError("Agent Runtime compatibility pin incomplete")
-    if protocol_header != str(PROTOCOL_VERSION):
-        raise RuntimeCompatibilityError("Agent Runtime protocol unsupported")
-    expected = runtime_compatibility_offer(engine_id)["offerDigest"]
-    if offer_digest_header != expected:
-        raise RuntimeCompatibilityError("Agent Runtime offer digest mismatch")
-
-
-def _digest(value: object) -> str:
-    encoded = json.dumps(
-        value,
-        ensure_ascii=False,
-        separators=(",", ":"),
-    ).encode()
-    return f"sha256:{hashlib.sha256(encoded).hexdigest()}"

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

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-import os
-
-from .config import EnvironmentSecretResolver, OpenAiCompatibleConfig
-from .context_version_port import HttpContextVersionPort, UnavailableContextVersionPort
-from .engine import AgentEngineAdapter
-from .openai_engine import OpenAiCompatibleEngineAdapter
-from .openai_provider import OpenAiCompatibleProvider
-from .postgres_report_store import PostgresAgentRuntimeReportStore
-from .postgres_store import PostgresRunStore
-from .provider_audit import ProviderAuditStore
-from .provider_governance import ProviderRequestGovernance
-from .report_store import (
-    AgentRuntimeReportStore,
-    InMemoryAgentRuntimeReportStore,
-)
-from .sqlite_store import SqliteRunStore
-from .store import InMemoryRunStore, RunStore
-from .store_cipher import RunStoreCipher
-from .tool_host import ToolHostClient
-from .unavailable_engine import UnavailableEngineAdapter
-
-
-def default_engine(
-    report_store: AgentRuntimeReportStore | None = None,
-) -> AgentEngineAdapter:
-    config = OpenAiCompatibleConfig.from_environment()
-    if config is None:
-        return UnavailableEngineAdapter()
-    internal_token = os.environ.get("AGENT_SERVER_INTERNAL_TOKEN", "").strip()
-    if not internal_token:
-        raise ValueError("Agent Server Provider 已配置但内部 Token 缺失")
-    context_host_url = os.environ.get("AGENT_CONTEXT_HOST_URL", "").strip()
-    return OpenAiCompatibleEngineAdapter(
-        OpenAiCompatibleProvider(
-            config,
-            EnvironmentSecretResolver(os.environ),
-        ),
-        ToolHostClient(internal_token),
-        ProviderRequestGovernance(
-            ProviderAuditStore(
-                required_environment("AI_PROVIDER_AUDIT_STORE_PATH"),
-                retention_days=provider_audit_retention_days(),
-            )
-        ),
-        report_store,
-        (
-            HttpContextVersionPort(context_host_url, internal_token)
-            if context_host_url
-            else UnavailableContextVersionPort()
-        ),
-    )
-
-
-def default_store() -> RunStore:
-    database_url = os.environ.get("AGENT_DATABASE_URL", "").strip()
-    path = os.environ.get("AGENT_RUN_STORE_PATH", "").strip()
-    if not database_url and not path:
-        return InMemoryRunStore()
-    cipher = RunStoreCipher(required_environment("AGENT_RUN_ENCRYPTION_SECRET"))
-    return (
-        PostgresRunStore(database_url, cipher)
-        if database_url
-        else SqliteRunStore(path, cipher)
-    )
-
-
-def default_report_store() -> AgentRuntimeReportStore:
-    database_url = os.environ.get("AGENT_DATABASE_URL", "").strip()
-    retention_days = report_retention_days()
-    return (
-        PostgresAgentRuntimeReportStore(database_url, retention_days)
-        if database_url
-        else InMemoryAgentRuntimeReportStore(retention_days)
-    )
-
-
-def required_environment(key: str) -> str:
-    value = os.environ.get(key, "").strip()
-    if not value:
-        raise ValueError(f"Provider 已配置但缺少 {key}")
-    return value
-
-
-def provider_audit_retention_days() -> int:
-    raw = os.environ.get("AI_PROVIDER_AUDIT_RETENTION_DAYS", "90")
-    try:
-        value = int(raw)
-    except ValueError as error:
-        raise ValueError("AI_PROVIDER_AUDIT_RETENTION_DAYS 必须是整数") from error
-    if not 1 <= value <= 3650:
-        raise ValueError("AI_PROVIDER_AUDIT_RETENTION_DAYS 超出允许范围")
-    return value
-
-
-def report_retention_days() -> int:
-    raw = os.environ.get("AI_RUNTIME_REPORT_RETENTION_DAYS", "90")
-    try:
-        value = int(raw)
-    except ValueError as error:
-        raise ValueError("AI_RUNTIME_REPORT_RETENTION_DAYS 必须是整数") from error
-    if not 1 <= value <= 3650:
-        raise ValueError("AI_RUNTIME_REPORT_RETENTION_DAYS 超出允许范围")
-    return value

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

@@ -1,57 +0,0 @@
-"""Safe attempt diagnostics, separate from the canonical Run store and audit."""
-
-from __future__ import annotations
-
-import logging
-import time
-
-from .store import RunRecord
-
-logger = logging.getLogger(__name__)
-
-
-class AgentOperationalAttempt:
-    def __init__(self, record: RunRecord) -> None:
-        self._run_id = record.run_id
-        self._trace_id = record.trace_id
-        self._started_at: float | None = None
-        self._finished = False
-
-    def start(self) -> None:
-        if self._started_at is not None:
-            return
-        self._started_at = time.monotonic()
-        self._emit("agent.run.attempt.started")
-
-    def finish(self, status: str) -> None:
-        if self._started_at is None or self._finished:
-            return
-        self._finished = True
-        self._emit(
-            "agent.run.attempt.completed",
-            operational_status=status,
-            operational_duration_ms=round(
-                (time.monotonic() - self._started_at) * 1_000, 3
-            ),
-        )
-
-    def _emit(self, event: str, **fields: str | float) -> None:
-        try:
-            emit = (
-                logger.warning
-                if event == "agent.run.attempt.completed"
-                and fields.get("operational_status") != "completed"
-                else logger.info
-            )
-            emit(
-                "Agent 执行阶段",
-                extra={
-                    "operational_event": event,
-                    "run_id": self._run_id,
-                    "trace_id": self._trace_id,
-                    **fields,
-                },
-            )
-        except Exception:
-            # 日志出口失败不能改变 Run 或租约的业务结果。
-            return

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

@@ -1,325 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-import uuid
-
-from .approval_resolution import resolve_pending_approval
-from .artifact_input import ArtifactLoader
-from .contracts import StartRunRequest
-from .engine import (
-    AgentEngineAdapter,
-    EngineCompleted,
-    SafeEngineError,
-)
-from .fingerprint import request_fingerprint, resolved_release
-from .lease import cancel_on_lease_loss, lease_failed
-from .report_lifecycle import (
-    append_and_sync_canonical_event,
-    ensure_run_report_safely,
-    start_run_report_safely,
-    sync_terminal_from_canonical,
-)
-from .report_store import AgentRuntimeReportStore
-from .run_admission import RunAdmission
-from .run_capacity import RunCapacity, RunCapacityReservation
-from .service_control import AgentRunControlMixin
-from .service_errors import OperationNotFoundError
-from .service_execution import build_engine_run_request
-from .service_tasks import complete_task, renew_lease, run_admitted
-from .signal_events import canonical_signal_event
-from .store import RunRecord, RunStore
-from .telemetry import AgentRunTrace
-from .vision_requirement import require_vision_readiness
-
-logger = logging.getLogger(__name__)
-
-
-class AgentRunService(AgentRunControlMixin):
-    def __init__(
-        self,
-        engine: AgentEngineAdapter,
-        store: RunStore,
-        report_store: AgentRuntimeReportStore,
-        artifact_loader: ArtifactLoader | None = None,
-        max_concurrent_runs: int = 1,
-        max_queue_depth: int = 0,
-    ) -> None:
-        self.engine = engine
-        self.store = store
-        self.report_store = report_store
-        self.artifact_loader = artifact_loader
-        self._tasks: set[asyncio.Task[None]] = set()
-        self._active_run_ids: set[str] = set()
-        self._recovery_task: asyncio.Task[None] | None = None
-        self._admission = RunAdmission(
-            store,
-            RunCapacity(max_concurrent_runs, max_queue_depth),
-        )
-
-    async def start(
-        self,
-        request: StartRunRequest,
-        idempotency_key: str,
-    ) -> RunRecord:
-        if not getattr(self.engine, "configured", True):
-            raise SafeEngineError(
-                "RUNTIME_UNAVAILABLE",
-                "Agent Provider 尚未配置",
-                retryable=False,
-            )
-        if not self.engine.supports(request.operation_key):
-            raise OperationNotFoundError
-        missing = set(request.required_capabilities) - set(self.engine.capabilities)
-        unsupported = set(request.input_modalities) - set(self.engine.input_modalities)
-        if missing or unsupported:
-            raise SafeEngineError(
-                "MODEL_ROUTE_UNAVAILABLE",
-                "模型 Deployment 缺少 Operation 所需能力或输入模态",
-                retryable=True,
-            )
-        fingerprint = request_fingerprint(request)
-        candidate = RunRecord(
-            run_id=f"run_{uuid.uuid4().hex}",
-            engine_id=self.engine.engine_id,
-            operation_key=request.operation_key,
-            input=request.input,
-            idempotency_key=idempotency_key,
-            fingerprint=fingerprint,
-            release=resolved_release(request),
-            trace_id=request.trace_id,
-        )
-        admission = await self._admission.admit(
-            candidate,
-            request.model_dump(by_alias=True),
-        )
-        record = admission.record
-        await ensure_run_report_safely(
-            self.report_store,
-            record.run_id,
-            request,
-            self.engine.engine_id,
-        )
-        if admission.reservation:
-            await self._spawn(record, request, admission.reservation)
-        return record
-
-    async def recover(self) -> None:
-        await self._recover_once()
-        if self._recovery_task is None:
-            self._recovery_task = asyncio.create_task(self._recovery_loop())
-
-    async def close(self) -> None:
-        if self._recovery_task:
-            self._recovery_task.cancel()
-        for task in list(self._tasks):
-            task.cancel()
-        await asyncio.gather(
-            *([self._recovery_task] if self._recovery_task else []),
-            *self._tasks,
-            return_exceptions=True,
-        )
-        await self.store.close()
-        await self.report_store.close()
-
-    async def _recover_once(self) -> None:
-        for record, raw in await self.store.recoverable():
-            if record.run_id in self._active_run_ids:
-                continue
-            request = StartRunRequest.model_validate(raw)
-            reservation = await self._admission.reserve_recovery()
-            if not reservation:
-                return
-            await ensure_run_report_safely(
-                self.report_store,
-                record.run_id,
-                request,
-                record.engine_id,
-            )
-            if record.engine_id != self.engine.engine_id:
-                await self._fail(
-                    record.run_id,
-                    SafeEngineError(
-                        "RUNTIME_UNAVAILABLE",
-                        "Agent Engine 已升级，旧 Run 无法安全恢复",
-                        retryable=False,
-                    ),
-                )
-                await self.store.clear_invocation(record.run_id)
-                continue
-            await self._spawn(
-                record,
-                request,
-                reservation,
-                resumed=True,
-            )
-
-    async def _recovery_loop(self) -> None:
-        while True:
-            await asyncio.sleep(10)
-            try:
-                await self._recover_once()
-            except asyncio.CancelledError:
-                raise
-            except Exception:
-                logger.exception("Agent Run 恢复轮询失败，将继续重试")
-
-    async def _execute(
-        self,
-        record: RunRecord,
-        invocation: StartRunRequest,
-        resumed: bool = False,
-    ) -> None:
-        execution_task = asyncio.current_task()
-        if execution_task is None:
-            raise RuntimeError("Agent Run 缺少执行任务")
-        lease_task = asyncio.create_task(renew_lease(self.store, record.run_id))
-        run_trace = AgentRunTrace(record)
-        run_trace.start()
-        final_status = "unknown"
-        lease_task.add_done_callback(
-            lambda completed: cancel_on_lease_loss(completed, execution_task)
-        )
-        try:
-            await asyncio.wait_for(
-                require_vision_readiness(self.engine, invocation),
-                timeout=invocation.limits.max_duration_seconds,
-            )
-            await start_run_report_safely(self.report_store, record.run_id)
-            if await append_and_sync_canonical_event(
-                self.report_store,
-                self.store,
-                record.run_id,
-                "run.resumed" if resumed else "run.started",
-            ):
-                return
-            if invocation.artifacts and not self.artifact_loader:
-                raise SafeEngineError(
-                    "RUNTIME_UNAVAILABLE",
-                    "Agent Artifact Runtime 未配置",
-                    retryable=True,
-                )
-            prepared = (
-                await self.artifact_loader.prepare(
-                    invocation.artifacts,
-                    invocation.input_modalities,
-                    invocation.limits,
-                )
-                if self.artifact_loader
-                else ()
-            )
-            if await append_and_sync_canonical_event(
-                self.report_store,
-                self.store,
-                record.run_id,
-                "input.prepared",
-                {
-                    "artifactCount": len(prepared),
-                    "inputModalities": list(invocation.input_modalities),
-                },
-            ):
-                return
-            request = build_engine_run_request(record, invocation, prepared)
-            async with asyncio.timeout(invocation.limits.max_duration_seconds):
-                async for signal in self.engine.execute(request):
-                    if isinstance(signal, EngineCompleted):
-                        await self.store.complete(record.run_id, signal.output)
-                        await sync_terminal_from_canonical(
-                            self.report_store,
-                            self.store,
-                            record.run_id,
-                        )
-                        return
-                    event_type, fields = canonical_signal_event(signal)
-                    if await append_and_sync_canonical_event(
-                        self.report_store,
-                        self.store,
-                        record.run_id,
-                        event_type,
-                        fields,
-                    ):
-                        return
-            await self._fail(
-                record.run_id,
-                SafeEngineError(
-                    "STREAM_INTERRUPTED",
-                    "Agent Runtime 未返回终态",
-                    retryable=True,
-                ),
-            )
-        except SafeEngineError as error:
-            await self._fail(record.run_id, error)
-        except TimeoutError:
-            current = await self.get(record.run_id)
-            await resolve_pending_approval(self.store, current, "timed-out")
-            await self._fail(
-                record.run_id,
-                SafeEngineError(
-                    "RUN_TIMEOUT",
-                    "Agent Run 执行超时",
-                    retryable=True,
-                ),
-            )
-        except asyncio.CancelledError:
-            if lease_failed(lease_task):
-                await self._fail(
-                    record.run_id,
-                    SafeEngineError(
-                        "RUNTIME_UNAVAILABLE",
-                        "Agent Run 租约已丢失",
-                        retryable=True,
-                    ),
-                )
-                return
-            raise
-        except Exception:
-            await self._fail(
-                record.run_id,
-                SafeEngineError(
-                    "RUNTIME_UNAVAILABLE",
-                    "Agent Runtime 执行失败",
-                    retryable=True,
-                ),
-            )
-        finally:
-            try:
-                lease_task.cancel()
-                await asyncio.gather(lease_task, return_exceptions=True)
-                final_record = await self.store.get(record.run_id)
-                if final_record and final_record.terminal:
-                    await self.store.clear_invocation(record.run_id)
-                if final_record:
-                    final_status = final_record.status
-                try:
-                    await self.store.release_lease(record.run_id)
-                except KeyError:
-                    pass
-            finally:
-                run_trace.finish(final_status)
-
-    async def _spawn(
-        self,
-        record: RunRecord,
-        request: StartRunRequest,
-        reservation: RunCapacityReservation,
-        resumed: bool = False,
-    ) -> None:
-        if record.run_id in self._active_run_ids:
-            await reservation.release()
-            return
-        self._active_run_ids.add(record.run_id)
-        task = asyncio.create_task(
-            run_admitted(
-                reservation,
-                lambda: self._execute(record, request, resumed),
-            )
-        )
-        self._tasks.add(task)
-        task.add_done_callback(
-            lambda completed: complete_task(
-                self._tasks,
-                self._active_run_ids,
-                record.run_id,
-                completed,
-            )
-        )

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

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from .approval_resolution import resolve_pending_approval
-from .engine import AgentEngineAdapter, SafeEngineError
-from .report_lifecycle import append_and_sync_canonical_event
-from .report_store import AgentRuntimeReportStore
-from .service_errors import RunNotFoundError
-from .signal_events import canonical_failure_fields
-from .store import RunRecord, RunStore
-
-
-class AgentRunControlMixin:
-    """Queries, cancellation and terminal control shared by run execution."""
-
-    engine: AgentEngineAdapter
-    store: RunStore
-    report_store: AgentRuntimeReportStore
-
-    async def record_evaluation(
-        self,
-        release_id: str,
-        evaluation_set_key: str,
-        evaluation_set_version: str,
-        metrics: dict[str, float],
-    ) -> str:
-        return await self.store.record_evaluation(
-            release_id,
-            evaluation_set_key,
-            evaluation_set_version,
-            metrics,
-        )
-
-    async def get(self, run_id: str) -> RunRecord:
-        record = await self.store.get(run_id)
-        if record is None:
-            raise RunNotFoundError
-        return record
-
-    async def probe(self) -> None:
-        await self.store.probe()
-
-    async def cancel(self, run_id: str) -> RunRecord:
-        record = await self.get(run_id)
-        if record.terminal:
-            return record
-        await self.engine.cancel(run_id)
-        await resolve_pending_approval(self.store, record, "cancelled")
-        await append_and_sync_canonical_event(
-            self.report_store,
-            self.store,
-            run_id,
-            "run.cancelled",
-        )
-        return await self.get(run_id)
-
-    async def _fail(self, run_id: str, failure: SafeEngineError) -> None:
-        await append_and_sync_canonical_event(
-            self.report_store,
-            self.store,
-            run_id,
-            "run.failed",
-            canonical_failure_fields(failure),
-            fallback_safe_error_code=failure.code,
-        )

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

@@ -1,4 +0,0 @@
-class RunNotFoundError(Exception): ...
-
-
-class OperationNotFoundError(Exception): ...

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

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from .contracts import StartRunRequest
-from .engine import EngineRunRequest, PreparedArtifact
-from .store import RunRecord
-
-
-def build_engine_run_request(
-    record: RunRecord,
-    invocation: StartRunRequest,
-    artifacts: tuple[PreparedArtifact, ...],
-) -> EngineRunRequest:
-    return EngineRunRequest(
-        run_id=record.run_id,
-        operation_key=record.operation_key,
-        input=invocation.input,
-        input_modalities=tuple(invocation.input_modalities),
-        required_capabilities=tuple(invocation.required_capabilities),
-        artifacts=artifacts,
-        instructions=invocation.instructions,
-        user_prompt=invocation.user_prompt,
-        output_schema_key=invocation.output_schema_key,
-        output_schema=invocation.output_schema,
-        allowed_tools=tuple(invocation.allowed_tools),
-        limits=invocation.limits,
-        provider_egress=invocation.provider_egress,
-        provider_data_policy=invocation.provider_data_policy,
-        tool_network_policy=invocation.tool_network_policy,
-        model_pin=invocation.model_pin,
-        execution_grant=invocation.execution_grant,
-        tool_host_url=invocation.tool_host_url,
-        long_session=invocation.long_session,
-        prompt_version=invocation.release.prompt_version,
-    )