create-windy 0.6.9 → 0.6.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-windy",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "description": "创建单组织、单租户、私有部署优先的 Windy 企业 Dashboard Starter",
   "type": "module",
   "bin": {

package/template/.windy-template.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "templateCommit": "9176c4dc2db60979b5ce7fd89639da90648c49b9",
-  "generatorVersion": "0.6.9",
+  "templateCommit": "c1a0ff6aad5361fef49ab53d31a05c7b399d8130",
+  "generatorVersion": "0.6.11",
   "modules": [
     {
       "name": "system",
@@ -33,7 +33,7 @@
     },
     {
       "name": "system.agent",
-      "version": "0.1.0"
+      "version": "0.1.1"
     },
     {
       "name": "system.operations",

package/template/README.md

@@ -35,6 +35,10 @@ Drizzle migration，再启动 Server 与 Web；不要跳过 migration 后直接
 BuildKit 中的 Bun 包下载缓存，只下载新增或发生变化的依赖；冷安装每 15 秒输出一次
 不含 registry 地址或凭据的进度心跳。
 
+Windows 10/11 可在原生 PowerShell 中配合 Docker Desktop 直接运行 `bun run dev` 与
+`bun run dev:build`，不需要 WSL。Windows 是本地开发宿主；生产交付仍使用 Linux
+amd64 容器。
+
 | 服务 | 地址 |
 | ---- | ---- |
 | Web | http://localhost:18746 |

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

@@ -135,6 +135,7 @@ class RuntimeRelease(CanonicalModel):
     workflow_version: str = Field(min_length=1, max_length=80)
     prompt_version: str = Field(min_length=1, max_length=80)
     route_version: str = Field(min_length=1, max_length=80)
+    output_schema_version: str = Field(min_length=1, max_length=80)
     tool_schema_version: str = Field(min_length=1, max_length=80)
     manifest_digest: str = Field(pattern=r"^[a-f0-9]{64}$")
 
@@ -166,6 +167,7 @@ def legacy_release() -> RuntimeRelease:
         workflow_version="legacy",
         prompt_version="legacy",
         route_version="legacy",
+        output_schema_version="legacy",
         tool_schema_version="legacy",
         manifest_digest="0" * 64,
     )

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

@@ -237,12 +237,29 @@ def run_value(run: RunReport, attempts: list[AttemptReport]) -> dict[str, object
         "finishedAt": iso(run.finished_at),
         "durationMs": run.duration_ms,
         "attemptCount": len(attempts),
+        "modelDeployments": model_deployments(attempts),
         "models": models,
         "cacheStatus": cache,
         "usage": usage_value(attempts),
     }
 
 
+def model_deployments(attempts: Iterable[AttemptReport]) -> list[dict[str, object]]:
+    """按首次 Attempt 顺序保留真实的模型/deployment 组合及出现次数。"""
+    groups: dict[tuple[str, str], int] = {}
+    for item in attempts:
+        key = (item.deployment_key, item.reported_model or item.requested_model)
+        groups[key] = groups.get(key, 0) + 1
+    return [
+        {
+            "deploymentKey": deployment_key,
+            "model": model,
+            "attemptCount": attempt_count,
+        }
+        for (deployment_key, model), attempt_count in groups.items()
+    ]
+
+
 def usage_value(attempts: list[AttemptReport]) -> dict[str, int | None]:
     def total(field: str) -> int | None:
         values = [
@@ -267,6 +284,8 @@ def attempt_value(item: AttemptReport) -> dict[str, object]:
         "sequence": item.sequence,
         "toolRound": item.tool_round,
         "deploymentKey": item.deployment_key,
+        "requestedModel": item.requested_model,
+        "reportedModel": item.reported_model,
         "model": item.reported_model or item.requested_model,
         "outcome": item.outcome,
         "cacheStatus": item.usage.cache_status,

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

@@ -49,3 +49,33 @@ def test_typed_image_part_and_json_schema_output() -> None:
     with pytest.raises(SafeEngineError) as invalid:
         final_output('{"name":42}', schema)
     assert invalid.value.code == "OUTPUT_VALIDATION_FAILED"
+
+
+def test_supervisor_final_answer_schema_rejects_intermediate_text() -> None:
+    schema: dict[str, JsonValue] = {
+        "type": "object",
+        "properties": {
+            "finalAnswer": {
+                "type": "object",
+                "properties": {
+                    "schemaVersion": {"const": 1},
+                    "text": {"type": "string", "minLength": 1},
+                },
+                "required": ["schemaVersion", "text"],
+                "additionalProperties": False,
+            },
+            "nodes": {"type": "array"},
+        },
+        "required": ["finalAnswer"],
+        "additionalProperties": False,
+    }
+    assert final_output(
+        '{"finalAnswer":{"schemaVersion":1,"text":"最终回答"},"nodes":[]}',
+        schema,
+    ) == {
+        "finalAnswer": {"schemaVersion": 1, "text": "最终回答"},
+        "nodes": [],
+    }
+    with pytest.raises(SafeEngineError) as invalid:
+        final_output('{"nodes":[{"text":"中间节点","total":2}]}', schema)
+    assert invalid.value.code == "OUTPUT_VALIDATION_FAILED"

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

@@ -96,6 +96,7 @@ def fixture(suffix: str) -> RunRecord:
             "workflowVersion": "workflow-1",
             "promptVersion": "prompt-1",
             "routeVersion": "route-1",
+            "outputSchemaVersion": "output-schema-1",
             "toolSchemaVersion": "schema-1",
             "manifestDigest": "0" * 64,
         },

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

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import httpx
+import pytest
+from fastapi import FastAPI
+
+from southwind_agent_server.contracts import RunReportingContext, StartRunRequest
+from southwind_agent_server.report_routes import create_report_router
+from southwind_agent_server.report_store import InMemoryAgentRuntimeReportStore
+from southwind_agent_server.report_types import UsageFacts
+
+
+async def test_internal_run_routes_project_model_deployments_and_facts(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr("southwind_agent_server.report_routes.time.time", lambda: 400.0)
+    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
+    await store.ensure_run(
+        "run_1",
+        StartRunRequest(
+            operation_key="business.answer",
+            input=None,
+            reporting=RunReportingContext(
+                actor_id="actor_1", actor_type="user", department_id=None
+            ),
+        ),
+        100.0,
+    )
+    attempt = await store.start_attempt(
+        "run_1", 1, "ai.primary", "requested-model", 101.0
+    )
+    await store.finish_attempt(
+        attempt.attempt_id,
+        "completed",
+        UsageFacts(total_tokens=12),
+        102.0,
+        "provider-model-v2",
+    )
+    application = FastAPI()
+    application.include_router(create_report_router(store, "internal-token"))
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=application), base_url="http://test"
+    ) as client:
+        headers = {"Authorization": "Bearer internal-token"}
+        listed = await client.get(
+            "/api/internal/ai-runtime-report/runs?range=retained&scopeMode=all",
+            headers=headers,
+        )
+        detail = await client.get(
+            "/api/internal/ai-runtime-report/runs/run_1", headers=headers
+        )
+
+    assert listed.status_code == 200
+    assert listed.json()["items"][0]["modelDeployments"] == [
+        {
+            "deploymentKey": "ai.primary",
+            "model": "provider-model-v2",
+            "attemptCount": 1,
+        }
+    ]
+    assert detail.status_code == 200
+    assert detail.json()["attempts"] == [
+        {
+            "attemptId": attempt.attempt_id,
+            "sequence": 1,
+            "toolRound": 1,
+            "deploymentKey": "ai.primary",
+            "requestedModel": "requested-model",
+            "reportedModel": "provider-model-v2",
+            "model": "provider-model-v2",
+            "outcome": "completed",
+            "cacheStatus": "unknown",
+            "usageSource": "unknown",
+            "inputTokens": None,
+            "outputTokens": None,
+            "cachedInputTokens": None,
+            "reasoningTokens": None,
+            "totalTokens": 12,
+            "firstTokenLatencyMs": None,
+            "durationMs": 1000,
+            "safeErrorCode": None,
+            "startedAt": "1970-01-01T00:01:41Z",
+            "finishedAt": "1970-01-01T00:01:42Z",
+        }
+    ]

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

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Literal
+from typing import Any, Literal, cast
 
 import pytest
 
@@ -284,3 +284,64 @@ async def test_completely_unknown_aggregate_tokens_stay_null() -> None:
     }
     assert summary["byModel"][0]["totalTokens"] is None  # type: ignore[index]
     assert summary["activity"][0]["totalTokens"] is None  # type: ignore[index]
