create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/runtime/audit.nodecheck.ts

@@ -0,0 +1,60 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { RuntimeStore } from "./store.js";
+import { configFromEnvironment } from "./config.js";
+
+test("provider audits retain configured 190 days independently of Run retention and record TTL purges", () => {
+  assert.equal(configFromEnvironment({}).providerAuditRetentionDays, 190);
+  assert.throws(
+    () => configFromEnvironment({ AI_PROVIDER_AUDIT_RETENTION_DAYS: "0" }),
+    /RETENTION/,
+  );
+  assert.throws(
+    () => configFromEnvironment({ AI_PROVIDER_AUDIT_RETENTION_DAYS: "3651" }),
+    /RETENTION/,
+  );
+  const directory = mkdtempSync(join(tmpdir(), "dsh-audit-retention-")),
+    path = join(directory, "runtime.sqlite");
+  let store = new RuntimeStore(path);
+  try {
+    const insert = store.db.prepare(
+      "INSERT INTO provider_audit(id,value,created_at) VALUES(?,?,?)",
+    );
+    insert.run(
+      1,
+      '{"decision":"redact"}',
+      new Date(Date.now() - 91 * 86400000).toISOString(),
+    );
+    insert.run(
+      2,
+      '{"decision":"reject"}',
+      new Date(Date.now() - 191 * 86400000).toISOString(),
+    );
+    // Sparse identifiers also guard against deleting young rows by record count.
+    insert.run(100005, '{"decision":"allow"}', new Date().toISOString());
+    store.close();
+    store = new RuntimeStore(path, 190);
+    const health = store.auditHealth();
+    assert.equal(health.status, "healthy");
+    assert.equal(health.retentionDays, 190);
+    assert.equal(health.retainedRecords, 2);
+    assert.equal(health.redactedAttempts, 1);
+    assert.equal(health.rejectedAttempts, 0);
+    assert.equal(health.lastDeletedRecords, 1);
+    assert.equal(health.totalDeletedRecords, 1);
+    assert.ok(health.lastPurgeAt && health.lastPurgeAt > Date.now() / 1000 - 5);
+    store.audit({ decision: "allow" });
+    assert.equal(store.auditHealth().retainedRecords, 3);
+    assert.equal(store.auditHealth().totalDeletedRecords, 1);
+    store.close();
+    store = new RuntimeStore(path, 90);
+    assert.equal(store.auditHealth().retainedRecords, 2);
+    assert.equal(store.auditHealth().totalDeletedRecords, 2);
+  } finally {
+    store.close();
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,61 @@
+import { AdmissionQueue } from "../native/admission.js";
+import { SafeError } from "./contracts.js";
+/** Shared across canonical DSH, native DSH and the Client Agent model relay. */
+export class ModelCapacity {
+  private active = 0;
+  private readonly nativeQueue: AdmissionQueue;
+  constructor(readonly maximum: number) {
+    this.nativeQueue = new AdmissionQueue(
+      Math.max(0, maximum - 1),
+      32,
+      90000,
+      () => this.active < this.maximum - 1,
+      () => {
+        this.active++;
+        return () => {
+          this.active--;
+        };
+      },
+    );
+  }
+  /** Native parents/children share a cancellable queue and leave a canonical slot. */
+  async acquireNative(signal: AbortSignal): Promise<() => void> {
+    try {
+      return await this.nativeQueue.acquire(signal);
+    } catch (error) {
+      if (signal.aborted) throw signal.reason;
+      if (error instanceof Error && error.message.startsWith("NATIVE_"))
+        throw new SafeError(
+          "RATE_LIMITED",
+          "工作台模型容量不足或等待超时",
+          true,
+          429,
+        );
+      throw error;
+    }
+  }
+  acquire(): () => void {
+    if (this.active >= this.maximum)
+      throw new SafeError(
+        "RATE_LIMITED",
+        "共享模型容量已满，请稍后重试",
+        true,
+        429,
+      );
+    this.active++;
+    let released = false;
+    return () => {
+      if (!released) {
+        released = true;
+        this.active--;
+        this.nativeQueue.drain();
+      }
+    };
+  }
+  snapshot() {
+    return {
+      activeModelCalls: this.active,
+      maxConcurrentModelCalls: this.maximum,
+    };
+  }
+}

package/template/apps/agent-server/runtime/client-completion-budget.nodecheck.ts

@@ -0,0 +1,92 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import type { AddressInfo } from "node:net";
+import { clientCompletion } from "./completions.js";
+import { configFromEnvironment } from "./config.js";
+import { ModelCapacity } from "./capacity.js";
+import type { RuntimeStore } from "./store.js";
+
+async function completion(transportLimit: number) {
+  const provider = createServer(async (request, response) => {
+    for await (const _part of request) {
+      /* Drain synthetic request. */
+    }
+    response.setHeader("content-type", "text/event-stream");
+    for (let index = 0; index < 160; index++) {
+      response.write(
+        `data: ${JSON.stringify({
+          id: "chatcmpl-synthetic",
+          object: "chat.completion.chunk",
+          model: "synthetic-model",
+          choices: [
+            {
+              index: 0,
+              delta: { content: "字" },
+              finish_reason: index === 159 ? "stop" : null,
+            },
+          ],
+        })}\n\n`,
+      );
+    }
+    response.end("data: [DONE]\n\n");
+  });
+  await new Promise<void>((resolve) =>
+    provider.listen(0, "127.0.0.1", resolve),
+  );
+  const endpoint = `http://127.0.0.1:${(provider.address() as AddressInfo).port}/v1`;
+  const config = configFromEnvironment({
+    AGENT_SERVER_INTERNAL_TOKEN: "test-internal-auth-token-32-bytes",
+    QWEN_API_URL: endpoint,
+    QWEN_MODEL: "synthetic-model",
+    AI_PROVIDER_MAX_RESPONSE_BYTES: String(transportLimit),
+  });
+  try {
+    const response = await clientCompletion(
+      new Request("http://runtime/completion", {
+        method: "POST",
+        body: JSON.stringify({
+          clientRunId: "synthetic-run",
+          operationKey: "test.page",
+          deploymentKey: config.deploymentKey,
+          modelAlias: "windy-default",
+          attempt: 1,
+          messages: [{ role: "user", content: "Synthetic test" }],
+          providerDataPolicy: {
+            inputFields: [],
+            envelopeFields: [
+              {
+                field: "user-prompt",
+                classification: "internal",
+                dlpAction: "redact",
+              },
+            ],
+          },
+          maxResponseBytes: 1024,
+        }),
+      }),
+      config,
+      { audit() {} } as unknown as RuntimeStore,
+      new ModelCapacity(1),
+    );
+    return await response.text();
+  } finally {
+    await new Promise<void>((resolve, reject) =>
+      provider.close((error) => (error ? reject(error) : resolve())),
+    );
+  }
+}
+
+test("Client Agent SSE envelopes use the independent transport budget", async () => {
+  const output = await completion(65536);
+  assert.match(output, /data: \[DONE\]/);
+  assert.doesNotMatch(output, /windy.error/);
+  assert.equal((output.match(/"content":"字"/g) ?? []).length, 160);
+});
+
+test("Client Agent transport remains bounded independently of output", async () => {
+  const output = await completion(4096);
+  assert.match(output, /windy.error/);
+  assert.match(output, /BUDGET_EXCEEDED/);
+  assert.doesNotMatch(output, /data: \[DONE\]/);
+});

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

@@ -0,0 +1,39 @@
+import { createRequire } from "node:module";
+import { digest } from "./contracts.js";
+
+const require = createRequire(import.meta.url);
+const { version } = require("@deepseek-ai/dsh/package.json") as {
+  version: string;
+};
+export const ENGINE_ID = `windy.dsh.${version}`;
+export function compatibilityOffer() {
+  const protocolVersions = [1];
+  const protocolFeatures = [
+    "canonical-sse-replay.v1",
+    "execution-grant-forwarding.v1",
+    "operation-release-attestation.v1",
+    "run-cancel.v1",
+    "run-lifecycle.v1",
+    "runtime-reporting.v1",
+    "tool-callback.v1",
+  ];
+  const toolCallback = {
+    contractVersion: 1,
+    authentication: "windy-internal-bearer-v1",
+  };
+  const body = {
+    schemaVersion: 1,
+    runtimeKind: "agent",
+    engineId: ENGINE_ID,
+    protocolVersions,
+    protocolFeatures,
+    toolCallback,
+    releaseDigest: digest({
+      runtimeKind: "agent",
+      engineId: ENGINE_ID,
+      protocolVersions,
+    }),
+    capabilitiesDigest: digest({ protocolFeatures, toolCallback }),
+  };
+  return { ...body, offerDigest: digest(body) };
+}

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

@@ -0,0 +1,320 @@
+import { z } from "zod";
+import {
+  policySchema,
+  readJson,
+  SafeError,
+  digest,
+  errorValue,
+  type ProviderPolicy,
+} from "./contracts.js";
+import type { RuntimeConfig } from "./config.js";
+import { requireModel } from "./config.js";
+import type { RuntimeStore } from "./store.js";
+import type { ModelCapacity } from "./capacity.js";
+import { admitProviderContext } from "./context-budget.js";
+import { governProvider, sseJson } from "./governance.js";
+const message = z
+  .object({
+    role: z.enum(["system", "user", "assistant", "tool"]),
+    content: z.string().nullable().optional(),
+  })
+  .passthrough();
+const nativeMessage = z
+  .object({
+    role: z.enum(["system", "developer", "user", "assistant", "tool"]),
+    content: z
+      .union([
+        z.string(),
+        z.array(
+          z.union([
+            z.object({ type: z.literal("text"), text: z.string() }),
+            z.object({
+              type: z.literal("image_url"),
+              image_url: z.object({
+                url: z
+                  .string()
+                  .regex(
+                    /^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/,
+                  ),
+                detail: z.enum(["auto", "low", "high"]).optional(),
+              }),
+            }),
+          ]),
+        ),
+      ])
+      .nullable()
+      .optional(),
+  })
+  .passthrough();
+const tool = z.object({
+  type: z.literal("function"),
+  function: z
+    .object({
+      name: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
+      parameters: z.record(z.string(), z.unknown()),
+    })
+    .passthrough(),
+});
+const completionSchema = z
+  .object({
+    clientRunId: z.string().min(1).max(80),
+    operationKey: z.string().min(1).max(200),
+    deploymentKey: z.string().min(1),
+    modelAlias: z.string().regex(/^[A-Za-z0-9._-]{1,80}$/),
+    attempt: z.number().int().min(1).max(128),
+    messages: z.array(message).min(1).max(128),
+    tools: z.array(tool).max(64).default([]),
+    toolChoice: z
+      .union([
+        z.literal("auto"),
+        z.literal("none"),
+        z.object({
+          type: z.literal("function"),
+          function: z.object({ name: z.string() }),
+        }),
+      ])
+      .nullish(),
+    parallelToolCalls: z.literal(false).default(false),
+    providerDataPolicy: policySchema,
+    maxResponseBytes: z.number().int().min(1024).max(16777216),
+  })
+  .strict();
+export interface CompletionAuthority {
+  actorId: string;
+  signal: AbortSignal;
+}
+const nativePolicy: ProviderPolicy = {
+  inputFields: [],
+  envelopeFields: [
+    "instructions",
+    "user-prompt",
+    "provider-output",
+    "tool-results",
+    "tool-definitions",
+    "artifact-content",
+  ].map((field) => ({
+    field,
+    classification: "sensitive",
+    dlpAction: "redact",
+  })),
+};
+export function completionDigest(config: RuntimeConfig) {
+  return digest({
+    deploymentKey: config.deploymentKey,
+    model: config.model,
+    endpointDigest: digest(config.baseUrl),
+    generationParameters: config.generation,
+  });
+}
+export async function clientCompletion(
+  request: Request,
+  config: RuntimeConfig,
+  store: RuntimeStore,
+  capacity: ModelCapacity,
+): Promise<Response> {
+  const body = completionSchema.parse(await readJson(request));
+  if (body.deploymentKey !== config.deploymentKey)
+    throw new SafeError(
+      "MODEL_ROUTE_UNAVAILABLE",
+      "Client Agent Deployment 不可用",
+    );
+  const names = body.tools.map((item) => item.function.name);
+  if (
+    new Set(names).size !== names.length ||
+    (typeof body.toolChoice === "object" &&
+      body.toolChoice &&
+      !names.includes(body.toolChoice.function.name))
+  )
+    throw new SafeError("INVALID_INPUT", "工具定义无效", false, 400);
+  return streamCompletion(config, store, capacity, {
+    messages: body.messages,
+    tools: body.tools,
+    toolChoice: body.toolChoice,
+    modelAlias: body.modelAlias,
+    maxResponseBytes: body.maxResponseBytes,
+    policy: body.providerDataPolicy,
+    metadata: {
+      runId: body.clientRunId,
+      operationKey: body.operationKey,
+      attempt: body.attempt,
+    },
+    signal: request.signal,
+    native: false,
+  });
+}
+export async function nativeCompletion(
+  request: Request,
+  authority: CompletionAuthority,
+  config: RuntimeConfig,
+  store: RuntimeStore,
+  capacity: ModelCapacity,
+): Promise<Response> {
+  if (!authority.actorId || authority.signal.aborted)
+    throw new SafeError("FORBIDDEN", "工作台身份无效", false, 403);
+  const body = z
+    .object({
+      model: z.string().optional(),
+      messages: z.array(nativeMessage).min(1).max(512),
+      // The native workbench aggregates actor-authorized MCP tools and DSH's
+      // local tools; it is not a canonical run's bounded allowedTools list.
+      tools: z.array(tool).max(128).default([]),
+      tool_choice: z.unknown().optional(),
+      max_tokens: z.number().int().positive().optional(),
+      stream: z.literal(true),
+    })
+    .passthrough()
+    .parse(await readJson(request, 8388608));
+  return streamCompletion(config, store, capacity, {
+    messages: body.messages,
+    tools: body.tools,
+    toolChoice: body.tool_choice,
+    maxTokens: body.max_tokens,
+    modelAlias: config.model,
+    maxResponseBytes: config.maxResponseBytes,
+    policy: nativePolicy,
+    metadata: {
+      actorId: authority.actorId,
+      operationKey: "dsh.native-workbench",
+      attempt: 1,
+    },
+    signal: AbortSignal.any([request.signal, authority.signal]),
+    native: true,
+  });
+}
+interface PreparedCompletion {
+  messages: Record<string, unknown>[];
+  tools: Record<string, unknown>[];
+  toolChoice: unknown;
+  modelAlias: string;
+  maxResponseBytes: number;
+  maxTokens?: number;
+  policy: ProviderPolicy;
+  metadata: Record<string, unknown>;
+  signal: AbortSignal;
+  native: boolean;
+}
+async function streamCompletion(
+  config: RuntimeConfig,
+  store: RuntimeStore,
+  capacity: ModelCapacity,
+  input: PreparedCompletion,
+) {
+  requireModel(config);
+  const governed = governProvider(
+    input.messages,
+    input.tools,
+    undefined,
+    input.policy,
+    store,
+    { ...input.metadata, deploymentKey: config.deploymentKey },
+  );
+  const maxTokens = Math.min(input.maxTokens ?? 2048, config.maxOutputTokens);
+  const payload: Record<string, unknown> = {
+    model: config.model,
+    messages: governed.messages,
+    ...(governed.tools.length ? { tools: governed.tools } : {}),
+    ...(input.toolChoice != null ? { tool_choice: input.toolChoice } : {}),
+    stream: true,
+    stream_options: { include_usage: true },
+    parallel_tool_calls: input.native,
+    max_tokens: maxTokens,
+    ...config.generation,
+  };
+  const release = input.native
+      ? await capacity.acquireNative(input.signal)
+      : capacity.acquire(),
+    controller = new AbortController();
+  const signal = AbortSignal.any([
+    input.signal,
+    controller.signal,
+    AbortSignal.timeout(
+      Math.min(config.requestTimeoutMs, config.maxDurationSeconds * 1000),
+    ),
+  ]);
+  let response: Response;
+  try {
+    await admitProviderContext(config, payload, signal);
+    response = await fetch(`${config.baseUrl}/chat/completions`, {
+      method: "POST",
+      signal,
+      redirect: "error",
+      headers: {
+        "content-type": "application/json",
+        ...(config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {}),
+      },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new SafeError(
+        response.status === 429 ? "RATE_LIMITED" : "PROVIDER_UNAVAILABLE",
+        "模型服务请求失败",
+        response.status === 429 || response.status >= 500,
+        503,
+      );
+    }
+  } catch (error) {
+    release();
+    throw error;
+  }
+  const encoder = new TextEncoder();
+  let cancelled = false;
+  const stream = new ReadableStream<Uint8Array>({
+    async start(sink) {
+      const event = (name: string | undefined, value: unknown) => {
+        if (!cancelled)
+          sink.enqueue(
+            encoder.encode(
+              `${name ? `event: ${name}\n` : ""}data: ${JSON.stringify(value)}\n\n`,
+            ),
+          );
+      };
+      try {
+        if (!input.native)
+          event("windy.meta", { deploymentDigest: completionDigest(config) });
+        let finished = false;
+        for await (const chunk of sseJson(
+          response,
+          // Client sessions enforce their output limit on the assembled response.
+          // SSE framing and repeated envelopes retain a separate transport bound.
+          config.maxResponseBytes,
+          signal,
+        )) {
+          if (
+            Array.isArray(chunk.choices) &&
+            chunk.choices.some(
+              (choice) => typeof choice?.finish_reason === "string",
+            )
+          )
+            finished = true;
+          chunk.model = input.modelAlias;
+          event(undefined, chunk);
+        }
+        if (!finished)
+          throw new SafeError("STREAM_INTERRUPTED", "模型响应意外中断", true);
+        if (!cancelled) sink.enqueue(encoder.encode("data: [DONE]\n\n"));
+      } catch (error) {
+        if (!cancelled)
+          event(input.native ? "error" : "windy.error", {
+            ...errorValue(error),
+            failureKind: "upstream-transport",
+          });
+      } finally {
+        release();
+        if (!cancelled) sink.close();
+      }
+    },
+    cancel() {
+      cancelled = true;
+      controller.abort();
+      release();
+    },
+  });
+  return new Response(stream, {
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-store, no-transform",
+      "x-accel-buffering": "no",
+    },
+  });
+}