create-windy 0.8.2 → 0.9.1

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

@@ -1,329 +0,0 @@
-from __future__ import annotations
-
-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,
-    ApprovalRequired,
-    ApprovalResolved,
-    EngineCompleted,
-    EngineRunRequest,
-    EngineSignal,
-    OutputDelta,
-    SafeEngineError,
-    ToolCompleted,
-    ToolRequested,
-    UsageReported,
-)
-from .engine_identity import DIRECT_ENGINE_ID
-from .multimodal import attach_artifacts, final_output
-from .openai_engine_validation import (
-    assistant_tool_message,
-    attempt_outcome,
-    cancelled,
-    parse_arguments,
-    validate_provider_tool_calls,
-    validate_reported_model,
-    validate_runtime_request,
-)
-from .openai_provider import (
-    OpenAiCompatibleProvider,
-    ProviderToolCall,
-    ProviderTurn,
-)
-from .provider_governance import ProviderRequestGovernance
-from .report_lifecycle import (
-    finish_attempt_report_safely,
-    start_attempt_report_safely,
-)
-from .report_store import (
-    AgentRuntimeReportStore,
-    InMemoryAgentRuntimeReportStore,
-)
-from .report_types import UsageFacts
-from .runtime_budget import RuntimeBudgetAdmission
-from .tool_host import (
-    ToolApprovalPending,
-    ToolApprovalResolved,
-    ToolHostClient,
-    ToolInvocation,
-    canonical_tool_call_id,
-)
-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
-
-    @property
-    def input_modalities(self) -> tuple[str, ...]:
-        return self._provider.config.input_modalities
-
-    @property
-    def max_concurrent_runs(self) -> int:
-        return self._provider.config.max_concurrent_runs
-
-    @property
-    def max_queue_depth(self) -> int:
-        return self._provider.config.max_queue_depth
-
-    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,
-    ) -> AsyncIterator[EngineSignal]:
-        validate_runtime_request(
-            request,
-            self._provider.config.deployment_key,
-            self._provider.config.model,
-            self._provider.config.capabilities,
-            self._provider.config.input_modalities,
-        )
-        cancellation = self._cancellations.setdefault(
-            request.run_id,
-            asyncio.Event(),
-        )
-        allowed = {tool.key for tool in request.allowed_tools}
-        messages = attach_artifacts(
-            [
-                {"role": "system", "content": request.instructions},
-                {"role": "user", "content": request.user_prompt},
-            ],
-            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,
-                    attempt,
-                    self._provider.config.deployment_key,
-                    self._provider.config.model,
-                )
-                attempt_sequence = (
-                    report_attempt.sequence if report_attempt else attempt
-                )
-                finalized = False
-                turn: ProviderTurn | None = None
-                try:
-                    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,
-                    )
-                    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,
-                        "completed",
-                        turn.usage,
-                        reported_model=turn.reported_model,
-                    )
-                    finalized = True
-                except SafeEngineError as error:
-                    if not finalized:
-                        await finish_attempt_report_safely(
-                            self._report_store,
-                            report_attempt,
-                            attempt_outcome(error),
-                            turn.usage if turn else UsageFacts(),
-                            reported_model=(turn.reported_model if turn else None),
-                            safe_error_code=error.code,
-                        )
-                    raise
-                except Exception:
-                    if not finalized:
-                        await finish_attempt_report_safely(
-                            self._report_store,
-                            report_attempt,
-                            "failed",
-                            turn.usage if turn else UsageFacts(),
-                            reported_model=(turn.reported_model if turn else None),
-                            safe_error_code="RUNTIME_UNAVAILABLE",
-                        )
-                    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,
-                        turn.tool_calls,
-                        allowed,
-                        messages,
-                        cancellation,
-                    ):
-                        yield signal
-                    continue
-                for delta in turn.text_deltas:
-                    output_bytes += len(delta.encode())
-                    if output_bytes > request.limits.max_output_bytes:
-                        raise SafeEngineError(
-                            "BUDGET_EXCEEDED",
-                            "Agent 输出超过 Operation 上限",
-                            retryable=False,
-                        )
-                    yield OutputDelta(delta)
-                yield EngineCompleted(final_output(turn.text, governed.output_schema))
-                return
-            raise SafeEngineError(
-                "BUDGET_EXCEEDED",
-                "Agent Tool 调用轮次超过上限",
-                retryable=False,
-            )
-        finally:
-            self._cancellations.pop(request.run_id, None)
-
-    async def _execute_tools(
-        self,
-        request: EngineRunRequest,
-        calls: list[ProviderToolCall],
-        allowed: set[str],
-        messages: list[dict[str, JsonValue]],
-        cancellation: asyncio.Event,
-    ) -> AsyncIterator[EngineSignal]:
-        for call in calls:
-            cancelled(cancellation)
-            if not call.call_id or not call.name or call.name not in allowed:
-                raise SafeEngineError(
-                    "TOOL_DENIED",
-                    "模型请求了未授权 Tool",
-                    retryable=False,
-                )
-            arguments = parse_arguments(call.arguments)
-            tool_call_id = canonical_tool_call_id(
-                request.run_id,
-                call.name,
-                arguments,
-            )
-            yield ToolRequested(tool_call_id, call.name)
-            invocation = ToolInvocation(
-                request.run_id,
-                tool_call_id,
-                call.name,
-                arguments,
-                request.execution_grant,
-            )
-            approval: ToolApprovalPending | None = None
-            while True:
-                cancelled(cancellation)
-                try:
-                    result = await self._tool_host.execute(
-                        request.tool_host_url,
-                        invocation,
-                    )
-                    if approval:
-                        yield ApprovalResolved(
-                            approval.work_item_id,
-                            tool_call_id,
-                            "approved",
-                        )
-                    break
-                except ToolApprovalPending as pending:
-                    if approval is None:
-                        approval = pending
-                        yield ApprovalRequired(
-                            pending.work_item_id,
-                            tool_call_id,
-                        )
-                    elif pending.work_item_id != approval.work_item_id:
-                        raise SafeEngineError(
-                            "TOOL_DENIED",
-                            "Agent Tool 审批标识漂移",
-                            retryable=False,
-                        ) from None
-                    await asyncio.sleep(2)
-                except ToolApprovalResolved as resolved:
-                    yield ApprovalResolved(
-                        resolved.work_item_id,
-                        tool_call_id,
-                        resolved.outcome,
-                    )
-                    raise SafeEngineError(
-                        "TOOL_DENIED",
-                        "Agent Tool 审批未通过",
-                        retryable=False,
-                    ) from None
-            yield ToolCompleted(tool_call_id)
-            messages.append(
-                {
-                    "role": "tool",
-                    "tool_call_id": call.call_id,
-                    "content": json.dumps(
-                        result,
-                        ensure_ascii=False,
-                        separators=(",", ":"),
-                    ),
-                }
-            )
-
-    async def cancel(self, run_id: str) -> None:
-        event = self._cancellations.get(run_id)
-        if event is not None:
-            event.set()
-
-    async def readiness(self) -> dict[str, object]:
-        return await VlmReadinessProbe(self._provider.config, self._provider).inspect()
-
-    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