+
+
+async def test_run_projection_keeps_model_deployment_combinations_and_facts() -> None:
+    store = InMemoryAgentRuntimeReportStore(now=lambda: 400.0)
+    await store.ensure_run("run_empty", request("actor_1"), 90.0)
+    await store.ensure_run("run_1", request("actor_1"), 100.0)
+
+    first = await store.start_attempt(
+        "run_1", 1, "ai.primary", "requested-primary", 101.0
+    )
+    await store.start_attempt("run_1", 2, "ai.fallback", "requested-fallback", 102.0)
+    third = await store.start_attempt(
+        "run_1", 3, "ai.primary", "requested-primary", 103.0
+    )
+    await store.finish_attempt(
+        first.attempt_id,
+        "completed",
+        UsageFacts(),
+        104.0,
+        "provider-primary-v2",
+    )
+    await store.finish_attempt(third.attempt_id, "failed", UsageFacts(), 105.0)
+
+    page = await store.list_runs(ReportFilter(0, 500), 1, 20)
+    items = cast(list[dict[str, Any]], page["items"])
+    item = items[0]
+    assert item["modelDeployments"] == [
+        {
+            "deploymentKey": "ai.primary",
+            "model": "provider-primary-v2",
+            "attemptCount": 1,
+        },
+        {
+            "deploymentKey": "ai.fallback",
+            "model": "requested-fallback",
+            "attemptCount": 1,
+        },
+        {
+            "deploymentKey": "ai.primary",
+            "model": "requested-primary",
+            "attemptCount": 1,
+        },
+    ]
+    assert items[1]["modelDeployments"] == []
+
+    detail = await store.get_run("run_1")
+    assert detail is not None
+    attempts = cast(list[dict[str, Any]], detail["attempts"])
+    assert [
+        (
+            attempt["sequence"],
+            attempt["deploymentKey"],
+            attempt["requestedModel"],
+            attempt["reportedModel"],
+        )
+        for attempt in attempts
+    ] == [
+        (1, "ai.primary", "requested-primary", "provider-primary-v2"),
+        (2, "ai.fallback", "requested-fallback", None),
+        (3, "ai.primary", "requested-primary", None),
+    ]

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

