create-windy 0.8.3 → 0.9.1

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

@@ -0,0 +1,81 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { runtime } from "./runtime-test-fixtures.js";
+
+function completion(tools: unknown[]) {
+  return new Request("http://runtime/internal/boundary/v1/chat/completions", {
+    method: "POST",
+    body: JSON.stringify({
+      stream: true,
+      messages: [
+        {
+          role: "system",
+          content: "最终答案必须只包含符合以下 JSON Schema",
+        },
+        { role: "user", content: "Synthetic test only" },
+      ],
+      tools,
+    }),
+  });
+}
+
+const authority = () => ({
+  actorId: "fixture-user",
+  signal: AbortSignal.timeout(5000),
+});
+
+const fixtureTools = (count: number) =>
+  Array.from({ length: count }, (_, index) => ({
+    type: "function",
+    function: {
+      name: `mcp__windy__fixture_${index}`,
+      description: "业务工具 test.count (synthetic)",
+      parameters: { type: "object", properties: {} },
+    },
+  }));
+
+test("native workbench admits the full authorized MCP inventory plus local DSH tools", async () => {
+  const handler = runtime();
+  // Current product MCP exposes 76 query tools; native DSH adds its own tools.
+  try {
+    const response = await handler.handleNativeCompletion(
+      completion(fixtureTools(96)),
+      authority(),
+    );
+    assert.equal(response.status, 200, await response.clone().text());
+    assert.match(await response.text(), /tool_calls/);
+  } finally {
+    await handler.close();
+  }
+});
+
+test("native inventory remains bounded", async () => {
+  const handler = runtime();
+  try {
+    const response = await handler.handleNativeCompletion(
+      completion(fixtureTools(129)),
+      authority(),
+    );
+    assert.equal(response.status, 400);
+    assert.equal((await response.json()).code, "INVALID_INPUT");
+  } finally {
+    await handler.close();
+  }
+});
+
+test("malformed native completion reports invalid input without leaking payloads", async () => {
+  const handler = runtime();
+  try {
+    const response = await handler.handleNativeCompletion(
+      completion([{ type: "function", function: { name: "invalid.name" } }]),
+      authority(),
+    );
+    assert.equal(response.status, 400);
+    const body = await response.json();
+    assert.equal(body.code, "INVALID_INPUT");
+    assert.equal(body.retryable, false);
+    assert.doesNotMatch(JSON.stringify(body), /invalid\.name|Synthetic/);
+  } finally {
+    await handler.close();
+  }
+});

package/template/apps/agent-server/runtime/output-validation.ts

@@ -0,0 +1,66 @@
+import { ENGINE_ID } from "./compatibility.js";
+import Ajv, { type ErrorObject } from "ajv";
+import { SafeError } from "./contracts.js";
+export interface OutputValidationContext {
+  runId: string;
+  operationKey: string;
+  outputSchemaKey: string;
+}
+function safePath(value: string): string {
+  return value
+    .split("/")
+    .slice(0, 16)
+    .map((segment) =>
+      /^(?:#|[A-Za-z_$][A-Za-z0-9_$-]{0,63}|[0-9]{1,5})$/.test(segment) ||
+      !segment
+        ? segment
+        : "[field]",
+    )
+    .join("/")
+    .slice(0, 512);
+}
+export function validateStructuredOutput(
+  raw: string,
+  schema: Record<string, unknown>,
+  context: OutputValidationContext,
+  log: (value: string) => void = console.warn,
+): unknown {
+  const failed = (validationKind: string, error?: ErrorObject): never => {
+    log(
+      JSON.stringify({
+        event: "agent.output.validation.failed",
+        engineId: ENGINE_ID,
+        runId: context.runId,
+        operationKey: context.operationKey.slice(0, 200),
+        outputSchemaKey: context.outputSchemaKey.slice(0, 200),
+        validationKind,
+        ...(error
+          ? {
+              keyword: error.keyword,
+              instancePath: safePath(error.instancePath),
+              schemaPath: safePath(error.schemaPath),
+            }
+          : {}),
+      }),
+    );
+    throw new SafeError("OUTPUT_VALIDATION_FAILED", "模型输出未通过格式校验");
+  };
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return failed("json-syntax");
+  }
+  let validate;
+  try {
+    validate = new Ajv({
+      strict: false,
+      allErrors: false,
+      validateFormats: false,
+    }).compile(schema);
+  } catch {
+    return failed("schema-definition");
+  }
+  if (!validate(value)) return failed("schema-instance", validate.errors?.[0]);
+  return value;
+}

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

