create-windy 0.4.1 → 0.5.1

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

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import asyncio
+
+from southwind_agent_server.contracts import (
+    RunReportingContext,
+    StartRunRequest,
+)
+from southwind_agent_server.deterministic import DeterministicEngineAdapter
+from southwind_agent_server.report_store import (
+    InMemoryAgentRuntimeReportStore,
+)
+from southwind_agent_server.service import AgentRunService
+from southwind_agent_server.store import (
+    CanonicalEvent,
+    InMemoryRunStore,
+    RunRecord,
+)
+
+
+def request(text: str = "done") -> StartRunRequest:
+    return StartRunRequest(
+        operation_key="test.echo",
+        input={"text": text},
+        trace_id="trace_1",
+        reporting=RunReportingContext(
+            actor_id="actor_1",
+            actor_type="user",
+        ),
+    )
+
+
+async def test_rewritten_event_terminal_drives_report_status() -> None:
+    canonical = EventLimitRunStore()
+    report = InMemoryAgentRuntimeReportStore()
+    service = AgentRunService(
+        DeterministicEngineAdapter(),
+        canonical,
+        report,
+    )
+
+    record = await service.start(request(), "event-limit")
+    final = await wait_for_terminal(service, record.run_id)
+    detail = await report.get_run(record.run_id)
+    await service.close()
+
+    assert final.status == "failed"
+    assert detail is not None
+    assert detail["status"] == "failed"
+    assert detail["safeErrorCode"] == "BUDGET_EXCEEDED"
+
+
+async def test_output_limit_terminal_drives_report_status() -> None:
+    canonical = OutputLimitRunStore()
+    report = InMemoryAgentRuntimeReportStore()
+    service = AgentRunService(
+        DeterministicEngineAdapter(),
+        canonical,
+        report,
+    )
+
+    record = await service.start(request("too large"), "output-limit")
+    final = await wait_for_terminal(service, record.run_id)
+    detail = await report.get_run(record.run_id)
+    await service.close()
+
+    assert final.status == "failed"
+    assert detail is not None
+    assert detail["status"] == "failed"
+    assert detail["safeErrorCode"] == "BUDGET_EXCEEDED"
+
+
+async def test_completion_wins_cancel_race_in_report() -> None:
+    canonical = CompleteWinsCancelRunStore()
+    report = InMemoryAgentRuntimeReportStore()
+    service = AgentRunService(
+        DeterministicEngineAdapter(),
+        canonical,
+        report,
+    )
+    invocation = request()
+    record = run_record(invocation, "race")
+    await canonical.create_or_get(record, invocation.model_dump(by_alias=True))
+    await report.ensure_run(record.run_id, invocation, 100.0)
+    await report.start_run(record.run_id, 101.0)
+
+    final = await service.cancel(record.run_id)
+    detail = await report.get_run(record.run_id)
+    await service.close()
+
+    assert final.status == "completed"
+    assert detail is not None
+    assert detail["status"] == "completed"
+
+
+async def wait_for_terminal(
+    service: AgentRunService,
+    run_id: str,
+) -> RunRecord:
+    async def poll() -> RunRecord:
+        while True:
+            record = await service.get(run_id)
+            if record.terminal:
+                return record
+            await asyncio.sleep(0)
+
+    return await asyncio.wait_for(poll(), 1)
+
+
+def run_record(invocation: StartRunRequest, suffix: str) -> RunRecord:
+    return RunRecord(
+        run_id=f"run_{suffix}",
+        operation_key=invocation.operation_key,
+        input=invocation.input,
+        idempotency_key=f"key_{suffix}",
+        fingerprint=f"fingerprint_{suffix}",
+        release=invocation.release.model_dump(by_alias=True),
+        trace_id=invocation.trace_id,
+    )
+
+
+def failure_event(run_id: str, sequence: int) -> CanonicalEvent:
+    return {
+        "type": "run.failed",
+        "runId": run_id,
+        "sequence": sequence,
+        "error": {
+            "code": "BUDGET_EXCEEDED",
+            "message": "Agent 存储超过安全上限",
+            "requestId": f"request_{sequence}",
+            "retryable": False,
+        },
+    }
+
+
+class EventLimitRunStore(InMemoryRunStore):
+    async def append(
+        self,
+        run_id: str,
+        event_type: str,
+        fields: dict[str, object] | None = None,
+    ) -> CanonicalEvent | None:
+        if event_type == "usage.reported":
+            record = await self.get(run_id)
+            assert record is not None
+            event = failure_event(run_id, len(record.events) + 1)
+            return await super().append(
+                run_id,
+                "run.failed",
+                {"error": event["error"]},
+            )
+        return await super().append(run_id, event_type, fields)
+
+
+class OutputLimitRunStore(InMemoryRunStore):
+    async def complete(self, run_id: str, output: object) -> None:
+        del output
+        record = await self.get(run_id)
+        assert record is not None
+        event = failure_event(run_id, len(record.events) + 1)
+        await super().append(
+            run_id,
+            "run.failed",
+            {"error": event["error"]},
+        )
+
+
+class CompleteWinsCancelRunStore(InMemoryRunStore):
+    async def append(
+        self,
+        run_id: str,
+        event_type: str,
+        fields: dict[str, object] | None = None,
+    ) -> CanonicalEvent | None:
+        if event_type == "run.cancelled":
+            await super().complete(run_id, {"winner": "complete"})
+        return await super().append(run_id, event_type, fields)