@@ -1,165 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-
-from .contracts import JsonValue
-from .engine import EngineRunRequest, SafeEngineError
-from .openai_provider import ProviderToolCall
-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:
-    if (
-        not request.instructions.strip()
-        or not request.user_prompt.strip()
-        or not request.execution_grant.strip()
-        or not request.tool_host_url.strip()
-    ):
-        raise SafeEngineError(
-            "INVALID_INPUT",
-            "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",
-            "模型 Deployment 缺少 Operation 所需能力",
-            retryable=True,
-        )
-    if set(request.input_modalities) - set(provider_input_modalities):
-        raise SafeEngineError(
-            "MODEL_ROUTE_UNAVAILABLE",
-            "模型 Deployment 不支持 Operation 输入模态",
-            retryable=True,
-        )
-    if (
-        request.provider_egress.mode != "configured-endpoint"
-        or request.provider_egress.deployment_key != provider_deployment_key
-    ):
-        raise SafeEngineError(
-            "FORBIDDEN",
-            "Agent Operation 未授权当前模型部署出网",
-            retryable=False,
-        )
-    if request.tool_network_policy.mode != "forbidden":
-        raise SafeEngineError(
-            "TOOL_DENIED",
-            "Agent Tool 网络策略不受支持",
-            retryable=False,
-        )
-    if (
-        not request.provider_data_policy.input_fields
-        or not request.provider_data_policy.envelope_fields
-    ):
-        raise SafeEngineError(
-            "FORBIDDEN",
-            "Agent Operation 缺少 Provider 字段治理策略",
-            retryable=False,
-        )
-
-
-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(
-            "RUN_CANCELLED",
-            "Agent Run 已取消",
-            retryable=False,
-        )
-
-
-def parse_arguments(raw: str) -> dict[str, JsonValue]:
-    try:
-        value = json.loads(raw or "{}")
-    except json.JSONDecodeError:
-        raise SafeEngineError(
-            "TOOL_DENIED",
-            "Agent Tool 参数无效",
-            retryable=False,
-        ) from None
-    if not isinstance(value, dict):
-        raise SafeEngineError(
-            "TOOL_DENIED",
-            "Agent Tool 参数必须是对象",
-            retryable=False,
-        )
-    return value
-
-
-def assistant_tool_message(
-    calls: list[ProviderToolCall],
-) -> dict[str, JsonValue]:
-    return {
-        "role": "assistant",
-        "content": None,
-        "tool_calls": [
-            {
-                "id": call.call_id,
-                "type": "function",
-                "function": {
-                    "name": call.name,
-                    "arguments": call.arguments,
-                },
-            }
-            for call in calls
-        ],
-    }
-
-
-def validate_provider_tool_calls(
-    calls: list[ProviderToolCall],
-    allowed: set[str],
-) -> None:
-    for call in calls:
-        if not call.call_id or not call.name or call.name not in allowed:
-            raise SafeEngineError(
-                "TOOL_DENIED",
-                "模型请求了未授权 Tool",
-                retryable=False,
-            )
-        parse_arguments(call.arguments)
-
-
-def attempt_outcome(error: SafeEngineError) -> AttemptTerminalOutcome:
-    if error.code == "RUN_CANCELLED":
-        return "cancelled"
-    if error.code in {"FORBIDDEN", "INVALID_INPUT", "TOOL_DENIED"}:
-        return "blocked"
-    return "failed"