create-windy 0.6.12 → 0.6.15

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

@@ -38,6 +38,21 @@ def request_fingerprint(request: StartRunRequest) -> str:
                 if request.readiness_pin
                 else None
             ),
+            "modelPin": (
+                request.model_pin.model_dump(by_alias=True)
+                if request.model_pin
+                else None
+            ),
+            "limits": request.limits.model_dump(by_alias=True),
+            "allowedTools": [
+                tool.model_dump(by_alias=True) for tool in request.allowed_tools
+            ],
+            "providerEgress": request.provider_egress.model_dump(by_alias=True),
+            "providerDataPolicy": request.provider_data_policy.model_dump(
+                by_alias=True
+            ),
+            "toolNetworkPolicy": request.tool_network_policy.model_dump(by_alias=True),
+            "executionGrant": request.execution_grant,
         },
         ensure_ascii=False,
         separators=(",", ":"),

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

@@ -1,15 +1,21 @@
 from __future__ import annotations
 
-from fastapi import FastAPI
+from collections.abc import Callable
+from typing import Annotated, cast
+
+from fastapi import FastAPI, Header
 from fastapi.responses import JSONResponse
 
-from .http_helpers import safe_error
+from .http_helpers import authorized, safe_error
 from .service import AgentRunService
 from .vlm_readiness import unavailable_vlm_snapshot
 
 
 def install_health_routes(
-    application: FastAPI, runtime: AgentRunService, engine: object
+    application: FastAPI,
+    runtime: AgentRunService,
+    engine: object,
+    internal_token: str | None,
 ) -> None:
     @application.get("/health/live")
     async def live() -> dict[str, str]:
@@ -48,3 +54,31 @@ def install_health_routes(
                 ),
                 status_code=503,
             )
+
+    @application.get("/health/model-coordinate", response_model=None)
+    async def model_coordinate(
+        authorization: Annotated[str | None, Header()] = None,
+    ) -> dict[str, str] | JSONResponse:
+        if not authorized(authorization, internal_token):
+            return safe_error(403, "FORBIDDEN", "内部调用认证失败", False)
+        coordinate = cast(
+            Callable[[], dict[str, str]] | None,
+            getattr(engine, "model_coordinate", None),
+        )
+        if coordinate is None:
+            return safe_error(
+                503,
+                "MODEL_ROUTE_UNAVAILABLE",
+                "Agent Runtime Model coordinate 不可用",
+                True,
+            )
+        try:
+            await runtime.probe()
+            return coordinate()
+        except Exception:
+            return safe_error(
+                503,
+                "MODEL_ROUTE_UNAVAILABLE",
+                "Agent Runtime Model coordinate 不可用",
+                True,
+            )

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

@@ -4,6 +4,12 @@ import asyncio
 import json
 from collections.abc import AsyncIterator
 
