create-windy 0.8.3 → 0.10.0

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

@@ -1,182 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from pathlib import Path
-from typing import cast
-
-import pytest
-
-from southwind_agent_server.contracts import JsonValue
-from southwind_agent_server.sqlite_store import (
-    RunStoreCapacityError,
-    SqliteRunStore,
-)
-from southwind_agent_server.store import IdempotencyConflictError, RunRecord
-from southwind_agent_server.store_cipher import RunStoreCipher
-
-TEST_CIPHER = RunStoreCipher("test-secret-" * 4)
-
-
-async def test_terminal_run_and_cursor_survive_store_rebuild(
-    tmp_path: Path,
-) -> None:
-    path = str(tmp_path / "runs.sqlite3")
-    first = SqliteRunStore(path, TEST_CIPHER)
-    record = fixture("run_1", "key_1")
-    await first.create_or_get(record)
-    await first.append("run_1", "run.started")
-    await first.append("run_1", "output.delta", {"text": "你好"})
-    await first.complete("run_1", {"text": "你好"})
-    await first.close()
-
-    restored = SqliteRunStore(path, TEST_CIPHER)
-    current = await restored.get("run_1")
-    by_idempotency = await restored.get_by_idempotency("key_1")
-    events, terminal = await restored.events_after("run_1", 1, 0.01)
-    await restored.close()
-
-    assert current is not None
-    assert by_idempotency is not None
-    assert by_idempotency.run_id == current.run_id
-    assert current.status == "completed"
-    assert current.output == {"text": "你好"}
-    assert [event["sequence"] for event in events] == [2, 3]
-    assert terminal is True
-
-
-async def test_incomplete_run_recovers_as_one_safe_terminal(
-    tmp_path: Path,
-) -> None:
-    path = str(tmp_path / "runs.sqlite3")
-    first = SqliteRunStore(path, TEST_CIPHER)
-    await first.create_or_get(fixture("run_2", "key_2"))
-    await first.append("run_2", "run.started")
-    await first.close()
-
-    restored = SqliteRunStore(path, TEST_CIPHER)
-    current = await restored.get("run_2")
-    await restored.close()
-
-    assert current is not None
-    assert current.status == "failed"
-    assert [event["type"] for event in current.events] == [
-        "run.started",
-        "run.failed",
-    ]
-    error = cast(dict[str, object], current.events[-1]["error"])
-    assert error["code"] == "RUNTIME_UNAVAILABLE"
-    assert error["retryable"] is True
-    assert "secret" not in str(current.events)
-
-
-async def test_encrypted_waiting_run_is_recoverable(tmp_path: Path) -> None:
-    path = str(tmp_path / "recoverable.sqlite3")
-    first = SqliteRunStore(path, TEST_CIPHER)
-    await first.create_or_get(
-        fixture("run_wait", "key_wait"),
-        {
-            "kind": "agent",
-            "operationKey": "test.echo",
-            "input": {"text": "secret"},
-        },
-    )
-    await first.append("run_wait", "approval.required")
-    await first.close()
-
-    database_bytes = await asyncio.to_thread(Path(path).read_bytes)
-    assert "secret" not in database_bytes.decode(errors="ignore")
-    restored = SqliteRunStore(path, TEST_CIPHER)
-    recovered = await restored.recoverable()
-    await restored.close()
-
-    assert recovered[0][0].status == "awaiting-approval"
-    assert recovered[0][1] == {
-        "kind": "agent",
-        "operationKey": "test.echo",
-        "input": {"text": "secret"},
-    }
-
-
-async def test_event_and_run_capacity_are_bounded(tmp_path: Path) -> None:
-    store = SqliteRunStore(
-        str(tmp_path / "bounded.sqlite3"),
-        TEST_CIPHER,
-        max_runs=1,
-        max_events_per_run=3,
-    )
-    await store.create_or_get(fixture("run_3", "key_3"))
-    await store.append("run_3", "run.started")
-    await store.append("run_3", "output.delta", {"text": "one"})
-    with pytest.raises(RunStoreCapacityError):
-        await store.append("run_3", "output.delta", {"text": "two"})
-
-    current = await store.get("run_3")
-    assert current is not None
-    assert current.status == "failed"
-    assert current.events[-1]["type"] == "run.failed"
-
-    with pytest.raises(RunStoreCapacityError):
-        await store.create_or_get(fixture("run_4", "key_4"))
-    await store.close()
-
-
-async def test_release_evaluation_and_trace_are_immutable(tmp_path: Path) -> None:
-    store = SqliteRunStore(str(tmp_path / "release.sqlite3"), TEST_CIPHER)
-    original = fixture("run_release", "key_release")
-    await store.create_or_get(original)
-    first = await store.record_evaluation(
-        "release_test",
-        "quality",
-        "1",
-        {"accuracy": 0.9},
-    )
-    repeated = await store.record_evaluation(
-        "release_test",
-        "quality",
-        "1",
-        {"accuracy": 0.9},
-    )
-
-    conflicting = fixture("run_conflict", "key_conflict")
-    conflicting.release = {
-        **cast(dict[str, JsonValue], conflicting.release),
-        "promptVersion": "changed",
-    }
-    with pytest.raises(IdempotencyConflictError):
-        await store.create_or_get(conflicting)
-    with pytest.raises(IdempotencyConflictError):
-        await store.record_evaluation(
-            "release_test",
-            "quality",
-            "1",
-            {"accuracy": 0.8},
-        )
-
-    restored = await store.get("run_release")
-    assert first == repeated
-    assert restored is not None
-    assert restored.release == original.release
-    assert restored.trace_id == original.trace_id
-    assert await store.get("run_conflict") is None
-    await store.close()
-
-
-def fixture(run_id: str, idempotency_key: str) -> RunRecord:
-    return RunRecord(
-        run_id=run_id,
-        operation_key="test.echo",
-        input={"text": "hello"},
-        idempotency_key=idempotency_key,
-        fingerprint=f"fingerprint-{run_id}",
-        release={
-            "releaseId": "release_test",
-            "operationVersion": "1.0.0",
-            "workflowVersion": "workflow-1",
-            "promptVersion": "prompt-1",
-            "routeVersion": "route-1",
-            "outputSchemaVersion": "output-schema-1",
-            "toolSchemaVersion": "schema-1",
-            "manifestDigest": "0" * 64,
-        },
-        trace_id="1" * 32,
-    )

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

