create-windy 0.8.3 → 0.9.1

package/template/apps/agent-server/tests/test_tool_structured_output.py

@@ -1,347 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import json
-import sqlite3
-from dataclasses import replace
-from pathlib import Path
-from typing import cast
-
-import httpx
-import pytest
-
-from southwind_agent_server.attempt_context import govern_provider_attempt
-from southwind_agent_server.attempt_context_projection import (
-    AttemptContextPreparation,
-    governed_envelope,
-)
-from southwind_agent_server.context_message_digest import canonical_json_digest
-from southwind_agent_server.context_version_port import (
-    PreparedContext,
-    PreparedSource,
-    UnavailableContextVersionPort,
-)
-from southwind_agent_server.contracts import JsonValue, ProviderFieldPolicy
-from southwind_agent_server.engine import (
-    EngineCompleted,
-    EngineRunRequest,
-    SafeEngineError,
-    ToolCompleted,
-)
-from southwind_agent_server.openai_engine import OpenAiCompatibleEngineAdapter
-from southwind_agent_server.tool_host import ToolHostClient
-from tests.openai_provider_test_support import (
-    create_provider,
-    governance,
-    runtime_request,
-    sse_response,
-)
-
-SCHEMA: dict[str, JsonValue] = {
-    "type": "object",
-    "properties": {"total": {"type": "integer"}},
-    "required": ["total"],
-    "additionalProperties": False,
-}
-
-
-def structured_request() -> EngineRunRequest:
-    request = runtime_request("business.records.list")
-    return replace(
-        request,
-        output_schema_key="business.answer.v1",
-        output_schema=SCHEMA,
-        provider_data_policy=request.provider_data_policy.model_copy(
-            update={
-                "envelope_fields": [
-                    *request.provider_data_policy.envelope_fields,
-                    ProviderFieldPolicy(
-                        field="output-schema",
-                        classification="internal",
-                        dlp_action="redact",
-                    ),
-                ]
-            }
-        ),
-    )
-
-
-def test_tool_payload_uses_schema_guidance_without_mutation_or_duplicate() -> None:
-    provider = create_provider(httpx.MockTransport(lambda _: httpx.Response(500)))
-    request = runtime_request("business.records.list")
-    messages: list[dict[str, JsonValue]] = [{"role": "system", "content": "原指令"}]
-    body = provider.request_body(messages, request.allowed_tools, "answer.v1", SCHEMA)
-    payload = json.loads(body)
-    assert "response_format" not in payload
-    assert payload["tools"][0]["function"]["name"] == "business.records.list"
-    assert payload["messages"][0]["content"].startswith("原指令\n\n")
-    assert (
-        json.dumps(SCHEMA, ensure_ascii=False, separators=(",", ":"))
-        in payload["messages"][0]["content"]
-    )
-    assert messages[0]["content"] == "原指令"
-    assert (
-        provider.request_body(
-            payload["messages"], request.allowed_tools, "answer.v1", SCHEMA
-        )
-        == body
-    )
-    plain = json.loads(provider.request_body(messages, (), "answer.v1", SCHEMA))
-    assert plain["messages"] == messages
-    assert plain["response_format"]["json_schema"]["strict"] is True
-
-
-@pytest.mark.parametrize("final", ['{"total":1}', '{"total":"1"}', "```json\n{}\n```"])
-async def test_real_function_round_keeps_strict_final_schema(final: str) -> None:
-    turns = 0
-    calls = 0
-
-    async def provider_handler(request: httpx.Request) -> httpx.Response:
-        nonlocal turns
-        turns += 1
-        body = json.loads(request.content)
-        assert "response_format" not in body
-        assert '"required":["total"]' in body["messages"][0]["content"]
-        if turns == 1:
-            return sse_response(
-                [
-                    {
-                        "choices": [
-                            {
-                                "delta": {
-                                    "tool_calls": [
-                                        {
-                                            "index": 0,
-                                            "id": "call_1",
-                                            "function": {
-                                                "name": "business.records.list",
-                                                "arguments": "{}",
-                                            },
-                                        }
-                                    ]
-                                }
-                            }
-                        ]
-                    }
-                ]
-            )
-        assert body["messages"][-1]["role"] == "tool"
-        return sse_response([{"choices": [{"delta": {"content": final}}]}])
-
-    async def tool_handler(request: httpx.Request) -> httpx.Response:
-        nonlocal calls
-        calls += 1
-        assert json.loads(request.content)["executionGrant"] == "grant_1"
-        return httpx.Response(200, json={"value": {"total": 1}})
-
-    engine = OpenAiCompatibleEngineAdapter(
-        create_provider(httpx.MockTransport(provider_handler)),
-        ToolHostClient("internal-token", transport=httpx.MockTransport(tool_handler)),
-        governance(),
-    )
-    request = structured_request()
-    if final == '{"total":1}':
-        signals = [signal async for signal in engine.execute(request)]
-        assert any(isinstance(signal, ToolCompleted) for signal in signals)
-        assert isinstance(signals[-1], EngineCompleted)
-        assert signals[-1].output == {"total": 1}
-    else:
-        with pytest.raises(SafeEngineError) as denied:
-            _ = [signal async for signal in engine.execute(request)]
-        assert denied.value.code == "OUTPUT_VALIDATION_FAILED"
-    assert turns == 2 and calls == 1
-
-
-async def test_text_tool_call_is_not_executable() -> None:
-    async def provider_handler(_: httpx.Request) -> httpx.Response:
-        return sse_response(
-            [
-                {
-                    "choices": [
-                        {
-                            "delta": {
-                                "content": (
-                                    '{"tool_calls":[{"name":"business.records.list",'
-                                    '"arguments":{}}]}'
-                                )
-                            }
-                        }
-                    ]
-                }
-            ]
-        )
-
-    async def tool_handler(_: httpx.Request) -> httpx.Response:
-        pytest.fail("正文中的工具调用不得执行")
-
-    engine = OpenAiCompatibleEngineAdapter(
-        create_provider(httpx.MockTransport(provider_handler)),
-        ToolHostClient("internal-token", transport=httpx.MockTransport(tool_handler)),
-        governance(),
-    )
-    with pytest.raises(SafeEngineError) as denied:
-        _ = [signal async for signal in engine.execute(structured_request())]
-    assert denied.value.code == "OUTPUT_VALIDATION_FAILED"
-
-
-async def test_governed_guidance_matches_audit_and_context_bytes(
-    tmp_path: Path,
-) -> None:
-    request = structured_request()
-    request = replace(
-        request, output_schema={**SCHEMA, "description": "password=secret"}
-    )
-    provider = create_provider(httpx.MockTransport(lambda _: httpx.Response(500)))
-    audit_path = str(tmp_path / "audit.sqlite3")
-    messages: list[dict[str, JsonValue]] = [
-        {"role": "system", "content": request.instructions},
-        {"role": "user", "content": "历史来源"},
-        {"role": "user", "content": request.user_prompt},
-    ]
-    prepared = await govern_provider_attempt(
-        UnavailableContextVersionPort(),
-        governance(audit_path),
-        provider,
-        request,
-        1,
-        None,
-        messages,
-    )
-    payload = json.loads(prepared.provider_request)
-    assert payload["messages"] == prepared.governed.messages
-    assert "password=secret" not in prepared.provider_request.decode()
-    assert "[REDACTED]" in payload["messages"][0]["content"]
-    with sqlite3.connect(audit_path) as connection:
-        assert connection.execute(
-            "select sent_bytes, decision from provider_attempt_audit"
-        ).fetchone() == (len(prepared.provider_request), "redact")
-    source = PreparedSource(
-        "business", "session", "source-1", "v1", 1, "a" * 64, {}, "历史来源", "user"
-    )
-    envelope = governed_envelope(
-        AttemptContextPreparation(
-            PreparedContext("preparation-1", (source,)), messages, 1
-        ),
-        request.run_id,
-        "attempt-1",
-        prepared.governed.messages,
-        prepared.provider_request,
-        provider.config.deployment_key,
-        provider.config.model,
-        request.prompt_version,
-        (),
-    )
-    entries = cast(list[dict[str, JsonValue]], envelope["messages"])
-    assert entries[0]["content"] == payload["messages"][0]["content"]
-    assert (
-        cast(list[dict[str, JsonValue]], entries[1]["origins"])[0]["sourceId"]
-        == "source-1"
-    )
-    provider_fields = cast(dict[str, JsonValue], envelope["provider"])
-    assert (
-        provider_fields["requestDigest"]
-        == hashlib.sha256(prepared.provider_request).hexdigest()
-    )
-    assert provider_fields["outputSchemaDigest"] == hashlib.sha256(b"null").hexdigest()
-    assert entries[0]["digest"] == canonical_json_digest(payload["messages"][0])
-    assert entries[0]["digest"] != canonical_json_digest(cast(JsonValue, messages[0]))
-
-
-async def test_schema_guidance_still_requires_output_schema_authorization() -> None:
-    request = structured_request()
-    request = replace(
-        request,
-        provider_data_policy=runtime_request(
-            "business.records.list"
-        ).provider_data_policy,
-    )
-    with pytest.raises(SafeEngineError) as denied:
-        await govern_provider_attempt(
-            UnavailableContextVersionPort(),
-            governance(),
-            create_provider(httpx.MockTransport(lambda _: httpx.Response(500))),
-            request,
-            1,
-            None,
-            [{"role": "system", "content": "指令"}],
-        )
-    assert denied.value.code == "FORBIDDEN"
-
-
-async def test_schema_guidance_counts_toward_input_token_budget() -> None:
-    calls = 0
-
-    async def handler(_: httpx.Request) -> httpx.Response:
-        nonlocal calls
-        calls += 1
-        return sse_response([])
-
-    provider = create_provider(httpx.MockTransport(handler))
-    request = structured_request()
-    messages: list[dict[str, JsonValue]] = [
-        {"role": "system", "content": request.instructions},
-        {"role": "user", "content": request.user_prompt},
-    ]
-    original_bytes = len(provider.request_body(messages, request.allowed_tools))
-    assert original_bytes < 1024
-    request = replace(
-        request,
-        output_schema={**SCHEMA, "description": "业务结果字段说明。" * 100},
-        limits=request.limits.model_copy(update={"max_input_tokens": original_bytes}),
-    )
-    engine = OpenAiCompatibleEngineAdapter(
-        provider, ToolHostClient("internal-token"), governance()
-    )
-    with pytest.raises(SafeEngineError) as denied:
-        _ = [signal async for signal in engine.execute(request)]
-    assert denied.value.code == "BUDGET_EXCEEDED"
-    assert calls == 0
-
-
-async def test_tool_schema_respects_model_attempt_limit() -> None:
-    calls = 0
-
-    async def handler(_: httpx.Request) -> httpx.Response:
-        nonlocal calls
-        calls += 1
-        return sse_response(
-            [
-                {
-                    "choices": [
-                        {
-                            "delta": {
-                                "tool_calls": [
-                                    {
-                                        "index": 0,
-                                        "id": "call_1",
-                                        "function": {
-                                            "name": "business.records.list",
-                                            "arguments": "{}",
-                                        },
-                                    }
-                                ]
-                            }
-                        }
-                    ]
-                }
-            ]
-        )
-
-    request = structured_request()
-    request = replace(
-        request, limits=request.limits.model_copy(update={"max_model_attempts": 1})
-    )
-    engine = OpenAiCompatibleEngineAdapter(
-        create_provider(httpx.MockTransport(handler)),
-        ToolHostClient(
-            "internal-token",
-            transport=httpx.MockTransport(
-                lambda _: httpx.Response(200, json={"value": {"total": 1}})
-            ),
-        ),
-        governance(),
-    )
-    with pytest.raises(SafeEngineError) as denied:
-        _ = [signal async for signal in engine.execute(request)]
-    assert denied.value.code == "BUDGET_EXCEEDED"
-    assert calls == 1

