create-windy 0.6.12 → 0.6.14

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

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .contracts import RuntimeLimits
+from .engine import SafeEngineError
+from .report_types import UsageFacts
+
+
+@dataclass
+class RuntimeBudgetAdmission:
+    limits: RuntimeLimits
+    input_tokens: int = 0
+    output_tokens: int = 0
+    tool_calls: int = 0
+
+    def before_attempt(self, attempt: int) -> int | None:
+        if (
+            self.limits.max_model_attempts is not None
+            and attempt > self.limits.max_model_attempts
+        ):
+            self._denied("Agent 模型调用次数超过 Workflow 上限")
+        if self.limits.max_input_tokens is not None:
+            if self.input_tokens >= self.limits.max_input_tokens:
+                self._denied("Agent 输入 Token 已耗尽")
+        if self.limits.max_output_tokens is None:
+            return None
+        remaining = self.limits.max_output_tokens - self.output_tokens
+        if remaining <= 0:
+            self._denied("Agent 输出 Token 已耗尽")
+        return remaining
+
+    def record_usage(self, usage: UsageFacts) -> None:
+        if usage.input_tokens is None or usage.output_tokens is None:
+            if (
+                self.limits.max_input_tokens is not None
+                or self.limits.max_output_tokens is not None
+            ):
+                self._denied("Provider 未返回 Workflow Token 计量")
+            return
+        self.input_tokens += usage.input_tokens
+        self.output_tokens += usage.output_tokens
+        if (
+            self.limits.max_input_tokens is not None
+            and self.input_tokens > self.limits.max_input_tokens
+        ):
+            self._denied("Agent 输入 Token 超过 Workflow 上限")
+        if (
+            self.limits.max_output_tokens is not None
+            and self.output_tokens > self.limits.max_output_tokens
+        ):
+            self._denied("Agent 输出 Token 超过 Workflow 上限")
+
+    def before_provider(self, conservative_input_tokens: int) -> None:
+        if conservative_input_tokens < 0:
+            self._denied("Agent 输入 Token 上界无效")
+        if (
+            self.limits.max_input_tokens is not None
+            and self.input_tokens + conservative_input_tokens
+            > self.limits.max_input_tokens
+        ):
+            self._denied("Agent 本次输入可能超过 Workflow Token 上限")
+
+    def reserve_tools(self, count: int) -> None:
+        self.tool_calls += count
+        if (
+            self.limits.max_tool_calls is not None
+            and self.tool_calls > self.limits.max_tool_calls
+        ):
+            self._denied("Agent Tool 调用次数超过 Workflow 上限")
+
+    @staticmethod
+    def _denied(message: str) -> None:
+        raise SafeEngineError("BUDGET_EXCEEDED", message, retryable=False)

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

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import os
 
-from .adk_adapter import AdkEngineAdapter
 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
@@ -18,6 +19,7 @@ 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(
@@ -25,11 +27,12 @@ def default_engine(
 ) -> AgentEngineAdapter:
     config = OpenAiCompatibleConfig.from_environment()
     if config is None:
-        return AdkEngineAdapter(report_store=report_store)
+        return UnavailableEngineAdapter()
     internal_token = os.environ.get("AGENT_SERVER_INTERNAL_TOKEN", "").strip()
     if not internal_token:
         raise ValueError("Agent Server Provider 已配置但内部 Token 缺失")
-    return AdkEngineAdapter(
+    context_host_url = os.environ.get("AGENT_CONTEXT_HOST_URL", "").strip()
+    return OpenAiCompatibleEngineAdapter(
         OpenAiCompatibleProvider(
             config,
             EnvironmentSecretResolver(os.environ),
@@ -42,6 +45,11 @@ def default_engine(
             )
         ),
         report_store,
+        (
+            HttpContextVersionPort(context_host_url, internal_token)
+            if context_host_url
+            else UnavailableContextVersionPort()
+        ),
     )
 
 

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

@@ -23,10 +23,11 @@ from .report_lifecycle import (
 from .report_store import AgentRuntimeReportStore
 from .run_admission import RunAdmission
 from .run_capacity import RunCapacity, RunCapacityReservation
-from .service_errors import OperationNotFoundError, RunNotFoundError
+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_failure_fields, canonical_signal_event
+from .signal_events import canonical_signal_event
 from .store import RunRecord, RunStore
 from .telemetry import AgentRunTrace
 from .vision_requirement import require_vision_readiness
@@ -34,7 +35,7 @@ from .vision_requirement import require_vision_readiness
 logger = logging.getLogger(__name__)
 
 
-class AgentRunService:
+class AgentRunService(AgentRunControlMixin):
     def __init__(
         self,
         engine: AgentEngineAdapter,
@@ -61,6 +62,12 @@ class AgentRunService:
         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)
@@ -74,6 +81,7 @@ class AgentRunService:
         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,
@@ -86,7 +94,12 @@ class AgentRunService:
             request.model_dump(by_alias=True),
         )
         record = admission.record
-        await ensure_run_report_safely(self.report_store, record.run_id, request)
+        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
@@ -121,7 +134,19 @@ class AgentRunService:
                 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,
@@ -139,43 +164,6 @@ class AgentRunService:
             except Exception:
                 logger.exception("Agent Run 恢复轮询失败，将继续重试")
 
-    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 _execute(
         self,
         record: RunRecord,
@@ -220,21 +208,19 @@ class AgentRunService:
                 if self.artifact_loader
                 else ()
             )
-            request = build_engine_run_request(record, invocation, prepared)
-            approval_timeout = max(
-                (
-                    tool.approval_timeout_seconds or 0
-                    for tool in invocation.allowed_tools
-                    if tool.approval == "required"
-                ),
-                default=0,
-            )
-            async with asyncio.timeout(
-                max(
-                    invocation.limits.max_duration_seconds,
-                    approval_timeout + (5 if approval_timeout else 0),
-                )
+            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)
@@ -337,13 +323,3 @@ class AgentRunService:
                 completed,
             )
         )