@@ -174,6 +174,7 @@ def fixture(run_id: str, idempotency_key: str) -> RunRecord:
             "workflowVersion": "workflow-1",
             "promptVersion": "prompt-1",
             "routeVersion": "route-1",
+            "outputSchemaVersion": "output-schema-1",
             "toolSchemaVersion": "schema-1",
             "manifestDigest": "0" * 64,
         },

package/template/apps/server/src/agent/remote-runtime.test.ts

@@ -210,6 +210,7 @@ function runtimeRelease(): AgentRuntimeOperation["release"] {
     workflowVersion: "workflow-1",
     promptVersion: "prompt-1",
     routeVersion: "route-1",
+    outputSchemaVersion: "output-schema-1",
     toolSchemaVersion: "schema-1",
     manifestDigest: "0".repeat(64),
   };

package/template/apps/server/src/agent/run-audit.ts

@@ -41,6 +41,7 @@ export function auditAgentRun(input: {
       workflowVersion: input.release.workflowVersion,
       promptVersion: input.release.promptVersion,
       routeVersion: input.release.routeVersion,
+      outputSchemaVersion: input.release.outputSchemaVersion,
       toolSchemaVersion: input.release.toolSchemaVersion,
       traceId: input.traceId,
     },

package/template/apps/server/src/agent/run-contracts.ts

@@ -56,6 +56,7 @@ export interface AgentRuntimeRelease {
   readonly workflowVersion: string;
   readonly promptVersion: string;
   readonly routeVersion: string;
+  readonly outputSchemaVersion: string;
   readonly toolSchemaVersion: string;
   readonly manifestDigest: string;
 }

package/template/apps/server/src/agent/run-facade.ts

@@ -30,7 +30,6 @@ import {
 } from "./provider-input-governance.js";
 import {
   rotateVisionArtifacts,
-  validateOutputSchema,
   validateVisionArtifacts,
 } from "./vision-input.js";
 import { requireVisionOperationReadiness } from "./vision-readiness.js";
@@ -55,6 +54,7 @@ import {
   buildRegisteredOperations,
   type RegisteredOperation,
 } from "./run-operation-registry.js";
+import { validateRegisteredOutputSchema } from "./run-output-schema.js";
 export { AgentRunFacadeError } from "./run-errors.js";
 
 type ServerRuntime = ReturnType<typeof createServerRuntime>;
@@ -157,7 +157,7 @@ export class AgentRunFacade {
         400,
       );
     }
-    validateOutputSchema(plan.outputSchema, operation.definition);
+    validateRegisteredOutputSchema(plan.outputSchema, operation);
     const rotatedArtifacts = await rotateVisionArtifacts(
       artifacts,
       operation.definition,

package/template/apps/server/src/agent/run-operation-registry.ts

@@ -13,6 +13,7 @@ export interface RegisteredOperation {
   feature: ReturnType<typeof findFeature>;
   tools: AgentRuntimeOperation["allowedTools"];
   release: AgentRuntimeOperation["release"];
+  outputSchema?: NonNullable<ModuleManifest["jsonSchemas"]>[number]["schema"];
 }
 
 export function buildRegisteredOperations(
@@ -26,6 +27,11 @@ export function buildRegisteredOperations(
     ]),
   );
   const features = modules.flatMap(({ features }) => features);