package/template/apps/agent-server/tests/test_trajectory.py

@@ -1,91 +0,0 @@
-from typing import cast
-
-from southwind_agent_server.store import RunRecord
-from southwind_agent_server.trajectory import project_run_trajectory
-
-
-def test_trajectory_preserves_governed_signals_without_sensitive_payloads() -> None:
-    record = RunRecord(
-        run_id="run_1",
-        operation_key="business.answer",
-        input={"prompt": "输入正文"},
-        idempotency_key="idem_1",
-        fingerprint="fingerprint_1",
-        release={"releaseId": "legacy"},
-        events=[
-            {"type": "run.started", "sequence": 1},
-            {
-                "type": "input.prepared",
-                "sequence": 2,
-                "artifactCount": 1,
-                "inputModalities": ["text", "image"],
-            },
-            {
-                "type": "output.delta",
-                "sequence": 3,
-                "text": "第一段输出",
-            },
-            {
-                "type": "output.delta",
-                "sequence": 4,
-                "text": "第二段输出",
-            },
-            {
-                "type": "tool.requested",
-                "sequence": 5,
-                "toolCallId": "call_secret",
-                "toolKey": "business.search",
-                "arguments": {"secret": "不可暴露"},
-            },
-            {
-                "type": "approval.required",
-                "sequence": 6,
-                "toolCallId": "call_secret",
-                "workItemId": "approval_secret",
-            },
-            {
-                "type": "approval.resolved",
-                "sequence": 7,
-                "toolCallId": "call_secret",
-                "workItemId": "approval_secret",
-                "outcome": "approved",
-            },
-            {"type": "tool.completed", "sequence": 8, "toolCallId": "call_secret"},
-            {
-                "type": "usage.reported",
-                "sequence": 9,
-                "attemptSequence": 1,
-                "usage": {"totalTokens": 24, "providerBody": "不可暴露"},
-            },
-            {"type": "run.completed", "sequence": 10},
-        ],
-    )
-
-    trajectory = project_run_trajectory(record)
-    events = cast(list[dict[str, object]], trajectory["events"])
-
-    assert trajectory["available"] is True
-    assert events[2] == {
-        "sequence": 3,
-        "sequenceEnd": 4,
-        "type": "output.delta",
-        "title": "模型生成输出",
-        "deltaCount": 2,
-        "outputCharacters": 10,
-    }
-    assert events[3]["toolKey"] == "business.search"
-    assert events[5]["approvalOutcome"] == "approved"
-    serialized = repr(trajectory)
-    for sensitive in (
-        "输入正文",
-        "第一段输出",
-        "第二段输出",
-        "call_secret",
-        "approval_secret",
-        "不可暴露",
-    ):
-        assert sensitive not in serialized
-
-
-def test_trajectory_marks_expired_canonical_run_as_unavailable() -> None:
-    assert project_run_trajectory(None) == {"available": False, "events": []}