@@ -0,0 +1,121 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  runtime,
+  request,
+  input,
+  providerCalls,
+} from "./runtime-test-fixtures.js";
+
+test("single-slot production capacity accepts consecutive completed canonical runs", async () => {
+  const handler = runtime({
+    AI_PROVIDER_MAX_CONCURRENT_RUNS: "1",
+    AI_PROVIDER_MAX_QUEUE_DEPTH: "0",
+  });
+  try {
+    for (let i = 0; i < 10; i++) {
+      const started = await handler(
+        request("/api/agent/runs", "POST", input(), `consecutive-${i}`),
+      );
+      assert.equal(
+        started?.status,
+        200,
+        `run ${i}: ${started?.status === 200 ? "ok" : await started?.text()}`,
+      );
+      const run = (await started!.json()) as { eventsUrl: string };
+      assert.match(
+        await (await handler(request(run.eventsUrl)))!.text(),
+        /event: run.completed/,
+      );
+    }
+  } finally {
+    await handler.close();
+  }
+});
+
+test("failed and cancelled runs release their slot before announcing terminal state", async () => {
+  const handler = runtime({
+    AI_PROVIDER_MAX_CONCURRENT_RUNS: "1",
+    AI_PROVIDER_MAX_QUEUE_DEPTH: "0",
+  });
+  try {
+    for (const kind of ["failed", "cancelled"] as const) {
+      const body = input();
+      if (kind === "failed") body.providerDataPolicy.envelopeFields = [];
+      else body.userPrompt = "hold-model";
+      const started = await handler(
+        request("/api/agent/runs", "POST", body, kind),
+      );
+      assert.equal(started?.status, 200);
+      const run = (await started!.json()) as {
+        runId: string;
+        eventsUrl: string;
+      };
+      if (kind === "cancelled")
+        await handler(
+          request(`/api/agent/runs/${run.runId}/cancel`, "POST", {}),
+        );
+      assert.match(
+        await (await handler(request(run.eventsUrl)))!.text(),
+        new RegExp(`event: run.${kind}`),
+      );
+      const next = await handler(
+        request("/api/agent/runs", "POST", input(), `after-${kind}`),
+      );
+      assert.equal(next?.status, 200);
+      const following = (await next!.json()) as { eventsUrl: string };
+      assert.match(
+        await (await handler(request(following.eventsUrl)))!.text(),
+        /event: run.completed/,
+      );
+    }
+  } finally {
+    await handler.close();
+  }
+});
+
+test("an active run still blocks a second run with no queue and retains one physical model call", async () => {
+  const callsBefore = providerCalls;
+  const handler = runtime({
+    AI_PROVIDER_MAX_CONCURRENT_RUNS: "1",
+    AI_PROVIDER_MAX_QUEUE_DEPTH: "0",
+  });
+  try {
+    const body = input();
+    body.userPrompt = "hold-model";
+    const started = await handler(
+      request("/api/agent/runs", "POST", body, "active"),
+    );
+    const run = (await started!.json()) as { eventsUrl: string };
+    let activeCalls = 0;
+    for (let attempt = 0; attempt < 100 && activeCalls === 0; attempt++) {
+      const health = (await (await handler(
+        request("/health/ready"),
+      ))!.json()) as {
+        activeModelCalls: number;
+      };
+      activeCalls = health.activeModelCalls;
+      if (!activeCalls) await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    assert.equal(activeCalls, 1);
+    const denied = await handler(
+      request("/api/agent/runs", "POST", input(), "while-active"),
+    );
+    assert.equal(denied?.status, 429);
+    assert.equal(
+      ((await denied!.json()) as { code: string }).code,
+      "BUDGET_EXCEEDED",
+    );
+    assert.match(
+      await (await handler(request(run.eventsUrl)))!.text(),
+      /event: run.completed/,
+    );
+    const idle = (await (await handler(request("/health/ready")))!.json()) as {
+      activeModelCalls: number;
+    };
+    assert.equal(idle.activeModelCalls, 0);
+    assert.equal(providerCalls - callsBefore, 1);
+  } finally {
+    await handler.close();
+  }
+});

package/template/apps/agent-server/runtime/questions-workflow.nodecheck.ts

@@ -0,0 +1,249 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import AgentRegistry from "@deepseek-ai/dsh-agent";
+import AgentLoop from "@deepseek-ai/dsh-agent-loop";
+import SessionStore, { SessionId } from "@deepseek-ai/dsh-session";
+import SessionProjections from "@deepseek-ai/dsh-session-projection";
+import LlmRuntime, {
+  LlmAdapter,
+  MessageId,
+  ToolCallId,
+  type GenerateOptions,
+  type StreamChunk,
+} from "@deepseek-ai/dsh-llm";
+import ToolRuntime from "@deepseek-ai/dsh-tools";
+import SystemPrompt from "@deepseek-ai/dsh-system-prompt";
+import UserQuestions from "@deepseek-ai/dsh-user-questions";
+import * as AskUser from "@deepseek-ai/dsh-tool-ask-user";
+import { createQuestionBridge } from "../plugins/questions.mjs";
+import { registerWorkflowTool } from "../plugins/skill-library/workflow.mjs";
+import type { SkillContext } from "../plugins/skill-library/index.mjs";
+
+class ScenarioModel extends LlmAdapter {
+  calls = 0;
+  results: unknown[] = [];
+  constructor(
+    readonly tool: string,
+    readonly args: object,
+  ) {
+    super();
+  }
+  override async *stream(
+    options: GenerateOptions,
+  ): AsyncGenerator<StreamChunk> {
+    options.signal?.throwIfAborted();
+    if (++this.calls === 1) {
+      const call = {
+        type: "tool-call" as const,
+        id: ToolCallId("scenario-call"),
+        name: this.tool,
+        arguments: JSON.stringify(this.args),
+      };
+      yield { type: "block-start", index: 0, blockType: "tool-call" };
+      yield {
+        type: "tool-call-delta",
+        index: 0,
+        id: call.id,
+        name: call.name,
+        argumentsDelta: call.arguments,
+      };
+      yield { type: "block-end", index: 0, block: call };
+      yield { type: "finish", reason: { kind: "tool-calls" } };
+    } else {
+      this.results = options.messages.filter(
+        (message) => message.role === "tool",
+      );
+      yield { type: "block-start", index: 0, blockType: "text" };
+      yield {
+        type: "text-delta",
+        index: 0,
+        text: "已根据用户确认继续完成合成测试。",
+      };
+      yield {
+        type: "block-end",
+        index: 0,
+        block: { type: "text", text: "已根据用户确认继续完成合成测试。" },
+      };
+      yield { type: "finish", reason: { kind: "stop" } };
+    }
+  }
+}
+
+async function scenario(tool: string, args: object, skillRoot?: string) {
+  const ctx = new Context();
+  const fibers: { dispose(): Promise<void> }[] = [];
+  const bridge = createQuestionBridge();
+  let ready!: () => void;
+  const asked = new Promise<void>((done) => {
+    ready = done;
+  });
+  for (const plugin of [
+    LlmRuntime,
+    SessionStore,
+    SessionProjections,
+    AgentRegistry,
+    ToolRuntime,
+    UserQuestions,
+  ])
+    fibers.push(await ctx.plugin(plugin));
+  fibers.push(
+    await ctx.plugin(SystemPrompt, {
+      includeHarnessIdentity: false,
+      includeRuntimeContext: false,
+    }),
+  );
+  fibers.push(
+    await ctx.plugin(AgentLoop, { maxParallelToolCalls: 1, agents: [] }),
+  );
+  fibers.push(await ctx.plugin(AskUser));
+  ctx.on(
+    "user-questions/request",
+    (request, next) => {
+      const waiting = bridge.ask(request, next);
+      ready();
+      return waiting;
+    },
+    { prepend: true },
+  );
+  if (skillRoot) {
+    const root = join(skillRoot, "owner"),
+      defaults = join(skillRoot, "defaults");
+    await mkdir(root);
+    await mkdir(defaults);
+    const host: SkillContext = {
+      tools: ctx.tools,
+      userQuestions: ctx.userQuestions,
+      workingDirectory: { get: () => root },
+      sandboxPolicy: { workspaceRoot: root },
+      workspaceRegistry: {
+        get: () => ({ path: root }),
+        list: () => [{ id: "owned-workspace", path: root }],
+      },
+      effect: (effect) => {
+        ctx.effect(() => {
+          const dispose = effect();
+          return () => {
+            if (typeof dispose === "function") dispose();
+          };
+        });
+      },
+      on() {},
+      connection: { requestRejection: () => undefined },
+      webServer: { register: () => () => {} },
+    };
+    registerWorkflowTool(host, { enabled: true, defaultSkillDir: defaults });
+  }
+  const model = new ScenarioModel(tool, args);
+  ctx.llm.registerAdapter(["synthetic"], model);
+  const handle = await ctx.agents.create({
+    sessionId: SessionId("scenario-session"),
+    signal: AbortSignal.timeout(10000),
+    agentOptions: {
+      provider: "synthetic",
+      model: "scenario-model",
+      maxTokens: 2048,
+    },
+  });
+  handle.agent.followup({
+    id: MessageId("scenario-prompt"),
+    role: "user",
+    source: { kind: "user" },
+    content: [{ type: "text", text: "请按合成测试场景处理" }],
+  });
+  const pendingQuestion = Promise.race([
+    asked,
+    handle.agent.whenIdle().then(() => {
+      throw new Error(
+        `Scenario ended without a question: ${JSON.stringify(handle.agent.session.snapshotEvents())}`,
+      );
+    }),
+  ]);
+  return {
+    ctx,
+    bridge,
+    model,
+    handle,
+    asked: pendingQuestion,
+    async close() {
+      bridge.close();
+      await handle.dispose();
+      for (const fiber of fibers.reverse()) await fiber.dispose();
+    },
+  };
+}
+
+test("official DSH Loop asks options, waits without a second model call, accepts floating reply and continues", async () => {
+  const f = await scenario("ask_user_question", {
+    questions: [
+      {
+        id: "format",
+        question: "生成哪种报告？",
+        options: [{ label: "HTML" }, { label: "PPT" }],
+      },
+    ],
+  });
+  try {
+    await f.asked;
+    const [question] = f.bridge.list("scenario-session");
+    assert.equal(f.model.calls, 1);
+    assert.equal(question?.questions[0]?.question, "生成哪种报告？");
+    f.bridge.answer("scenario-session", question!.id, {
+      answers: [{ id: "format", selected: ["HTML"] }],
+    });
+    await f.handle.agent.whenIdle();
+    assert.equal(f.model.calls, 2);
+    assert.match(JSON.stringify(f.model.results), /HTML/);
+    assert.equal(f.bridge.list("scenario-session").length, 0);
+    const end = f.handle.agent.session
+      .snapshotEvents()
+      .filter((event) => event.type === "turn/end")
+      .at(-1);
+    assert.equal(end?.data.reason.kind, "completed");
+  } finally {
+    await f.close();
+  }
+});
+
+test("official DSH Loop reviews Chinese named workflow, persists confirmed skill and returns saved receipt to model", async () => {
+  const temporary = await realpath(
+    await mkdtemp(join(tmpdir(), "windy-skill-loop-")),
+  );
+  const f = await scenario(
+    "save_workflow_skill",
+    {
+      name: "每周案件简报",
+      description: "整理本次授权材料。",
+      workflow:
+        "输入：用户选择的材料。\n步骤：核对来源，整理简报，回读核验。\n输出：附来源的简报。",
+    },
+    temporary,
+  );
+  try {
+    await f.asked;
+    const [question] = f.bridge.list("scenario-session");
+    assert.match(question!.questions[0]!.detail!, /每周案件简报/);
+    assert.equal(f.model.calls, 1);
+    f.bridge.answer("scenario-session", question!.id, {
+      answers: [{ id: "save-skill", selected: ["保存个人技能"] }],
+    });
+    await f.handle.agent.whenIdle();
+    assert.equal(f.model.calls, 2);
+    assert.match(JSON.stringify(f.model.results), /saved/);
+    const draft = question!.questions[0]!.detail!;
+    const name = /^name: (.+)$/m.exec(draft)![1]!;
+    assert.equal(
+      await readFile(
+        join(temporary, "owner", ".dsh", "skills", name, "SKILL.md"),
+        "utf8",
+      ),
+      draft,
+    );
+  } finally {
+    await f.close();
+    await rm(temporary, { recursive: true, force: true });
+  }
+});

package/template/apps/agent-server/runtime/report-breakdown.ts

@@ -0,0 +1,79 @@
+import type { RuntimeStore, StoredRun } from "./store.js";
+export function reportBreakdown(runs: StoredRun[], store: RuntimeStore) {
+  const byModel = new Map<
+    string,
+    {
+      deploymentKey: string;
+      model: string;
+      attempts: number;
+      inputTokens: number | null;
+      outputTokens: number | null;
+      cachedInputTokens: number | null;
+      reasoningTokens: number | null;
+      totalTokens: number | null;
+      unknownUsageCount: number;
+    }
+  >();
+  const activity = new Map<
+    string,
+    {
+      date: string;
+      runs: number;
+      completed: number;
+      failed: number;
+      totalTokens: number | null;
+    }
+  >();
+  for (const run of runs) {
+    const date = run.createdAt.slice(0, 10),
+      point = activity.get(date) ?? {
+        date,
+        runs: 0,
+        completed: 0,
+        failed: 0,
+        totalTokens: null,
+      };
+    point.runs++;
+    if (run.status === "completed") point.completed++;
+    if (run.status === "failed") point.failed++;
+    for (const attempt of store.attempts(run.id)) {
+      const deploymentKey = String(attempt.deploymentKey),
+        model = String(attempt.model),
+        key = `${deploymentKey}\0${model}`;
+      const group = byModel.get(key) ?? {
+        deploymentKey,
+        model,
+        attempts: 0,
+        inputTokens: null,
+        outputTokens: null,
+        cachedInputTokens: null,
+        reasoningTokens: null,
+        totalTokens: null,
+        unknownUsageCount: 0,
+      };
+      group.attempts++;
+      if (attempt.usageSource === "unknown") group.unknownUsageCount++;
+      for (const field of [
+        "inputTokens",
+        "outputTokens",
+        "cachedInputTokens",
+        "reasoningTokens",
+        "totalTokens",
+      ] as const) {
+        const value = attempt[field];
+        if (typeof value === "number")
+          group[field] = (group[field] ?? 0) + value;
+      }
+      if (typeof attempt.totalTokens === "number")
+        point.totalTokens = (point.totalTokens ?? 0) + attempt.totalTokens;
+      byModel.set(key, group);
+    }
+    activity.set(date, point);
+  }
+  return {
+    byModel: [...byModel.values()],
+    activity: [...activity.values()].sort((a, b) =>
+      a.date.localeCompare(b.date),
+    ),
+  };
+}