create-windy 0.8.3 → 0.9.1

package/template/apps/agent-server/runtime/store-idempotency.nodecheck.ts

@@ -0,0 +1,74 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { RuntimeStore } from "./store.js";
+import { digest, runSchema } from "./contracts.js";
+
+function request(traceId: string) {
+  return runSchema.parse({
+    operationKey: "system.example.extraction",
+    input: { sourceId: "synthetic-source" },
+    userPrompt: "合成测试笔录",
+    providerEgress: { mode: "forbidden" },
+    providerDataPolicy: { inputFields: [], envelopeFields: [] },
+    toolNetworkPolicy: { mode: "forbidden" },
+    executionGrant: "same-actor-scoped-grant",
+    release: { releaseId: "release-1" },
+    traceId,
+  });
+}
+
+test("durable retry with a new request trace reattaches the same run", () => {
+  const store = new RuntimeStore(":memory:");
+  try {
+    const first = store.create(request("attempt-1"), "same-job-unit");
+    const replay = store.create(request("attempt-2"), "same-job-unit");
+    assert.equal(replay.fresh, false);
+    assert.equal(replay.run.id, first.run.id);
+    for (const changed of [
+      { userPrompt: "different input" },
+      { executionGrant: "other-actor-grant" },
+      { release: { releaseId: "release-2" } },
+      {
+        providerDataPolicy: {
+          inputFields: [],
+          envelopeFields: [
+            {
+              field: "user-prompt",
+              classification: "public",
+              dlpAction: "reject" as const,
+            },
+          ],
+        },
+      },
+    ]) {
+      assert.throws(
+        () =>
+          store.create(
+            { ...request("attempt-3"), ...changed },
+            "same-job-unit",
+          ),
+        /幂等键已用于其他请求/,
+      );
+    }
+  } finally {
+    store.db.close();
+  }
+});
+
+test("legacy persisted request digest recovers without deleting the old run", () => {
+  const store = new RuntimeStore(":memory:");
+  try {
+    const body = request("legacy-attempt");
+    const first = store.create(body, "legacy-job");
+    store.db
+      .prepare("UPDATE runs SET digest=? WHERE id=?")
+      .run(digest(body), first.run.id);
+    assert.equal(
+      store.create(request("recovery-attempt"), "legacy-job").run.id,
+      first.run.id,
+    );
+    assert.equal(store.events(first.run.id).length, 1);
+  } finally {
+    store.db.close();
+  }
+});

package/template/apps/agent-server/runtime/store.ts