package/template/apps/agent-server/tests/test_vision_readiness_enforcement.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from southwind_agent_server.contracts import StartRunRequest
-from southwind_agent_server.engine import SafeEngineError
-from southwind_agent_server.fingerprint import request_fingerprint
-from southwind_agent_server.vision_requirement import require_vision_readiness
-
-
-def vision_request(**values: object) -> StartRunRequest:
-    base: dict[str, object] = {
-        "operation_key": "evidence.image.inspect",
-        "input": None,
-        "input_modalities": ["text", "image"],
-        "required_capabilities": ["text-generation", "vision"],
-    }
-    return StartRunRequest(**{**base, **values})  # type: ignore[arg-type]
-
-
-class ReadyEngine:
-    async def readiness(self) -> dict[str, object]:
-        deployment = {
-            "key": "ai.openai-compatible",
-            "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
-            "releaseDigest": "sha256:" + "d" * 64,
-            "offersDigest": "sha256:" + "a" * 64,
-        }
-        return {
-            "status": "ready",
-            "deployment": deployment,
-            "downstreamProbe": {
-                "status": "passed",
-                **{
-                    "deploymentIdentity": deployment["identity"],
-                    "releaseDigest": deployment["releaseDigest"],
-                    "offersDigest": deployment["offersDigest"],
-                },
-            },
-        }
-
-
-async def test_vision_requires_pin_and_rejects_deployment_drift() -> None:
-    with pytest.raises(SafeEngineError, match="VLM Runtime"):
-        await require_vision_readiness(ReadyEngine(), vision_request())
-
-    pin = {
-        "key": "ai.openai-compatible",
-        "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
-        "releaseDigest": "sha256:" + "d" * 64,
-        "offersDigest": "sha256:" + "a" * 64,
-    }
-    await require_vision_readiness(ReadyEngine(), vision_request(readiness_pin=pin))
-    drifted = vision_request(
-        readiness_pin={**pin, "offersDigest": "sha256:" + "b" * 64}
-    )
-    with pytest.raises(SafeEngineError, match="VLM Runtime"):
-        await require_vision_readiness(ReadyEngine(), drifted)
-
-
-def test_readiness_pin_changes_idempotency_fingerprint() -> None:
-    pin = {
-        "key": "ai.openai-compatible",
-        "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
-        "releaseDigest": "sha256:" + "d" * 64,
-        "offersDigest": "sha256:" + "a" * 64,
-    }
-    first = request_fingerprint(vision_request(readiness_pin=pin))
-    second = request_fingerprint(
-        vision_request(readiness_pin={**pin, "offersDigest": "sha256:" + "b" * 64})
-    )
-    assert first != second