-
-    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_control.py

@@ -0,0 +1,64 @@
+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_execution.py

@@ -26,6 +26,9 @@ def build_engine_run_request(
         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,
     )

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

@@ -0,0 +1,2 @@
+class RunStoreCapacityError(Exception):
+    """Raised when the bounded local run store cannot accept more data."""

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

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 import sqlite3
 
+from .engine_identity import DIRECT_ENGINE_ID, HISTORICAL_ADK_ENGINE_ID
+
 
 def initialize_database(database: sqlite3.Connection) -> None:
     database.execute("pragma foreign_keys = on")
     database.executescript(
-        """
+        f"""
         create table if not exists agent_runs (
           run_id text primary key,
+          engine_id text not null default '{DIRECT_ENGINE_ID}',
           operation_key text not null,
           input_json text not null,
           idempotency_key text not null unique,
@@ -43,6 +46,11 @@ def initialize_database(database: sqlite3.Connection) -> None:
         database.execute(
             "alter table agent_runs add column trace_id text not null default ''"
         )
+    if "engine_id" not in columns:
+        database.execute(
+            "alter table agent_runs add column engine_id "
+            f"text not null default '{HISTORICAL_ADK_ENGINE_ID}'"
+        )
     database.executescript(
         """
         create table if not exists agent_releases (

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

@@ -9,6 +9,7 @@ from typing import cast
 
 from .contracts import AgentError, AgentErrorCode, JsonValue, RunStatus
 from .sqlite_catalog import SqliteCatalogMixin
+from .sqlite_errors import RunStoreCapacityError as RunStoreCapacityError
 from .sqlite_schema import initialize_database
 from .sqlite_serialization import encode, sequence_of
 from .store import (
@@ -19,9 +20,7 @@ from .store import (
 )
 from .store_cipher import RunStoreCipher
 
-
-class RunStoreCapacityError(Exception):
-    pass
+__all__ = ["RunStoreCapacityError", "SqliteRunStore"]
 
 
 class SqliteRunStore(SqliteCatalogMixin):
@@ -75,13 +74,14 @@ class SqliteRunStore(SqliteCatalogMixin):
                 self._database.execute(
                     """
                     insert into agent_runs (
-                      run_id, operation_key, input_json, idempotency_key,
+                      run_id, engine_id, operation_key, input_json, idempotency_key,
                       fingerprint, status, output_json, created_at, updated_at,
                       release_json, trace_id, invocation_cipher
-                    ) values (?, ?, ?, ?, ?, 'accepted', 'null', ?, ?, ?, ?, ?)
+                    ) values (?, ?, ?, ?, ?, ?, 'accepted', 'null', ?, ?, ?, ?, ?)
                     """,
                     (
                         record.run_id,
+                        record.engine_id,
                         record.operation_key,
                         "null",
                         record.idempotency_key,
@@ -282,6 +282,7 @@ class SqliteRunStore(SqliteCatalogMixin):
         ]
         return RunRecord(
             run_id=str(row["run_id"]),
+            engine_id=str(row["engine_id"]),
             operation_key=str(row["operation_key"]),
             input=json.loads(str(row["input_json"])),
             idempotency_key=str(row["idempotency_key"]),

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

@@ -5,6 +5,7 @@ from dataclasses import dataclass, field
 from typing import Protocol
 
 from .contracts import JsonValue, RunStatus
+from .engine_identity import DIRECT_ENGINE_ID
 
 CanonicalEvent = dict[str, object]
 TERMINAL_STATUSES = frozenset({"completed", "failed", "cancelled"})
@@ -17,6 +18,7 @@ class RunRecord:
     input: JsonValue
     idempotency_key: str
     fingerprint: str
+    engine_id: str = DIRECT_ENGINE_ID
     release: JsonValue = None
     trace_id: str = ""
     status: RunStatus = "accepted"

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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,58 @@
+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)