@@ -0,0 +1,324 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+import {
+  SafeError,
+  type CanonicalEvent,
+  type RunRequest,
+  type RunStatus,
+} from "./contracts.js";
+import {
+  matchesRunRequestDigest,
+  runRequestDigest,
+} from "./run-request-digest.js";
+export interface StoredRun {
+  id: string;
+  status: RunStatus;
+  request: RunRequest;
+  output?: unknown;
+  createdAt: string;
+}
+export class RuntimeStore {
+  readonly db: DatabaseSync;
+  private readonly listeners = new Map<string, Set<() => void>>();
+  private readonly activeAuthority = new Map<string, string>();
+  constructor(
+    path: string,
+    private readonly providerAuditRetentionDays = 190,
+  ) {
+    if (
+      !Number.isSafeInteger(providerAuditRetentionDays) ||
+      providerAuditRetentionDays < 1 ||
+      providerAuditRetentionDays > 3650
+    )
+      throw new Error("AI_PROVIDER_AUDIT_RETENTION_DAYS invalid");
+    if (path !== ":memory:")
+      mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    this.db = new DatabaseSync(path);
+    this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;
+      CREATE TABLE IF NOT EXISTS runs(id TEXT PRIMARY KEY, idempotency TEXT UNIQUE NOT NULL, digest TEXT NOT NULL, status TEXT NOT NULL, request TEXT NOT NULL, output TEXT, created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS events(run_id TEXT NOT NULL, sequence INTEGER NOT NULL, value TEXT NOT NULL, PRIMARY KEY(run_id,sequence));
+      CREATE TABLE IF NOT EXISTS attempts(run_id TEXT NOT NULL, sequence INTEGER NOT NULL, value TEXT NOT NULL, PRIMARY KEY(run_id,sequence));
+      CREATE TABLE IF NOT EXISTS provider_audit(id INTEGER PRIMARY KEY, value TEXT NOT NULL, created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS provider_audit_retention(singleton INTEGER PRIMARY KEY CHECK(singleton=1), last_purge_at REAL, last_deleted INTEGER NOT NULL, total_deleted INTEGER NOT NULL);
+      INSERT OR IGNORE INTO provider_audit_retention VALUES(1,NULL,0,0);`);
+    const cutoff = new Date(Date.now() - 90 * 86400000).toISOString();
+    this.db
+      .prepare(
+        "DELETE FROM events WHERE run_id IN (SELECT id FROM runs WHERE created_at<?)",
+      )
+      .run(cutoff);
+    this.db
+      .prepare(
+        "DELETE FROM attempts WHERE run_id IN (SELECT id FROM runs WHERE created_at<?)",
+      )
+      .run(cutoff);
+    this.db.prepare("DELETE FROM runs WHERE created_at<?").run(cutoff);
+    this.purgeExpiredAudit();
+    const interrupted = this.db
+      .prepare(
+        "SELECT id FROM runs WHERE status IN ('accepted','running','awaiting-approval')",
+      )
+      .all() as { id: string }[];
+    for (const row of interrupted)
+      this.event(
+        row.id,
+        "run.failed",
+        {
+          error: {
+            code: "STREAM_INTERRUPTED",
+            message: "服务重启中断执行，请重新发起",
+            retryable: true,
+            requestId: `request_${randomUUID()}`,
+          },
+        },
+        "failed",
+      );
+  }
+  create(request: RunRequest, key: string): { run: StoredRun; fresh: boolean } {
+    const existing = this.db
+      .prepare("SELECT id,digest,request FROM runs WHERE idempotency=?")
+      .get(key) as { id: string; digest: string; request: string } | undefined;
+    if (existing) {
+      if (!matchesRunRequestDigest(request, existing.digest, existing.request))
+        throw new SafeError("RUN_CONFLICT", "幂等键已用于其他请求");
+      return { run: this.get(existing.id), fresh: false };
+    }
+    const run: StoredRun = {
+      id: `run_${randomUUID().replaceAll("-", "")}`,
+      request,
+      status: "accepted",
+      createdAt: new Date().toISOString(),
+    };
+    const size = this.db
+      .prepare("SELECT COUNT(*) AS count FROM runs")
+      .get() as { count: number };
+    if (size.count >= 10000)
+      throw new SafeError(
+        "BUDGET_EXCEEDED",
+        "Agent Run 留存容量已满",
+        true,
+        429,
+      );
+    this.db
+      .prepare(
+        "INSERT INTO runs(id,idempotency,digest,status,request,created_at) VALUES(?,?,?,?,?,?)",
+      )
+      .run(
+        run.id,
+        key,
+        runRequestDigest(request),
+        run.status,
+        JSON.stringify({ ...request, executionGrant: "" }),
+        run.createdAt,
+      );
+    this.activeAuthority.set(run.id, request.executionGrant);
+    this.event(run.id, "run.accepted");
+    return { run, fresh: true };
+  }
+  get(id: string): StoredRun {
+    const row = this.db.prepare("SELECT * FROM runs WHERE id=?").get(id) as
+      | {
+          id: string;
+          status: RunStatus;
+          request: string;
+          output: string | null;
+          created_at: string;
+        }
+      | undefined;
+    if (!row)
+      throw new SafeError("RUN_CONFLICT", "Agent Run 不存在", false, 404);
+    return {
+      id: row.id,
+      status: row.status,
+      request: {
+        ...JSON.parse(row.request),
+        executionGrant: this.activeAuthority.get(id) ?? "",
+      },
+      output: row.output ? JSON.parse(row.output) : undefined,
+      createdAt: row.created_at,
+    };
+  }
+  events(id: string, after = 0): CanonicalEvent[] {
+    return (
+      this.db
+        .prepare(
+          "SELECT value FROM events WHERE run_id=? AND sequence>? ORDER BY sequence",
+        )
+        .all(id, after) as { value: string }[]
+    ).map((row) => JSON.parse(row.value));
+  }
+  event(
+    id: string,
+    type: string,
+    fields: Record<string, unknown> = {},
+    status?: RunStatus,
+  ) {
+    const row = this.db
+      .prepare(
+        "SELECT COALESCE(MAX(sequence),0)+1 AS seq FROM events WHERE run_id=?",
+      )
+      .get(id) as { seq: number };
+    const value: CanonicalEvent = {
+      type,
+      runId: id,
+      sequence: row.seq,
+      ...fields,
+    };
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db
+        .prepare("INSERT INTO events VALUES(?,?,?)")
+        .run(id, row.seq, JSON.stringify(value));
+      if (status)
+        this.db.prepare("UPDATE runs SET status=? WHERE id=?").run(status, id);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+    if (status && terminal(status)) this.activeAuthority.delete(id);
+    for (const listener of this.listeners.get(id) ?? []) listener();
+    return value;
+  }
+  complete(id: string, output: unknown, attestation: unknown) {
+    this.db
+      .prepare("UPDATE runs SET output=? WHERE id=?")
+      .run(JSON.stringify(output), id);
+    this.event(id, "run.completed", { attestation }, "completed");
+  }
+  audit(value: Record<string, unknown>) {
+    this.purgeExpiredAudit();
+    this.db
+      .prepare("INSERT INTO provider_audit(value,created_at) VALUES(?,?)")
+      .run(JSON.stringify(value), new Date().toISOString());
+  }
+  private purgeExpiredAudit() {
+    const now = Date.now(),
+      cutoff = new Date(
+        now - this.providerAuditRetentionDays * 86400000,
+      ).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = this.db
+        .prepare("DELETE FROM provider_audit WHERE created_at<?")
+        .run(cutoff);
+      this.db
+        .prepare(
+          "UPDATE provider_audit_retention SET last_purge_at=?, last_deleted=?, total_deleted=total_deleted+? WHERE singleton=1",
+        )
+        .run(now / 1000, result.changes, result.changes);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  startAttempt(
+    runId: string,
+    sequence: number,
+    deploymentKey: string,
+    model: string,
+  ) {
+    const value = {
+      attemptId: `${runId}_attempt_${sequence}`,
+      sequence,
+      toolRound: sequence,
+      deploymentKey,
+      requestedModel: model,
+      reportedModel: null,
+      model,
+      outcome: "running",
+      cacheStatus: "unknown",
+      usageSource: "unknown",
+      inputTokens: null,
+      outputTokens: null,
+      cachedInputTokens: null,
+      reasoningTokens: null,
+      totalTokens: null,
+      firstTokenLatencyMs: null,
+      durationMs: null,
+      safeErrorCode: null,
+      startedAt: new Date().toISOString(),
+      finishedAt: null,
+    };
+    this.db
+      .prepare("INSERT INTO attempts VALUES(?,?,?)")
+      .run(runId, sequence, JSON.stringify(value));
+  }
+  finishAttempt(
+    runId: string,
+    sequence: number,
+    fields: Record<string, unknown>,
+  ) {
+    const row = this.db
+      .prepare("SELECT value FROM attempts WHERE run_id=? AND sequence=?")
+      .get(runId, sequence) as { value: string };
+    const value = JSON.parse(row.value) as { startedAt: string };
+    this.db
+      .prepare("UPDATE attempts SET value=? WHERE run_id=? AND sequence=?")
+      .run(
+        JSON.stringify({
+          ...value,
+          ...fields,
+          finishedAt: new Date().toISOString(),
+          durationMs: Math.max(0, Date.now() - Date.parse(value.startedAt)),
+        }),
+        runId,
+        sequence,
+      );
+  }
+  attempts(runId: string): Record<string, unknown>[] {
+    return (
+      this.db
+        .prepare("SELECT value FROM attempts WHERE run_id=? ORDER BY sequence")
+        .all(runId) as { value: string }[]
+    ).map((row) => JSON.parse(row.value));
+  }
+  auditHealth() {
+    const row = this.db
+      .prepare(
+        "SELECT COUNT(*) AS count, MAX(created_at) AS last, COALESCE(SUM(json_extract(value,'$.decision')='reject'),0) AS rejected, COALESCE(SUM(json_extract(value,'$.decision')='redact'),0) AS redacted FROM provider_audit",
+      )
+      .get() as {
+      count: number;
+      last: string | null;
+      rejected: number;
+      redacted: number;
+    };
+    const retention = this.db
+      .prepare("SELECT * FROM provider_audit_retention WHERE singleton=1")
+      .get() as {
+      last_purge_at: number | null;
+      last_deleted: number;
+      total_deleted: number;
+    };
+    return {
+      status: "healthy",
+      retentionDays: this.providerAuditRetentionDays,
+      retainedRecords: row.count,
+      rejectedAttempts: row.rejected,
+      redactedAttempts: row.redacted,
+      lastAttemptAt: row.last,
+      lastPurgeAt: retention.last_purge_at,
+      lastDeletedRecords: retention.last_deleted,
+      totalDeletedRecords: retention.total_deleted,
+    };
+  }
+  subscribe(id: string, listener: () => void) {
+    const set = this.listeners.get(id) ?? new Set();
+    set.add(listener);
+    this.listeners.set(id, set);
+    return () => {
+      set.delete(listener);
+      if (!set.size) this.listeners.delete(id);
+    };
+  }
+  close() {
+    this.activeAuthority.clear();
+    this.db.close();
+  }
+}
+export const terminal = (status: RunStatus) =>
+  ["completed", "failed", "cancelled"].includes(status);

package/template/apps/agent-server/runtime/structured-output-mode.nodecheck.ts

@@ -0,0 +1,51 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { configFromEnvironment } from "./config.js";
+import {
+  runtime,
+  input,
+  request,
+  providerPayloads,
+} from "./runtime-test-fixtures.js";
+
+test("structured output defaults to strict schema and rejects unknown modes", () => {
+  assert.equal(configFromEnvironment({}).structuredOutputMode, "json_schema");
+  assert.throws(
+    () => configFromEnvironment({ QWEN_STRUCTURED_OUTPUT_MODE: "relaxed" }),
+    /QWEN_STRUCTURED_OUTPUT_MODE invalid/,
+  );
+});
+
+for (const invalid of [false, true]) {
+  test(`explicit JSON mode retains full schema and ${invalid ? "rejects invalid" : "accepts valid"} provider output`, async () => {
+    const handler = runtime({ QWEN_STRUCTURED_OUTPUT_MODE: "json_object" });
+    try {
+      const body = input();
+      if (invalid)
+        body.outputSchema = {
+          type: "object",
+          properties: { answer: { type: "integer" } },
+          required: ["answer"],
+          additionalProperties: false,
+        };
+      const start = await handler(request("/api/agent/runs", "POST", body));
+      assert.equal(start?.status, 200);
+      const run = (await start!.json()) as { eventsUrl: string };
+      const response = await handler(request(run.eventsUrl));
+      const events = await response!.text();
+      assert.match(
+        events,
+        invalid ? /OUTPUT_VALIDATION_FAILED/ : /event: run.completed/,
+      );
+      const payload = providerPayloads.at(-1)!;
+      assert.deepEqual(payload.response_format, { type: "json_object" });
+      assert.ok(
+        JSON.stringify(payload.messages).includes(
+          JSON.stringify(body.outputSchema).replaceAll('"', '\\"'),
+        ),
+      );
+    } finally {
+      await handler.close();
+    }
+  });
+}

package/template/apps/agent-server/runtime/tool-name.ts

@@ -0,0 +1,6 @@
+import { createHash } from "node:crypto";
+/** Stable provider-portable name; the original business key stays at Tool Host. */
+export function businessToolName(key: string): string {
+  const label = key.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 35) || "tool";
+  return `business_${label}_${createHash("sha256").update(key).digest("hex").slice(0, 16)}`;
+}

package/template/apps/agent-server/runtime/tool-plugin.ts

@@ -0,0 +1,201 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { JsonValue } from "@deepseek-ai/dsh-util-values";
+import { digest, SafeError, type RunRequest } from "./contracts.js";
+import type { RuntimeConfig } from "./config.js";
+import type { RuntimeStore } from "./store.js";
+import type { ExecutionBudget } from "./model-plugin.js";
+import { businessToolName } from "./tool-name.js";
+export interface ToolSource {
+  toolCallId: string;
+  toolKey: string;
+  toolLabel: string;
+  preview: {
+    contentType: "application/json";
+    content: string;
+    byteSize: number;
+    truncated: boolean;
+  };
+  snapshotDigest: string;
+}
+export function registerBusinessTools(
+  ctx: Context,
+  request: RunRequest,
+  runId: string,
+  config: RuntimeConfig,
+  store: RuntimeStore,
+  budget: ExecutionBudget,
+  sources: ToolSource[],
+) {
+  for (const tool of request.allowedTools)
+    ctx.tools.register({
+      name: businessToolName(tool.key),
+      description: `业务工具 ${tool.key}（实际调用名 ${businessToolName(tool.key)}）。${tool.label}: ${tool.description}`,
+      parameters: tool.inputSchema,
+      output: {
+        schema: {},
+        render: (_args, value) => [
+          { type: "text", text: JSON.stringify(value) },
+        ],
+      },
+      async execute(args, execution) {
+        if (++budget.toolCalls > (request.limits.maxToolCalls ?? 32))
+          throw new SafeError("BUDGET_EXCEEDED", "工具调用次数达到上限");
+        if (
+          !request.executionGrant ||
+          request.toolNetworkPolicy.mode !== "forbidden"
+        )
+          throw new SafeError("TOOL_DENIED", "业务工具未获授权");
+        const host = new URL(request.toolHostUrl || config.toolHostUrl),
+          allowed = new URL(config.toolHostUrl);
+        if (
+          host.origin !== allowed.origin ||
+          host.pathname.replace(/\/$/, "") !==
+            allowed.pathname.replace(/\/$/, "") ||
+          host.username ||
+          host.password ||
+          host.search ||
+          host.hash
+        )
+          throw new SafeError("TOOL_DENIED", "业务 Tool Host 不在授权范围");
+        const callId = `tool_${digest({ runId, toolKey: tool.key, arguments: args }).slice(7, 47)}`;
+        store.event(runId, "tool.requested", {
+          toolCallId: callId,
+          toolKey: tool.key,
+          toolLabel: tool.label,
+        });
+        let approval: string | undefined;
+        const deadline =
+          Date.now() +
+          Math.min(
+            (tool.approvalTimeoutSeconds ?? 300) * 1000,
+            request.limits.maxDurationSeconds * 1000,
+          );
+        for (;;) {
+          execution.signal.throwIfAborted();
+          const response = await fetch(
+            `${host.href.replace(/\/$/, "")}/api/internal/agent/tools/execute`,
+            {
+              method: "POST",
+              signal: execution.signal,
+              redirect: "error",
+              headers: {
+                authorization: `Bearer ${config.internalToken}`,
+                "content-type": "application/json",
+              },
+              body: JSON.stringify({
+                executionGrant: request.executionGrant,
+                runId,
+                toolCallId: callId,
+                toolKey: tool.key,
+                arguments: args,
+              }),
+            },
+          );
+          const bytes = await boundedBody(
+            response,
+            request.limits.maxOutputBytes,
+          );
+          let body: Record<string, unknown>;
+          try {
+            body = JSON.parse(bytes);
+          } catch {
+            throw new SafeError("TOOL_DENIED", "业务 Tool Host 响应无效");
+          }
+          if (
+            response.status === 202 &&
+            body.code === "APPROVAL_REQUIRED" &&
+            typeof body.workItemId === "string"
+          ) {
+            if (!approval) {
+              approval = body.workItemId;
+              store.event(
+                runId,
+                "approval.required",
+                { workItemId: approval, toolCallId: callId },
+                "awaiting-approval",
+              );
+            }
+            if (Date.now() >= deadline)
+              throw new SafeError("RUN_TIMEOUT", "等待审批超时");
+            await abortableDelay(500, execution.signal);
+            continue;
+          }
+          if (approval)
+            store.event(
+              runId,
+              "approval.resolved",
+              {
+                workItemId: approval,
+                toolCallId: callId,
+                outcome: response.ok ? "approved" : "rejected",
+              },
+              "running",
+            );
+          if (!response.ok || !("value" in body))
+            throw new SafeError("TOOL_DENIED", "业务工具执行被拒绝");
+          const encoded = JSON.stringify(body.value),
+            byteSize = Buffer.byteLength(encoded);
+          const preview = {
+            contentType: "application/json" as const,
+            content: byteSize <= 8192 ? encoded : encoded.slice(0, 2048),
+            byteSize,
+            truncated: byteSize > 8192,
+          };
+          const snapshotDigest = digest(body.value);
+          if (sources.length < 12)
+            sources.push({
+              toolCallId: callId,
+              toolKey: tool.key,
+              toolLabel: tool.label,
+              preview,
+              snapshotDigest,
+            });
+          store.event(runId, "tool.completed", {
+            toolCallId: callId,
+            sourcePreview: preview,
+            sourceSnapshotDigest: snapshotDigest,
+          });
+          return body.value as JsonValue;
+        }
+      },
+    });
+}
+export async function boundedBody(
+  response: Response,
+  max: number,
+): Promise<string> {
+  if (!response.body) throw new SafeError("TOOL_DENIED", "上游响应为空");
+  const reader = response.body.getReader(),
+    parts: Uint8Array[] = [];
+  let size = 0;
+  try {
+    for (;;) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      size += chunk.value.length;
+      if (size > max)
+        throw new SafeError("BUDGET_EXCEEDED", "上游响应超过上限");
+      parts.push(chunk.value);
+    }
+  } finally {
+    await reader.cancel();
+  }
+  return Buffer.concat(parts).toString("utf8");
+}
+function abortableDelay(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}