package/template/apps/agent-server/tests/test_vlm_readiness.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-from base64 import b64decode
-from datetime import UTC, datetime
-from io import BytesIO
-
-from PIL import Image
-
-from southwind_agent_server.config import OpenAiCompatibleConfig
-from southwind_agent_server.engine import SafeEngineError
-from southwind_agent_server.vision_probe import _PROBE_IMAGE
-from southwind_agent_server.vlm_readiness import VlmReadinessProbe
-
-
-class ProbeProvider:
-    def __init__(self, error: SafeEngineError | None = None) -> None:
-        self.calls = 0
-        self.error = error
-
-    async def probe_vision(self) -> None:
-        self.calls += 1
-        if self.error:
-            raise self.error
-
-
-def test_synthetic_probe_image_is_a_decodable_red_pixel() -> None:
-    encoded = _PROBE_IMAGE.removeprefix("data:image/png;base64,")
-    with Image.open(BytesIO(b64decode(encoded))) as image:
-        image.load()
-        assert image.size == (1, 1)
-        assert image.convert("RGB").getpixel((0, 0)) == (255, 0, 0)
-
-
-def config(**values: object) -> OpenAiCompatibleConfig:
-    base: dict[str, object] = {
-        "base_url": "http://vlm.internal/v1",
-        "model": "vlm",
-        "api_key_ref": None,
-        "capabilities": ("text-generation", "vision"),
-        "input_modalities": ("text", "image"),
-        "readiness_deployment_identity": (
-            "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04"
-        ),
-        "readiness_release_digest": "sha256:" + "d" * 64,
-    }
-    return OpenAiCompatibleConfig(**{**base, **values})  # type: ignore[arg-type]
-
-
-async def test_vlm_readiness_requires_synthetic_image_inference() -> None:
-    provider = ProbeProvider()
-    now = datetime(2026, 8, 6, tzinfo=UTC)
-    snapshot = await VlmReadinessProbe(
-        config(), provider, wall_clock=lambda: now
-    ).inspect()
-
-    assert provider.calls == 1
-    assert snapshot["status"] == "ready"
-    assert snapshot["runtimeKind"] == "agent"
-    assert snapshot["offers"] == [
-        {
-            "variant": "vision",
-            "capabilities": ["text-generation", "vision"],
-            "inputModalities": ["text", "image"],
-            "outputModalities": ["text"],
-            "limits": {
-                "maxDurationSeconds": 300,
-                "maxInputBytes": 67_108_864,
-                "maxOutputBytes": 2 * 1024 * 1024,
-                "maxArtifacts": 16,
-                "maxPixelsPerArtifact": 100_000_000,
-                "maxConcurrentRuns": 1,
-                "maxQueueDepth": 0,
-            },
-        }
-    ]
-    assert snapshot["deployment"] == {
-        "key": "ai.openai-compatible",
-        "identity": "windy-deployment-v1_f31e8a65-92cb-4d03-8a77-3c1b5e9d4f04",
-        "releaseDigest": "sha256:" + "d" * 64,
-        "offersDigest": "sha256:"
-        "7beb2eeb442fd68c90d94b9469db732acdc51222e152ae0be3ae7be00d2459b2",
-    }
-
-
-async def test_vlm_readiness_does_not_claim_unconfigured_or_failed_vision() -> None:
-    unconfigured = ProbeProvider()
-    no_vision = await VlmReadinessProbe(
-        config(capabilities=("text-generation",)), unconfigured
-    ).inspect()
-    assert unconfigured.calls == 0
-    assert no_vision["status"] == "unavailable"
-    assert no_vision["configured"] is False
-
-    unavailable = await VlmReadinessProbe(
-        config(),
-        ProbeProvider(SafeEngineError("PROVIDER_UNAVAILABLE", "safe", retryable=True)),
-        wall_clock=lambda: datetime(2026, 8, 6, tzinfo=UTC),
-    ).inspect()
-    assert unavailable["status"] == "unavailable"
-    assert unavailable["downstreamProbe"] == {
-        "status": "failed",
-        "checkedAt": unavailable["observedAt"],
-        "latencyMs": 0,
-        "failureCode": "RESOURCE_UNAVAILABLE",
-        "retryable": True,
-    }