create-windy 0.6.12 → 0.6.15

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

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Literal, Protocol
+
+from .contracts import StartRunRequest
+from .engine_identity import DIRECT_ENGINE_ID
+from .report_metrics import AgentRuntimeMetrics
+from .report_types import (
+    AttemptReport,
+    AttemptTerminalOutcome,
+    NonTerminalRunStatus,
+    ReportFilter,
+    UsageFacts,
+)
+
+
+class AgentRuntimeReportStore(Protocol):
+    """Persistence boundary for operational reports and model attempts."""
+
+    retention_days: int
+    metrics: AgentRuntimeMetrics
+
+    async def ensure_run(
+        self,
+        run_id: str,
+        request: StartRunRequest,
+        created_at: float,
+        engine_id: str = DIRECT_ENGINE_ID,
+    ) -> None: ...
+
+    async def start_run(self, run_id: str, started_at: float) -> None: ...
+
+    async def set_run_status(
+        self,
+        run_id: str,
+        status: NonTerminalRunStatus,
+        updated_at: float,
+    ) -> None: ...
+
+    async def finish_run(
+        self,
+        run_id: str,
+        status: Literal["completed", "failed", "cancelled"],
+        finished_at: float,
+        safe_error_code: str | None = None,
+    ) -> None: ...
+
+    async def start_attempt(
+        self,
+        run_id: str,
+        tool_round: int,
+        deployment_key: str,
+        requested_model: str,
+        started_at: float,
+    ) -> AttemptReport: ...
+
+    async def finish_attempt(
+        self,
+        attempt_id: str,
+        outcome: AttemptTerminalOutcome,
+        usage: UsageFacts,
+        finished_at: float,
+        reported_model: str | None = None,
+        safe_error_code: str | None = None,
+    ) -> None: ...
+
+    async def summary(self, query: ReportFilter) -> dict[str, object]: ...
+
+    async def list_runs(
+        self, query: ReportFilter, page: int, page_size: int
+    ) -> dict[str, object]: ...
+
+    async def get_run(self, run_id: str) -> dict[str, object] | None: ...
+
+    async def close(self) -> None: ...

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

@@ -47,6 +47,7 @@ class UsageFacts:
 @dataclass(frozen=True)
 class RunReport:
     run_id: str
+    engine_id: str
     operation_key: str
     release_id: str
     trace_id: str
@@ -107,5 +108,11 @@ def iso(value: float | None) -> str | None:
     )
 
 
-def identity(run: RunReport) -> tuple[str, str, str, str | None]:
-    return (run.operation_key, run.release_id, run.trace_id, run.actor_id)
+def identity(run: RunReport) -> tuple[str, str, str, str, str | None]:
+    return (
+        run.engine_id,
+        run.operation_key,
+        run.release_id,
+        run.trace_id,
+        run.actor_id,
+    )

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"