@@ -1,142 +0,0 @@
-import io
-import json
-import logging
-from importlib import import_module
-from typing import TextIO, cast
-
-import pytest
-
-from southwind_agent_server.structured_logging import (
-    MAX_LOG_BYTES,
-    AgentStructuredLogHandler,
-    agent_log_record,
-    configure_agent_logging,
-)
-
-
-def test_agent_report_failure_keeps_only_safe_correlation() -> None:
-    stream = io.StringIO()
-    handler = AgentStructuredLogHandler(stream)
-    logger = logging.getLogger("southwind_agent_server.test_structured_logging")
-    logger.addHandler(handler)
-    logger.setLevel(logging.WARNING)
-    logger.propagate = False
-    try:
-        try:
-            raise ValueError("secret-error")
-        except ValueError:
-            logger.exception(
-                "Agent Runtime 报表写入失败",
-                extra={
-                    "run_id": "run-1",
-                    "report_stage": "run_terminal",
-                    "request_id": "bad\nrequest-secret",
-                    "body": "secret-body",
-                    "authorization": "Bearer secret-token",
-                },
-            )
-    finally:
-        logger.removeHandler(handler)
-    line = stream.getvalue().strip()
-    parsed = json.loads(line)
-    assert parsed["event"] == "agent.report.write.failed"
-    assert parsed["errorCode"] == "AGENT_REPORT_WRITE_FAILED"
-    assert parsed["runId"] == "run-1"
-    assert parsed["stageKey"] == "run_terminal"
-    assert parsed["retentionClass"] == "operational"
-    assert len(line.encode("utf-8")) <= MAX_LOG_BYTES
-    assert all(
-        secret not in line
-        for secret in (
-            "request-secret",
-            "secret-body",
-            "secret-token",
-            "secret-error",
-        )
-    )
-
-
-def test_unknown_message_and_long_fields_are_bounded() -> None:
-    record = logging.makeLogRecord(
-        {
-            "name": "southwind_agent_server.service",
-            "levelno": logging.ERROR,
-            "msg": "secret-message",
-            "run_id": "x" * 500,
-            "report_stage": "payload secret",
-        }
-    )
-    safe = agent_log_record(record)
-    assert safe["event"] == "agent.runtime.failed"
-    assert "runId" not in safe
-    assert "stageKey" not in safe
-    assert "secret-message" not in json.dumps(safe)
-    assert len(json.dumps(safe).encode("utf-8")) <= MAX_LOG_BYTES
-
-
-def test_asgi_entrypoint_installs_handler_without_changing_app() -> None:
-    from southwind_agent_server.app import app
-
-    asgi = import_module("southwind_agent_server.asgi")
-    configure_agent_logging()
-    handlers = [
-        handler
-        for handler in logging.getLogger("southwind_agent_server").handlers
-        if isinstance(handler, AgentStructuredLogHandler)
-    ]
-    assert asgi.app is app
-    assert len(handlers) == 1
-
-
-def test_stdout_failure_does_not_interrupt_runtime() -> None:
-    class BrokenStream:
-        def write(self, _value: str) -> None:
-            raise OSError("stdout unavailable")
-
-        def flush(self) -> None:
-            raise OSError("stdout unavailable")
-
-    handler = AgentStructuredLogHandler(cast(TextIO, BrokenStream()))
-    record = logging.makeLogRecord(
-        {
-            "name": "southwind_agent_server.service",
-            "levelno": logging.ERROR,
-            "msg": "Agent Run 恢复轮询失败，将继续重试",
-        }
-    )
-    handler.emit(record)
-
-
-def test_bootstrap_removes_borrowed_sink_without_closing_uvicorn(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    stream = io.StringIO()
-    legacy_stream = io.StringIO()
-    legacy = logging.StreamHandler(legacy_stream)
-    structured = AgentStructuredLogHandler(stream)
-    logger = logging.getLogger("southwind_agent_server")
-    uvicorn = logging.getLogger("uvicorn")
-    monkeypatch.setattr(logger, "handlers", [legacy, structured])
-    monkeypatch.setattr(logger, "level", logging.INFO)
-    monkeypatch.setattr(logger, "propagate", False)
-    monkeypatch.setattr(uvicorn, "handlers", [legacy])
-    monkeypatch.setattr(uvicorn, "level", logging.INFO)
-    monkeypatch.setattr(uvicorn, "propagate", False)
-    closed: list[bool] = []
-    monkeypatch.setattr(legacy, "close", lambda: closed.append(True))
-
-    configure_agent_logging()
-    configure_agent_logging()
-    assert logger.handlers == [structured]
-    assert uvicorn.handlers == [legacy]
-    assert not closed
-    try:
-        raise ValueError("secret-exception")
-    except ValueError:
-        logger.exception("Agent Run 恢复轮询失败，将继续重试")
-    assert len(stream.getvalue().splitlines()) == 1
-    assert json.loads(stream.getvalue())["errorCode"] == "AGENT_RUN_RECOVERY_FAILED"
-    assert legacy_stream.getvalue() == ""
-    assert "secret-exception" not in stream.getvalue()
-    uvicorn.warning("independent-server-warning")
-    assert "independent-server-warning" in legacy_stream.getvalue()

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

@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-from opentelemetry import trace
-
-from southwind_agent_server.store import RunRecord
-from southwind_agent_server.telemetry import AgentRunTrace
-
-
-def test_agent_run_trace_uses_redacted_parent_and_metadata_only() -> None:
-    record = RunRecord(
-        run_id="run_trace",
-        operation_key="business.answer",
-        input={"secret": "never-export"},
-        idempotency_key="key_trace",
-        fingerprint="0" * 64,
-        release={"releaseId": "release_trace"},
-        trace_id="1" * 32,
-    )
-    run_trace = AgentRunTrace(record)
-    run_trace.start()
-    current = trace.get_current_span().get_span_context()
-    run_trace.finish("completed")
-
-    assert f"{current.trace_id:032x}" == record.trace_id
-    assert current.is_valid

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

@@ -1,28 +0,0 @@
-from southwind_agent_server.tool_host import (
-    ToolApprovalPending,
-    approval_pending,
-    canonical_tool_call_id,
-)
-
-
-def test_tool_call_id_is_stable_across_provider_attempts() -> None:
-    first = canonical_tool_call_id(
-        "run-1",
-        "case.finding.merge",
-        {"expectedVersion": 3, "ids": ["a", "b"]},
-    )
-    second = canonical_tool_call_id(
-        "run-1",
-        "case.finding.merge",
-        {"ids": ["a", "b"], "expectedVersion": 3},
-    )
-
-    assert first == second
-    assert first.startswith("tool_")
-
-
-def test_parses_only_typed_approval_pending_response() -> None:
-    error = approval_pending(b'{"code":"APPROVAL_REQUIRED","workItemId":"work-1"}')
-
-    assert isinstance(error, ToolApprovalPending)
-    assert error.work_item_id == "work-1"