create-windy 0.8.2 → 0.9.1

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

@@ -1,309 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import cast
-
-from .contracts import (
-    JsonValue,
-    ProviderDataField,
-    ProviderDataPolicy,
-    RuntimeToolDefinition,
-)
-from .engine import SafeEngineError
-from .provider_audit import ProviderAttemptAudit, ProviderAuditStore
-
-_DLP_PATTERNS = (
-    re.compile(r"(?i)\bBearer\s+[A-Za-z0-9._~+/=-]{8,}"),
-    re.compile(r"(?i)\b(?:api[_-]?key|secret|password|token)\s*[:=]\s*\S+"),
-    re.compile(r"\b1[3-9]\d{9}\b"),
-    re.compile(r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.I),
-    re.compile(r"\b\d{17}[\dXx]\b"),
-    re.compile(r"\b(?:\d[ -]?){16,30}\b"),
-)
-_REDACTED = "[REDACTED]"
-
-
-@dataclass(frozen=True)
-class GovernedAttempt:
-    messages: list[dict[str, JsonValue]]
-    tools: tuple[RuntimeToolDefinition, ...]
-    output_schema: dict[str, JsonValue] | None
-
-
-class ProviderRequestGovernance:
-    def __init__(self, audit: ProviderAuditStore) -> None:
-        self.audit = audit
-
-    def authorize(
-        self,
-        *,
-        deployment_key: str,
-        operation_key: str,
-        run_id: str,
-        attempt: int,
-        messages: list[dict[str, JsonValue]],
-        tools: tuple[RuntimeToolDefinition, ...],
-        policy: ProviderDataPolicy,
-        input_value: JsonValue = None,
-        artifact_bytes: int = 0,
-        output_schema: dict[str, JsonValue] | None = None,
-        measure: Callable[
-            [
-                list[dict[str, JsonValue]],
-                tuple[RuntimeToolDefinition, ...],
-                dict[str, JsonValue] | None,
-            ],
-            int,
-        ]
-        | None = None,
-    ) -> GovernedAttempt:
-        rules = {rule.field: rule for rule in policy.envelope_fields}
-        classified: set[str] = set()
-        classified.update(input_classifications(input_value, policy))
-        redacted = False
-        governed_messages: list[dict[str, JsonValue]] = []
-        try:
-            for message in messages:
-                field = field_for_message(message)
-                rule = rules.get(field)
-                if rule is None:
-                    raise GovernanceDenied(f"Provider 未授权发送字段：{field}")
-                classified.add(rule.classification)
-                value, changed = govern_message(message, rule.dlp_action)
-                redacted = redacted or changed
-                governed_messages.append(cast(dict[str, JsonValue], value))
-            governed_tools = tools
-            if tools:
-                rule = rules.get("tool-definitions")
-                if rule is None:
-                    raise GovernanceDenied("Provider 未授权发送字段：tool-definitions")
-                classified.add(rule.classification)
-                raw_tools = [tool.model_dump(by_alias=True) for tool in tools]
-                governed, changed = govern_value(raw_tools, rule.dlp_action)
-                redacted = redacted or changed
-                governed_tools = tuple(
-                    RuntimeToolDefinition.model_validate(item)
-                    for item in cast(list[object], governed)
-                )
-            governed_schema = output_schema
-            if artifact_bytes:
-                artifact_rule = rules.get("artifact-content")
-                if artifact_rule is None:
-                    raise GovernanceDenied("Provider 未授权发送字段：artifact-content")
-                classified.add(artifact_rule.classification)
-            if output_schema is not None:
-                schema_rule = rules.get("output-schema")
-                if schema_rule is None:
-                    raise GovernanceDenied("Provider 未授权发送字段：output-schema")
-                classified.add(schema_rule.classification)
-                raw_schema, changed = govern_value(
-                    output_schema,
-                    schema_rule.dlp_action,
-                )
-                redacted = redacted or changed
-                governed_schema = cast(dict[str, JsonValue], raw_schema)
-            sent_bytes = (measure or payload_size)(
-                governed_messages,
-                governed_tools,
-                governed_schema,
-            )
-            decision = "redact" if redacted else "allow"
-            self._record(
-                deployment_key,
-                operation_key,
-                run_id,
-                attempt,
-                classified,
-                sent_bytes,
-                decision,
-            )
-            return GovernedAttempt(
-                governed_messages,
-                governed_tools,
-                governed_schema,
-            )
-        except GovernanceDenied:
-            self._record(
-                deployment_key,
-                operation_key,
-                run_id,
-                attempt,
-                classified,
-                0,
-                "reject",
-            )
-            raise SafeEngineError(
-                "FORBIDDEN",
-                "Provider 请求被字段治理策略拒绝",
-                retryable=False,
-            ) from None
-
-    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,
-        operation_key: str,
-        run_id: str,
-        attempt: int,
-        classified: set[str],
-        sent_bytes: int,
-        decision: str,
-    ) -> None:
-        try:
-            self.audit.append(
-                ProviderAttemptAudit(
-                    deployment_key,
-                    operation_key,
-                    run_id,
-                    attempt,
-                    tuple(sorted(classified)),
-                    sent_bytes,
-                    decision,
-                )
-            )
-        except Exception:
-            raise SafeEngineError(
-                "FORBIDDEN",
-                "Provider 发送审计不可用",
-                retryable=False,
-            ) from None
-
-
-class GovernanceDenied(Exception):
-    pass
-
-
-def field_for_message(message: dict[str, JsonValue]) -> ProviderDataField:
-    role = message.get("role")
-    if role == "system":
-        return "instructions"
-    if role == "user":
-        return "user-prompt"
-    if role == "assistant":
-        return "provider-output"
-    if role == "tool":
-        return "tool-results"
-    raise GovernanceDenied("Provider 消息角色未知")
-
-
-def input_classifications(
-    value: JsonValue,
-    policy: ProviderDataPolicy,
-) -> set[str]:
-    result: set[str] = set()
-    for rule in policy.input_fields:
-        current = value
-        found = True
-        for encoded in rule.json_pointer.removeprefix("/").split("/"):
-            segment = encoded.replace("~1", "/").replace("~0", "~")
-            if not isinstance(current, dict) or segment not in current:
-                found = False
-                break
-            current = current[segment]
-        if found:
-            result.add(rule.classification)
-    return result
-
-
-def govern_value(value: object, action: str) -> tuple[object, bool]:
-    if isinstance(value, str):
-        detected = any(pattern.search(value) for pattern in _DLP_PATTERNS)
-        if detected and action == "reject":
-            raise GovernanceDenied("DLP reject")
-        if detected:
-            result = value
-            for pattern in _DLP_PATTERNS:
-                result = pattern.sub(_REDACTED, result)
-            return result, result != value
-        return value, False
-    if isinstance(value, list):
-        changed = False
-        items: list[object] = []
-        for item in value:
-            governed, item_changed = govern_value(item, action)
-            items.append(governed)
-            changed = changed or item_changed
-        return items, changed
-    if isinstance(value, dict):
-        changed = False
-        governed_record: dict[str, object] = {}
-        for key, item in value.items():
-            governed, item_changed = govern_value(item, action)
-            governed_record[key] = governed
-            changed = changed or item_changed
-        return governed_record, changed
-    return value, False
-
-
-def govern_message(
-    message: dict[str, JsonValue],
-    action: str,
-) -> tuple[object, bool]:
-    content = message.get("content")
-    if message.get("role") != "user" or not isinstance(content, list):
-        return govern_value(message, action)
-    changed = False
-    governed_parts: list[object] = []
-    for part in content:
-        if not isinstance(part, dict):
-            raise GovernanceDenied("Provider 多模态消息结构无效")
-        if part.get("type") == "text":
-            governed, item_changed = govern_value(part, action)
-            governed_parts.append(governed)
-            changed = changed or item_changed
-            continue
-        image = part.get("image_url")
-        url = image.get("url") if isinstance(image, dict) else None
-        if (
-            part.get("type") != "image_url"
-            or not isinstance(url, str)
-            or not url.startswith("data:image/png;base64,")
-        ):
-            raise GovernanceDenied("Provider 图片输入结构无效")
-        governed_parts.append(part)
-    return {**message, "content": governed_parts}, changed
-
-
-def payload_size(
-    messages: list[dict[str, JsonValue]],
-    tools: tuple[RuntimeToolDefinition, ...],
-    output_schema: dict[str, JsonValue] | None = None,
-) -> int:
-    payload = {
-        "messages": messages,
-        "tools": [tool.model_dump(by_alias=True) for tool in tools],
-        "outputSchema": output_schema,
-    }
-    return len(
-        json.dumps(
-            payload,
-            ensure_ascii=False,
-            separators=(",", ":"),
-        ).encode()
-    )

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

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-import json
-
-from .contracts import JsonValue
-from .engine import SafeEngineError
-
-
-def tool_output_messages(
-    messages: list[dict[str, JsonValue]],
-    output_schema: dict[str, JsonValue] | None,
-) -> list[dict[str, JsonValue]]:
-    """Merge already-governed schema guidance without moving Context source ordinals."""
-    if output_schema is None:
-        return messages
-    if not messages or messages[0].get("role") != "system":
-        raise SafeEngineError(
-            "INVALID_INPUT", "工具结构化输出缺少系统指令", retryable=False
-        )
-    instructions = messages[0].get("content")
-    if not isinstance(instructions, str):
-        raise SafeEngineError(
-            "INVALID_INPUT", "工具结构化输出指令无效", retryable=False
-        )
-    guidance = (
-        "\n\n需要工具时，只通过 API 的 function calling 调用已提供的工具，"
-        "不要在正文中模拟工具调用。工具处理完成后的最终回复必须是符合以下 "
-        "JSON Schema 的单个 JSON 值，不含 Markdown 围栏或额外说明；"
-        "工具调用阶段不受最终 JSON 格式限制。\n"
-        + json.dumps(output_schema, ensure_ascii=False, separators=(",", ":"))
-    )
-    if instructions.endswith(guidance):
-        return messages
-    return [{**messages[0], "content": instructions + guidance}, *messages[1:]]

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

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from typing import Protocol
-
-
-class ReadinessEngine(Protocol):
-    async def readiness(self) -> dict[str, object]: ...
-
-
-async def readiness_pin_matches(engine: object, expected: dict[str, object]) -> bool:
-    readiness = getattr(engine, "readiness", None)
-    if not readiness:
-        return False
-    try:
-        snapshot = await readiness()
-    except Exception:
-        return False
-    deployment = snapshot.get("deployment") if isinstance(snapshot, dict) else None
-    probe = snapshot.get("downstreamProbe") if isinstance(snapshot, dict) else None
-    probe_names = {
-        "identity": "deploymentIdentity",
-        "releaseDigest": "releaseDigest",
-        "offersDigest": "offersDigest",
-    }
-    return bool(
-        isinstance(snapshot, dict)
-        and snapshot.get("status") == "ready"
-        and isinstance(deployment, dict)
-        and isinstance(probe, dict)
-        and probe.get("status") == "passed"
-        and all(deployment.get(key) == value for key, value in expected.items())
-        and all(
-            probe.get(probe_names[key]) == value
-            for key, value in expected.items()
-            if key in probe_names
-        )
-    )

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