+  const schemas = new Map(
+    modules.flatMap(({ jsonSchemas }) =>
+      (jsonSchemas ?? []).map((schema) => [schema.key, schema.schema] as const),
+    ),
+  );
   return new Map(
     modules.flatMap((module) =>
       (module.aiOperations ?? []).map((definition) => {
@@ -37,6 +43,7 @@ export function buildRegisteredOperations(
             ...handler,
             feature: findFeature(features, definition.featureKey),
             tools: toolDefinitions(modules, definition.allowedToolKeys),
+            outputSchema: schemas.get(definition.outputSchemaKey),
             release: buildAgentRuntimeRelease(
               modules,
               module,

package/template/apps/server/src/agent/run-output-schema.ts

@@ -0,0 +1,15 @@
+import type { ModuleAiJsonValue } from "@southwind-ai/server-sdk";
+import type { RegisteredOperation } from "./run-operation-registry.js";
+import { validateOutputSchema } from "./vision-input.js";
+
+export function validateRegisteredOutputSchema(
+  schema: ModuleAiJsonValue | undefined,
+  operation: RegisteredOperation,
+): void {
+  validateOutputSchema(
+    schema,
+    operation.definition,
+    operation.registration?.supervisor,
+    operation.outputSchema,
+  );
+}

package/template/apps/server/src/agent/run-release.ts

@@ -20,6 +20,7 @@ export function buildAgentRuntimeRelease(
   const coordinates = {
     operationVersion: module.version,
     ...versions,
+    outputSchemaVersion: outputSchemaDigest(modules, definition),
     toolSchemaVersion: operationSchemaDigest(modules, definition),
     manifestDigest: digest(module),
   };
@@ -29,6 +30,16 @@ export function buildAgentRuntimeRelease(
   };
 }
 
+function outputSchemaDigest(
+  modules: readonly ModuleManifest[],
+  definition: ModuleAiOperationDefinition,
+): string {
+  const schema = modules
+    .flatMap(({ jsonSchemas }) => jsonSchemas ?? [])
+    .find(({ key }) => key === definition.outputSchemaKey)?.schema;
+  return digest(schema);
+}
+
 function operationSchemaDigest(
   modules: readonly ModuleManifest[],
   definition: ModuleAiOperationDefinition,

package/template/apps/server/src/agent/supervisor-output-schema.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import {
+  composeSystemAgentFinalAnswerSchemaV1,
+  type ModuleAiOperationDefinition,
+} from "@southwind-ai/modules";
+import { validateOutputSchema } from "./vision-input.js";
+
+const definition: ModuleAiOperationDefinition = {
+  key: "business.copilot",
+  kind: "agent",
+  featureKey: "business.copilot",
+  permissionKey: "business.copilot.execute",
+  auditAction: "business.copilot.execute",
+  inputSchemaKey: "business.copilot.input.v1",
+  outputSchemaKey: "business.copilot.output.v1",
+  requiredCapabilities: ["text-generation"],
+  allowedToolKeys: [],
+  dataClassification: "internal",
+  execution: "interactive",
+  providerEgress: { mode: "configured-endpoint", deploymentKey: "ai.default" },
+  providerDataPolicy: {
+    inputFields: [
+      {
+        jsonPointer: "/prompt",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+    ],
+    envelopeFields: [
+      {
+        field: "instructions",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+      {
+        field: "user-prompt",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+      {
+        field: "output-schema",
+        classification: "internal",
+        dlpAction: "redact",
+      },
+    ],
+  },
+  toolNetworkPolicy: { mode: "forbidden" },
+  limits: {
+    maxDurationSeconds: 60,
+    maxInputBytes: 4_096,
+    maxOutputBytes: 1_048_576,
+  },
+};
+
+const supervisor = {
+  contractVersion: 1,
+  finalAnswerSchemaVersion: 1,
+} as const;
+
+describe("Supervisor output schema admission", () => {
+  test("只接受与 Manifest 完全一致的 canonical Schema", () => {
+    const schema = composeSystemAgentFinalAnswerSchemaV1({
+      properties: { citations: { type: "array" } },
+    });
+    expect(() =>
+      validateOutputSchema(schema, definition, supervisor, schema),
+    ).not.toThrow();
+    expect(() =>
+      validateOutputSchema(
+        composeSystemAgentFinalAnswerSchemaV1(),
+        definition,
+        supervisor,
+        schema,
+      ),
+    ).toThrow("与 Manifest 声明不一致");
+  });
+
+  test("拒绝缺失 Schema 或 legacy text Schema", () => {
+    expect(() =>
+      validateOutputSchema(undefined, definition, supervisor),
+    ).toThrow("必须提供 typed 输出 Schema");
+    expect(() =>
+      validateOutputSchema(
+        {
+          type: "object",
+          properties: { text: { type: "string" } },
+          required: ["text"],
+          additionalProperties: false,
+        },
+        definition,
+        supervisor,
+      ),
+    ).toThrow("canonical finalAnswer V1");
+  });
+});

package/template/apps/server/src/agent/vision-input.ts

@@ -1,6 +1,10 @@
-import type { ModuleAiOperationDefinition } from "@southwind-ai/modules";
+import {
+  assertSystemAgentFinalAnswerSchemaV1,
+  type ModuleAiOperationDefinition,
+} from "@southwind-ai/modules";
 import type {
   ModuleAiArtifactRef,
+  ModuleAiOperationHandlerRegistration,
   ModuleAiJsonValue,
 } from "@southwind-ai/server-sdk";
 import type { AiArtifactRuntime } from "../ai-artifact/runtime.js";
@@ -56,8 +60,13 @@ export async function rotateVisionArtifacts(
 export function validateOutputSchema(
   schema: ModuleAiJsonValue | undefined,
   definition: ModuleAiOperationDefinition,
+  supervisor?: ModuleAiOperationHandlerRegistration["supervisor"],
+  declaredSchema?: ModuleAiJsonValue,
 ) {
-  if (schema === undefined) return;
+  if (schema === undefined) {
+    if (supervisor) throw invalid("Supervisor 必须提供 typed 输出 Schema");
+    return;
+  }
   if (
     !schema ||
     typeof schema !== "object" ||
@@ -70,6 +79,16 @@ export function validateOutputSchema(
       400,
     );
   }
+  if (supervisor) {
+    try {
+      assertSystemAgentFinalAnswerSchemaV1(schema);
+    } catch {
+      throw invalid("Supervisor 输出 Schema 缺少 canonical finalAnswer V1");
+    }
+    if (canonicalJson(schema) !== canonicalJson(declaredSchema)) {
+      throw invalid("Supervisor 运行时输出 Schema 与 Manifest 声明不一致");
+    }
+  }
   if (
     definition.providerEgress?.mode === "configured-endpoint" &&
     !definition.providerDataPolicy?.envelopeFields.some(
@@ -84,6 +103,22 @@ export function validateOutputSchema(
   }
 }
 
+function canonicalJson(value: unknown): string {
+  return JSON.stringify(canonicalValue(value));
+}
+
+function canonicalValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonicalValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, canonicalValue(item)]),
+    );
+  }
+  return value;
+}
+
 export function validateVisionArtifacts(
   artifacts: readonly Pick<
     ModuleAiArtifactRef,

package/template/apps/server/src/ai-runtime-report/remote-parser.ts

@@ -111,6 +111,14 @@ function parseReportRun(value: unknown): InternalAiRuntimeRunListItem {
     finishedAt: nullableText(item.finishedAt),
     durationMs: nullableInteger(item.durationMs),
     attemptCount: integer(item.attemptCount),
+    modelDeployments: array(item.modelDeployments).map((modelDeployment) => {
+      const combination = record(modelDeployment);
+      return {
+        deploymentKey: text(combination.deploymentKey),
+        model: text(combination.model),
+        attemptCount: integer(combination.attemptCount),
+      };
+    }),
     models: array(item.models).map(text),
     cacheStatus: oneOf(item.cacheStatus, ["hit", "miss", "unknown"]),
     usage: parseUsage(item.usage),
@@ -124,6 +132,8 @@ function parseAttempt(value: unknown): AiRuntimeAttemptDetail {
     sequence: integer(item.sequence),
     toolRound: integer(item.toolRound),
     deploymentKey: text(item.deploymentKey),
+    requestedModel: text(item.requestedModel),
+    reportedModel: nullableText(item.reportedModel),
     model: text(item.model),
     outcome: oneOf(item.outcome, [
       "running",

package/template/apps/server/src/ai-runtime-report/service.test.ts

@@ -254,6 +254,7 @@ function runDetail(departmentId: string): InternalAiRuntimeRunDetail {
     finishedAt: "2026-07-31T00:00:01.000Z",
     durationMs: 1_000,
     attemptCount: 0,
+    modelDeployments: [],
     models: [],
     cacheStatus: "unknown",
     usage: {