package/template/apps/server/src/agent/debug-session-facade-provider-failure.test.ts

@@ -0,0 +1,269 @@
+import { describe, expect, test } from "bun:test";
+import type { ModuleManifest } from "@southwind-ai/modules";
+import {
+  MODULE_DEBUG_SESSION_SCHEMA_VERSION,
+  type ModuleDebugSessionProviderV1,
+} from "@southwind-ai/server-sdk";
+import { featureKey } from "@southwind-ai/shared";
+import {
+  bindModuleUserProjection,
+  createRequestGuardContext,
+  type RequestActor,
+} from "../guards.js";
+import type { InitializedModuleHosts } from "../module-host.js";
+import { manifest } from "../module-host/test-fixtures.js";
+import { createServerRuntime } from "../runtime.js";
+import { DebugSessionFacadeV1 } from "./debug-session-facade.js";
+import { DebugSessionIdCodecV1 } from "./debug-session-id.js";
+
+const OPERATION_KEY = "known.copilot.global";
+const SOURCE_ID = "conversation-sensitive-42";
+const SECRET_FAILURE = `provider failed for ${SOURCE_ID}`;
+
+describe("ADK 调试会话 Provider 故障隔离", () => {
+  test("一个 Provider 故障时 fail closed，避免把 partial 伪装成完整列表", async () => {
+    const failing = provider("known.failing-history", {
+      list: async () => {
+        throw new Error(SECRET_FAILURE);
+      },
+      get: async () => undefined,
+    });
+    const healthy = provider("known.healthy-history", {
+      list: async () => ({
+        sessions: [summary("conversation-healthy")],
+        truncated: false,
+      }),
+      get: async () => ({
+        ...summary("conversation-healthy"),
+        messages: [],
+      }),
+    });
+    const fixture = createFixture([failing, healthy]);
+
+    await expect(
+      fixture.facade.list(fixture.context, signal()),
+    ).rejects.toMatchObject({
+      code: "PROVIDER_UNAVAILABLE",
+      status: 503,
+    });
+    const failure = fixture.runtime.auditSink
+      .list()
+      .find(({ outcome }) => outcome === "failure");
+    expect(failure).toMatchObject({
+      action: "known.copilot.history.read",
+      outcome: "failure",
+      target: {
+        type: "agent-debug-session-provider",
+        id: "known.failing-history",
+      },
+      metadata: {
+        debugDataActorId: "user_dev_admin",
+        mode: "list",
+        phase: "list",
+        failureCode: "PROVIDER_UNAVAILABLE",
+      },
+    });
+    expect(JSON.stringify(failure)).not.toContain(SECRET_FAILURE);
+  });
+
+  test("存在 Provider 且全部失败时返回 503", async () => {
+    const fixture = createFixture([
+      failingProvider("known.first-history"),
+      failingProvider("known.second-history"),
+    ]);
+
+    await expect(
+      fixture.facade.list(fixture.context, signal()),
+    ).rejects.toMatchObject({
+      code: "PROVIDER_UNAVAILABLE",
+      status: 503,
+    });
+    expect(
+      fixture.runtime.auditSink
+        .list()
+        .filter(({ outcome }) => outcome === "failure"),
+    ).toHaveLength(2);
+  });
+
+  test("详情读取遇到 Provider 故障且最终未命中时返回 503", async () => {
+    let failDetail = false;
+    const unstable = provider("known.unstable-history", {
+      list: async () => ({
+        sessions: [summary(SOURCE_ID)],
+        truncated: false,
+      }),
+      get: async () => {
+        if (failDetail) throw new Error(SECRET_FAILURE);
+        return { ...summary(SOURCE_ID), messages: [] };
+      },
+    });
+    const empty = provider("known.empty-history", {
+      list: async () => ({ sessions: [], truncated: false }),
+      get: async () => undefined,
+    });
+    const fixture = createFixture([unstable, empty]);
+    const listed = await fixture.facade.list(fixture.context, signal());
+    failDetail = true;
+
+    await expect(
+      fixture.facade.get(
+        listed.sessions[0]?.id ?? "",
+        fixture.context,
+        signal(),
+      ),
+    ).rejects.toMatchObject({
+      code: "PROVIDER_UNAVAILABLE",
+      status: 503,
+    });
+    const failure = fixture.runtime.auditSink
+      .list()
+      .find(
+        ({ outcome, metadata }) =>
+          outcome === "failure" && metadata?.phase === "get",
+      );
+    expect(failure?.metadata).toMatchObject({
+      mode: "get",
+      phase: "get",
+      failureCode: "PROVIDER_UNAVAILABLE",
+    });
+    expect(JSON.stringify(failure)).not.toContain(SECRET_FAILURE);
+  });
+});
+
+function failingProvider(key: string): ModuleDebugSessionProviderV1 {
+  return provider(key, {
+    list: async () => {
+      throw new Error(SECRET_FAILURE);
+    },
+    get: async () => undefined,
+  });
+}
+
+function provider(
+  key: string,
+  methods: Pick<ModuleDebugSessionProviderV1, "list" | "get">,
+): ModuleDebugSessionProviderV1 {
+  return {
+    schemaVersion: MODULE_DEBUG_SESSION_SCHEMA_VERSION,
+    key,
+    operationKeys: [OPERATION_KEY],
+    featureKey: "known.copilot",
+    permissionKey: "known.copilot.execute",
+    auditAction: "known.copilot.history.read",
+    ...methods,
+  };
+}
+
+function createFixture(providers: readonly ModuleDebugSessionProviderV1[]) {
+  const module = debugManifest();
+  const hosts = {
+    debugSessionProviders: providers.map((provider) => ({
+      moduleName: "known",
+      provider,
+    })),
+    manifestOf(moduleName: string) {
+      if (moduleName !== "known") throw new Error("unknown module");
+      return module;
+    },
+  } as unknown as InitializedModuleHosts;
+  const base = createServerRuntime(
+    {},
+    {
+      featureCatalog: module.features,
+      licenseResolver: { resolve: () => ({ status: "valid" }) },
+    },
+  );
+  const runtime = {
+    ...base,
+    agentDebugOperationForActor: (actorId: string) =>
+      actorId === "service_adk_debug" ? OPERATION_KEY : undefined,
+  };
+  const context = createRequestGuardContext(
+    new Request("http://localhost/api/agent/debug/sessions/v1"),
+    {
+      resolveActor: () => bindModuleUserProjection(actor(), "user_dev_admin"),
+      resolveLicense: () => ({ status: "valid" }),
+      licenseEnforced: false,
+    },
+  );
+  return {
+    context,
+    facade: new DebugSessionFacadeV1(
+      hosts,
+      runtime,
+      new DebugSessionIdCodecV1("test-secret-012345678901234567890123456789"),
+    ),
+    runtime,
+  };
+}
+
+function actor(): RequestActor {
+  return {
+    id: "service_adk_debug",
+    type: "service",
+    name: "ADK Debug",
+    roleCodes: ["adk-debug"],
+    permissionKeys: ["known.copilot.execute"],
+  };
+}
+
+function summary(sourceId: string) {
+  return {
+    sourceId,
+    title: "历史研判",
+    scopeLabel: "测试范围",
+    updatedAt: "2026-07-31T01:00:01.000Z",
+    revision: "2",
+  };
+}
+
+function signal(): AbortSignal {
+  return new AbortController().signal;
+}
+
+function debugManifest(): ModuleManifest {
+  return manifest("known", {
+    features: [
+      {
+        key: featureKey("known.copilot"),
+        label: "Copilot",
+        module: "known",
+        visible: "visible",
+        enabled: true,
+        stage: "stable",
+      },
+    ],
+    permissions: [
+      {
+        key: "known.copilot.execute",
+        label: "使用 Copilot",
+        module: "known",
+        moduleLabel: "Known",
+        resource: "copilot",
+        resourceLabel: "Copilot",
+        action: "execute",
+      },
+    ],
+    aiOperations: [
+      {
+        key: OPERATION_KEY,
+        kind: "agent",
+        featureKey: "known.copilot",
+        permissionKey: "known.copilot.execute",
+        auditAction: "known.copilot.execute",
+        inputSchemaKey: "known.copilot.input.v1",
+        outputSchemaKey: "known.copilot.output.v1",
+        requiredCapabilities: ["text-generation"],
+        allowedToolKeys: [],
+        dataClassification: "internal",
+        execution: "streaming",
+        limits: {
+          maxDurationSeconds: 60,
+          maxInputBytes: 4096,
+          maxOutputBytes: 4096,
+        },
+      },
+    ],
+    auditActions: ["known.copilot.execute", "known.copilot.history.read"],
+  });
+}