@@ -1,218 +0,0 @@
-from __future__ import annotations
-
-import logging
-import time
-from typing import Literal, cast
-
-from .contracts import StartRunRequest
-from .report_store import AgentRuntimeReportStore
-from .report_types import (
-    AttemptReport,
-    AttemptTerminalOutcome,
-    NonTerminalRunStatus,
-    UsageFacts,
-)
-from .store import CanonicalEvent, RunRecord, RunStore
-
-logger = logging.getLogger(__name__)
-
-
-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(), engine_id)
-    except Exception:
-        reporting_failure(store, "run_ensure", run_id)
-
-
-async def start_run_report_safely(
-    store: AgentRuntimeReportStore,
-    run_id: str,
-) -> None:
-    try:
-        await store.start_run(run_id, time.time())
-    except Exception:
-        reporting_failure(store, "run_start", run_id)
-
-
-async def finish_run_report_safely(
-    store: AgentRuntimeReportStore,
-    run_id: str,
-    status: Literal["completed", "failed", "cancelled"],
-    safe_error_code: str | None = None,
-) -> None:
-    """Keep a reporting outage from changing the canonical Run terminal state."""
-    try:
-        await store.finish_run(
-            run_id,
-            status,
-            time.time(),
-            safe_error_code,
-        )
-    except Exception:
-        reporting_failure(
-            store,
-            "run_terminal",
-            run_id,
-            {"report_status": status},
-        )
-
-
-async def sync_terminal_from_canonical(
-    report_store: AgentRuntimeReportStore,
-    canonical_store: RunStore,
-    run_id: str,
-    fallback_safe_error_code: str | None = None,
-) -> RunRecord | None:
-    record = await canonical_store.get(run_id)
-    if record is None or not record.terminal:
-        return None
-    status = cast(Literal["completed", "failed", "cancelled"], record.status)
-    safe_error_code = None
-    if status == "failed":
-        safe_error_code = canonical_error_code(record) or fallback_safe_error_code
-    await finish_run_report_safely(
-        report_store,
-        run_id,
-        status,
-        safe_error_code,
-    )
-    return record
-
-
-async def sync_canonical_event(
-    report_store: AgentRuntimeReportStore,
-    canonical_store: RunStore,
-    run_id: str,
-    event: CanonicalEvent | None,
-    fallback_safe_error_code: str | None = None,
-) -> RunRecord | None:
-    event_type = event.get("type") if event else None
-    if event is None or event_type in {
-        "run.completed",
-        "run.failed",
-        "run.cancelled",
-    }:
-        return await sync_terminal_from_canonical(
-            report_store,
-            canonical_store,
-            run_id,
-            fallback_safe_error_code,
-        )
-    if isinstance(event_type, str):
-        await sync_status(report_store, run_id, event_type)
-    return None
-
-
-async def append_and_sync_canonical_event(
-    report_store: AgentRuntimeReportStore,
-    canonical_store: RunStore,
-    run_id: str,
-    event_type: str,
-    fields: dict[str, object] | None = None,
-    fallback_safe_error_code: str | None = None,
-) -> RunRecord | None:
-    event = await canonical_store.append(run_id, event_type, fields)
-    return await sync_canonical_event(
-        report_store,
-        canonical_store,
-        run_id,
-        event,
-        fallback_safe_error_code,
-    )
-
-
-async def sync_status(
-    store: AgentRuntimeReportStore,
-    run_id: str,
-    event_type: str,
-) -> None:
-    status: NonTerminalRunStatus
-    if event_type == "approval.required":
-        status = "awaiting-approval"
-    elif event_type == "approval.resolved":
-        status = "running"
-    else:
-        return
-    try:
-        await store.set_run_status(run_id, status, time.time())
-    except Exception:
-        reporting_failure(
-            store,
-            "run_status",
-            run_id,
-            {"report_status": status},
-        )
-
-
-def canonical_error_code(record: RunRecord) -> str | None:
-    for event in reversed(record.events):
-        if event.get("type") != "run.failed":
-            continue
-        error = event.get("error")
-        if isinstance(error, dict):
-            code = error.get("code")
-            if isinstance(code, str):
-                return code
-    return None
-
-
-async def start_attempt_report_safely(
-    store: AgentRuntimeReportStore,
-    run_id: str,
-    tool_round: int,
-    deployment_key: str,
-    requested_model: str,
-) -> AttemptReport | None:
-    try:
-        return await store.start_attempt(
-            run_id,
-            tool_round,
-            deployment_key,
-            requested_model,
-            time.time(),
-        )
-    except Exception:
-        reporting_failure(store, "attempt_start", run_id)
-        return None
-
-
-async def finish_attempt_report_safely(
-    store: AgentRuntimeReportStore,
-    attempt: AttemptReport | None,
-    outcome: AttemptTerminalOutcome,
-    usage: UsageFacts,
-    *,
-    reported_model: str | None = None,
-    safe_error_code: str | None = None,
-) -> None:
-    if attempt is None:
-        return
-    try:
-        await store.finish_attempt(
-            attempt.attempt_id,
-            outcome,
-            usage,
-            time.time(),
-            reported_model,
-            safe_error_code,
-        )
-    except Exception:
-        reporting_failure(store, "attempt_terminal", attempt.run_id)
-
-
-def reporting_failure(
-    store: AgentRuntimeReportStore,
-    stage: str,
-    run_id: str,
-    extra: dict[str, str] | None = None,
-) -> None:
-    store.metrics.observe_reporting_failure(stage)
-    logger.exception(
-        "Agent Runtime 报表写入失败",
-        extra={"run_id": run_id, "report_stage": stage, **(extra or {})},
-    )