+from .attempt_context import govern_provider_attempt
+from .client_completion_runtime import ClientCompletionRuntime
+from .context_version_port import (
+    ContextVersionPort,
+    UnavailableContextVersionPort,
+)
 from .contracts import JsonValue
 from .engine import (
     AgentEngineAdapter,
@@ -18,6 +24,7 @@ from .engine import (
     ToolRequested,
     UsageReported,
 )
+from .engine_identity import DIRECT_ENGINE_ID
 from .multimodal import attach_artifacts, final_output
 from .openai_engine_validation import (
     assistant_tool_message,
@@ -25,6 +32,7 @@ from .openai_engine_validation import (
     cancelled,
     parse_arguments,
     validate_provider_tool_calls,
+    validate_reported_model,
     validate_runtime_request,
 )
 from .openai_provider import (
@@ -42,6 +50,7 @@ from .report_store import (
     InMemoryAgentRuntimeReportStore,
 )
 from .report_types import UsageFacts
+from .runtime_budget import RuntimeBudgetAdmission
 from .tool_host import (
     ToolApprovalPending,
     ToolApprovalResolved,
@@ -53,19 +62,27 @@ from .vlm_readiness import VlmReadinessProbe
 
 
 class OpenAiCompatibleEngineAdapter(AgentEngineAdapter):
+    ENGINE_ID = DIRECT_ENGINE_ID
+
     def __init__(
         self,
         provider: OpenAiCompatibleProvider,
         tool_host: ToolHostClient,
         governance: ProviderRequestGovernance,
         report_store: AgentRuntimeReportStore | None = None,
+        context_versions: ContextVersionPort | None = None,
     ) -> None:
         self._provider = provider
         self._tool_host = tool_host
         self._governance = governance
         self._report_store = report_store or InMemoryAgentRuntimeReportStore()
+        self._context_versions = context_versions or UnavailableContextVersionPort()
         self._cancellations: dict[str, asyncio.Event] = {}
 
+    @property
+    def engine_id(self) -> str:
+        return self.ENGINE_ID
+
     @property
     def capabilities(self) -> tuple[str, ...]:
         return self._provider.config.capabilities
@@ -85,6 +102,12 @@ class OpenAiCompatibleEngineAdapter(AgentEngineAdapter):
     def supports(self, operation_key: str) -> bool:
         return bool(operation_key.strip())
 
+    def model_coordinate(self) -> dict[str, str]:
+        return {
+            "deploymentKey": self._provider.config.deployment_key,
+            "model": self._provider.config.model,
+        }
+
     async def execute(
         self,
         request: EngineRunRequest,
@@ -92,6 +115,7 @@ class OpenAiCompatibleEngineAdapter(AgentEngineAdapter):
         validate_runtime_request(
             request,
             self._provider.config.deployment_key,
+            self._provider.config.model,
             self._provider.config.capabilities,
             self._provider.config.input_modalities,
         )
@@ -108,9 +132,11 @@ class OpenAiCompatibleEngineAdapter(AgentEngineAdapter):
             request.artifacts,
         )
         output_bytes = 0
+        budget = RuntimeBudgetAdmission(request.limits)
         try:
             for attempt in range(1, self._provider.config.max_tool_rounds + 1):
                 cancelled(cancellation)
+                remaining_output_tokens = budget.before_attempt(attempt)
                 report_attempt = await start_attempt_report_safely(
                     self._report_store,
                     request.run_id,
@@ -124,35 +150,25 @@ class OpenAiCompatibleEngineAdapter(AgentEngineAdapter):
                 finalized = False
                 turn: ProviderTurn | None = None
                 try:
-                    governed = self._governance.authorize(
-                        deployment_key=self._provider.config.deployment_key,
-                        operation_key=request.operation_key,
-                        run_id=request.run_id,
-                        attempt=attempt_sequence,
-                        messages=messages,
-                        tools=request.allowed_tools,
-                        policy=request.provider_data_policy,
-                        input_value=request.input,
-                        artifact_bytes=sum(
-                            artifact.byte_size for artifact in request.artifacts
-                        ),
-                        output_schema=request.output_schema,
-                        measure=lambda messages, tools, schema: len(
-                            self._provider.request_body(
-                                messages,
-                                tools,
-                                request.output_schema_key,
-                                schema,
-                            )
-                        ),
+                    prepared = await govern_provider_attempt(
+                        self._context_versions,
+                        self._governance,
+                        self._provider,
+                        request,
+                        attempt_sequence,
+                        report_attempt.attempt_id if report_attempt else None,
+                        messages,
+                        remaining_output_tokens,
                     )
-                    turn = await self._provider.complete_turn(
-                        governed.messages,
-                        governed.tools,
-                        request.output_schema_key,
-                        governed.output_schema,
+                    governed = prepared.governed
+                    budget.before_provider(len(prepared.provider_request))
+                    turn = await self._provider.complete_turn_body(
+                        prepared.provider_request
                     )
+                    cancelled(cancellation)
+                    validate_reported_model(request, turn.reported_model)
                     validate_provider_tool_calls(turn.tool_calls, allowed)
+                    budget.record_usage(turn.usage)
                     await finish_attempt_report_safely(
                         self._report_store,
                         report_attempt,
@@ -185,6 +201,7 @@ class OpenAiCompatibleEngineAdapter(AgentEngineAdapter):
                     raise
                 yield UsageReported(attempt_sequence, turn.usage)
                 if turn.tool_calls:
+                    budget.reserve_tools(len(turn.tool_calls))
                     messages.append(assistant_tool_message(turn.tool_calls))
                     async for signal in self._execute_tools(
                         request,
@@ -307,3 +324,6 @@ class OpenAiCompatibleEngineAdapter(AgentEngineAdapter):
 
     def governance_health(self) -> dict[str, int | float | str | None]:
         return self._governance.health()
+
+    def client_completion_runtime(self) -> ClientCompletionRuntime:
+        return ClientCompletionRuntime(self._provider, self._governance)

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

@@ -12,6 +12,7 @@ from .report_types import AttemptTerminalOutcome
 def validate_runtime_request(
     request: EngineRunRequest,
     provider_deployment_key: str,
+    provider_model: str,
     provider_capabilities: tuple[str, ...],
     provider_input_modalities: tuple[str, ...],
 ) -> None:
@@ -26,6 +27,25 @@ def validate_runtime_request(
             "Agent Operation 运行计划不完整",
             retryable=False,
         )
+    if request.model_pin is not None and (
+        request.model_pin.deployment_key != provider_deployment_key
+        or request.model_pin.model != provider_model
+    ):
+        raise SafeEngineError(
+            "MODEL_ROUTE_UNAVAILABLE",
+            "Workflow Model pin 与当前 Provider 不一致",
+            retryable=False,
+        )
+    if request.limits.max_cost_micros is not None and (
+        request.model_pin is None
+        or request.limits.max_input_tokens is None
+        or request.limits.max_output_tokens is None
+    ):
+        raise SafeEngineError(
+            "BUDGET_EXCEEDED",
+            "成本 Budget 缺少冻结模型与 Token 硬上界",
+            retryable=False,
+        )
     if set(request.required_capabilities) - set(provider_capabilities):
         raise SafeEngineError(
             "MODEL_ROUTE_UNAVAILABLE",
@@ -64,6 +84,18 @@ def validate_runtime_request(
         )
 
 
+def validate_reported_model(
+    request: EngineRunRequest,
+    reported_model: str | None,
+) -> None:
+    if request.model_pin is not None and reported_model != request.model_pin.model:
+        raise SafeEngineError(
+            "MODEL_ROUTE_UNAVAILABLE",
+            "Provider 实际模型与 Workflow Model pin 不一致",
+            retryable=False,
+        )
+
+
 def cancelled(event: asyncio.Event) -> None:
     if event.is_set():
         raise SafeEngineError(

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

@@ -65,6 +65,10 @@ class OpenAiCompatibleProvider:
             output_schema_key,
             output_schema,
         )
+        return await self.complete_turn_body(body)
+
+    async def complete_turn_body(self, body: bytes) -> ProviderTurn:
+        """Send the exact governed bytes whose digest was persisted by the Harness."""
         turn = ProviderTurn()
         started_at = time.perf_counter()
         async with self._client() as client:
@@ -91,6 +95,7 @@ class OpenAiCompatibleProvider:
         tools: tuple[RuntimeToolDefinition, ...],
         output_schema_key: str = "",
         output_schema: dict[str, JsonValue] | None = None,
+        max_output_tokens: int | None = None,
     ) -> bytes:
         payload: dict[str, JsonValue] = {
             "model": self.config.model,
@@ -103,6 +108,8 @@ class OpenAiCompatibleProvider:
         structured = response_format(output_schema_key, output_schema)
         if structured is not None:
             payload["response_format"] = structured
+        if max_output_tokens is not None:
+            payload["max_tokens"] = max_output_tokens
         return json.dumps(
             payload,
             ensure_ascii=False,

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

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 from .contracts import StartRunRequest
+from .engine_identity import DIRECT_ENGINE_ID
 from .report_types import retention_seconds
 
 RUN_INSERT_SQL = """
 insert into agent_runtime_report_runs (
-  run_id, operation_key, release_id, trace_id,
+  run_id, engine_id, operation_key, release_id, trace_id,
   actor_id, actor_type, department_id, status,
   created_at, updated_at, expires_at
-) values (%s, %s, %s, %s, %s, %s, %s, 'accepted', %s, %s, %s)
+) values (%s, %s, %s, %s, %s, %s, %s, %s, 'accepted', %s, %s, %s)
 on conflict (run_id) do nothing
 """
 
@@ -18,10 +19,12 @@ def run_insert_values(
     request: StartRunRequest,
     created_at: float,
     retention_days: int,
+    engine_id: str = DIRECT_ENGINE_ID,
 ) -> tuple[object, ...]:
     context = request.reporting
     return (
         run_id,
+        engine_id,
         request.operation_key,
         request.release.release_id,
         request.trace_id,

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

@@ -178,6 +178,7 @@ def scope_conditions(
 def run_from_row(row: dict[str, Any]) -> RunReport:
     return RunReport(
         run_id=str(row["run_id"]),
+        engine_id=str(row["engine_id"]),
         operation_key=str(row["operation_key"]),
         release_id=str(row["release_id"]),
         trace_id=str(row["trace_id"]),

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

@@ -10,6 +10,7 @@ from psycopg.rows import dict_row
 from psycopg_pool import AsyncConnectionPool
 
 from .contracts import StartRunRequest
+from .engine_identity import DIRECT_ENGINE_ID
 from .postgres_report_insert import RUN_INSERT_SQL, run_insert_values
 from .postgres_report_queries import get_run, list_runs
 from .postgres_report_replay import assert_attempt_terminal_replay
@@ -70,6 +71,7 @@ class PostgresAgentRuntimeReportStore(AgentRuntimeReportStore):
         run_id: str,
         request: StartRunRequest,
         created_at: float,
+        engine_id: str = DIRECT_ENGINE_ID,
     ) -> None:
         await self.ready()
         context = request.reporting
@@ -78,6 +80,7 @@ class PostgresAgentRuntimeReportStore(AgentRuntimeReportStore):
             request,
             created_at,
             self.retention_days,
+            engine_id,
         )
         async with self._pool.connection() as connection:
             await connection.execute(
@@ -89,13 +92,14 @@ class PostgresAgentRuntimeReportStore(AgentRuntimeReportStore):
                 return
             existing_cursor = await connection.execute(
                 """
-                select operation_key, release_id, trace_id, actor_id
+                select engine_id, operation_key, release_id, trace_id, actor_id
                 from agent_runtime_report_runs where run_id = %s
                 """,
                 (run_id,),
             )
             existing = await existing_cursor.fetchone()
             identity = (
+                engine_id,
                 request.operation_key,
                 request.release.release_id,
                 request.trace_id,
@@ -104,6 +108,7 @@ class PostgresAgentRuntimeReportStore(AgentRuntimeReportStore):
             if (
                 not existing
                 or (
+                    str(existing["engine_id"]),
                     str(existing["operation_key"]),
                     str(existing["release_id"]),
                     str(existing["trace_id"]),

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

@@ -80,12 +80,12 @@ class PostgresRunStore:
                 inserted = await connection.execute(
                     """
                     insert into agent_runtime_runs (
-                      run_id, operation_key, idempotency_key, fingerprint,
+                      run_id, engine_id, operation_key, idempotency_key, fingerprint,
                       status, release_id, release_json, trace_id, invocation_cipher,
                       lease_owner, lease_until,
                       created_at, updated_at, expires_at
                     ) values (
-                      %s, %s, %s, %s, 'accepted', %s, %s, %s, %s, %s,
+                      %s, %s, %s, %s, %s, 'accepted', %s, %s, %s, %s, %s,
                       extract(epoch from clock_timestamp()) + %s, %s, %s, %s
                     )
                     on conflict (idempotency_key) do nothing
@@ -93,6 +93,7 @@ class PostgresRunStore:
                     """,
                     (
                         record.run_id,
+                        record.engine_id,
                         record.operation_key,
                         record.idempotency_key,
                         record.fingerprint,

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

@@ -88,6 +88,7 @@ class PostgresStoreBackend:
         )
         return RunRecord(
             run_id=str(row["run_id"]),
+            engine_id=str(row["engine_id"]),
             operation_key=str(row["operation_key"]),
             input=None,
             idempotency_key=str(row["idempotency_key"]),

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

@@ -144,6 +144,27 @@ class ProviderRequestGovernance:
     def health(self) -> dict[str, int | float | str | None]:
         return self.audit.health()
 
+    def record_client(
+        self,
+        *,
+        deployment_key: str,
+        operation_key: str,
+        run_id: str,
+        attempt: int,
+        classified: set[str],
+        sent_bytes: int,
+        decision: str,
+    ) -> None:
+        self._record(
+            deployment_key,
+            operation_key,
+            run_id,
+            attempt,
+            classified,
+            sent_bytes,
+            decision,
+        )
+
     def _record(
         self,
         deployment_key: str,

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

@@ -21,9 +21,10 @@ async def ensure_run_report_safely(
     store: AgentRuntimeReportStore,
     run_id: str,
     request: StartRunRequest,
+    engine_id: str,
 ) -> None:
     try:
-        await store.ensure_run(run_id, request, time.time())
+        await store.ensure_run(run_id, request, time.time(), engine_id)
     except Exception:
         reporting_failure(store, "run_ensure", run_id)
 

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

@@ -229,6 +229,7 @@ def run_value(run: RunReport, attempts: list[AttemptReport]) -> dict[str, object
     )
     return {
         "runId": run.run_id,
+        "engineId": run.engine_id,
         "operationKey": run.operation_key,
         "actorId": run.actor_id,
         "departmentId": run.department_id,

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

@@ -9,6 +9,8 @@ from fastapi.responses import JSONResponse, PlainTextResponse
 from .http_helpers import authorized, safe_error
 from .report_store import AgentRuntimeReportStore
 from .report_types import ReportFilter
+from .store import RunStore
+from .trajectory import project_run_trajectory
 
 type ReportRange = Literal["day", "month", "retained"]
 type ScopeMode = Literal["all", "bounded", "none"]
@@ -16,6 +18,7 @@ type ScopeMode = Literal["all", "bounded", "none"]
 
 def create_report_router(
     store: AgentRuntimeReportStore,
+    run_store: RunStore,
     internal_token: str | None,
 ) -> APIRouter:
     router = APIRouter()
@@ -97,7 +100,10 @@ def create_report_router(
         value = await store.get_run(run_id)
         if value is None:
             return safe_error(404, "RUN_CONFLICT", "Agent Run 不存在", False)
-        return value
+        return {
+            **value,
+            "trajectory": project_run_trajectory(await run_store.get(run_id)),
+        }
 
     return router
 

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

@@ -5,9 +5,10 @@ import time
 import uuid
 from collections.abc import Callable
 from dataclasses import replace
-from typing import Literal, Protocol
+from typing import Literal
 
 from .contracts import StartRunRequest
+from .engine_identity import DIRECT_ENGINE_ID
 from .report_metrics import AgentRuntimeMetrics
 from .report_presenter import (
     aggregate_summary,
@@ -18,6 +19,7 @@ from .report_presenter import (
     run_value,
     scoped_runs,
 )
+from .report_store_protocol import AgentRuntimeReportStore
 from .report_types import (
     AttemptReport,
     AttemptTerminalOutcome,
@@ -30,60 +32,7 @@ from .report_types import (
     validate_retention,
 )
 
-
-class AgentRuntimeReportStore(Protocol):
-    retention_days: int
-    metrics: AgentRuntimeMetrics
-
-    async def ensure_run(
-        self, run_id: str, request: StartRunRequest, created_at: float
-    ) -> 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: ...
+__all__ = ["AgentRuntimeReportStore", "InMemoryAgentRuntimeReportStore"]
 
 
 class InMemoryAgentRuntimeReportStore:
@@ -103,13 +52,18 @@ class InMemoryAgentRuntimeReportStore:
         self._lock = asyncio.Lock()
 
     async def ensure_run(
-        self, run_id: str, request: StartRunRequest, created_at: float
+        self,
+        run_id: str,
+        request: StartRunRequest,
+        created_at: float,
+        engine_id: str = DIRECT_ENGINE_ID,
     ) -> None:
         async with self._lock:
             self._prune()
             context = request.reporting
             candidate = RunReport(
                 run_id=run_id,
+                engine_id=engine_id,
                 operation_key=request.operation_key,
                 release_id=request.release.release_id,
                 trace_id=request.trace_id,