create-windy 0.8.3 → 0.9.1

package/template/apps/agent-server/native/parallel-harness.ts

@@ -0,0 +1,242 @@
+import { expect } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import * as Persistence from "@deepseek-ai/dsh-session-persistence-jsonl";
+import { Context } from "@deepseek-ai/cordis";
+import AgentRegistry from "@deepseek-ai/dsh-agent";
+import AgentLoop from "@deepseek-ai/dsh-agent-loop";
+import SessionStore, {
+  SessionId,
+  SessionLogOffset,
+} 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 LocalFileSystem from "@deepseek-ai/dsh-fs-local";
+import WorkingDirectory from "@deepseek-ai/dsh-working-directory";
+import Subagents from "@deepseek-ai/dsh-subagent";
+import * as Spawn from "@deepseek-ai/dsh-subagent-spawn-in-process";
+import * as Delegate from "@deepseek-ai/dsh-tool-subagent";
+import * as Control from "@deepseek-ai/dsh-tool-subagent-control";
+// @ts-expect-error Project Cordis plugin uses upstream JS module convention.
+import * as Policy from "../plugins/parallel.mjs";
+import { ModelCapacity } from "../runtime/capacity.js";
+import * as Mcp from "@deepseek-ai/dsh-mcp-client";
+import { parallelMcpFixture } from "./parallel-mcp-fixture.js";
+
+const delay = (ms: number) =>
+  new Promise<void>((accept) => setTimeout(accept, ms));
+export async function until(check: () => boolean) {
+  for (let i = 0; i < 100 && !check(); i++) await delay(10);
+  expect(check()).toBe(true);
+}
+export class SyntheticModel extends LlmAdapter {
+  readonly capacity: ModelCapacity;
+  constructor(slots = 3) {
+    super();
+    this.capacity = new ModelCapacity(slots);
+  }
+  childActive = 0;
+  maximum = 0;
+  aborted = 0;
+  hold = false;
+  calls = new Map<string, number>();
+  override providerInfo(id: string) {
+    return { id, name: id };
+  }
+  override async resolveModel(provider: string, id: string) {
+    return {
+      provider,
+      id,
+      name: id,
+      inputModalities: ["text" as const],
+      context: { contextWindow: 32768 },
+    };
+  }
+  override async *stream(
+    options: GenerateOptions,
+  ): AsyncGenerator<StreamChunk> {
+    const release = await this.capacity.acquireNative(options.signal!);
+    try {
+      yield* this.generate(options);
+    } finally {
+      release();
+    }
+  }
+  private async *generate(
+    options: GenerateOptions,
+  ): AsyncGenerator<StreamChunk> {
+    const text = JSON.stringify(options.messages);
+    const child = options.messages.some(
+      (m) =>
+        m.role === "user" && JSON.stringify(m.content).includes("CHILD_TASK_"),
+    );
+    const key = child ? (text.includes("CHILD_TASK_A") ? "a" : "b") : "parent";
+    const count = (this.calls.get(key) ?? 0) + 1;
+    this.calls.set(key, count);
+    const call = (name: string, args: object, id: string): StreamChunk => ({
+      type: "block-end",
+      index: id.endsWith("B") ? 1 : 0,
+      block: {
+        type: "tool-call",
+        id: ToolCallId(id),
+        name,
+        arguments: JSON.stringify(args),
+      },
+    });
+    if (!child && count === 1) {
+      for (const suffix of ["A", "B"])
+        yield call(
+          "subagent",
+          { description: `analysis ${suffix}`, prompt: `CHILD_TASK_${suffix}` },
+          `spawn-${suffix}`,
+        );
+      yield { type: "finish", reason: { kind: "tool-calls" } };
+      return;
+    }
+    if (child && count === 1) {
+      this.childActive++;
+      this.maximum = Math.max(this.maximum, this.childActive);
+      try {
+        if (this.hold)
+          await new Promise<void>((_, reject) => {
+            const abort = () => {
+              this.aborted++;
+              reject(options.signal?.reason);
+            };
+            options.signal?.addEventListener("abort", abort, { once: true });
+            if (options.signal?.aborted) abort();
+          });
+        else await delay(50);
+      } finally {
+        this.childActive--;
+      }
+      yield call("mcp__windy__query", { source: key }, `query-${key}`);
+      yield { type: "finish", reason: { kind: "tool-calls" } };
+      return;
+    }
+    if (child && count === 2) {
+      const parent = /PARENT_ID:([^\s]+)/.exec(text)?.[1] ?? "parent";
+      yield call(
+        "send_message",
+        { agent_id: parent, message: `RESULT_${key.toUpperCase()}` },
+        `report-${key}`,
+      );
+      yield { type: "finish", reason: { kind: "tool-calls" } };
+      return;
+    }
+    yield {
+      type: "block-end",
+      index: 0,
+      block: {
+        type: "text",
+        text: child
+          ? "分析完成"
+          : text.includes("RESULT_A") && text.includes("RESULT_B")
+            ? "汇总 A+B"
+            : "等待分析",
+      },
+    };
+    yield { type: "finish", reason: { kind: "stop" } };
+  }
+}
+export async function harness(
+  model: SyntheticModel,
+  policy = {},
+  seeded = false,
+) {
+  const directory = await mkdtemp(join(tmpdir(), "windy-subagents-"));
+  const ctx = new Context();
+  const fibers: Array<{ dispose(): Promise<void> }> = [];
+  for (const plugin of [
+    LlmRuntime,
+    SessionStore,
+    SessionProjections,
+    AgentRegistry,
+    LocalFileSystem,
+    WorkingDirectory,
+  ])
+    fibers.push(await ctx.plugin(plugin));
+  fibers.push(
+    await ctx.plugin(SystemPrompt, {
+      includeHarnessIdentity: false,
+      includeRuntimeContext: false,
+    }),
+  );
+  fibers.push(await ctx.plugin(ToolRuntime));
+  fibers.push(
+    await ctx.plugin(AgentLoop, { maxParallelToolCalls: 2, agents: [] }),
+  );
+  fibers.push(
+    await ctx.plugin(Persistence, { root: directory, compression: "none" }),
+  );
+  fibers.push(
+    await ctx.plugin(Subagents, { maxDepth: 1, maxActiveSubagents: 2 }),
+  );
+  fibers.push(await ctx.plugin(Spawn));
+  fibers.push(await ctx.plugin(Delegate, { provider: "spawn", maxDepth: 1 }));
+  fibers.push(await ctx.plugin(Control));
+  ctx.provide("sessionController", {
+    cancel(request: { sessionId: string }) {
+      ctx.agents.get(SessionId(request.sessionId))?.cancel({ kind: "user" });
+      return { accepted: true };
+    },
+  } as never);
+  fibers.push(await ctx.plugin(Policy, policy));
+  for (const fiber of fibers)
+    await (fiber as { await?(): Promise<void> }).await?.();
+
+  ctx.llm.registerAdapter(["test"], model);
+  const mcp = parallelMcpFixture();
+  const mcpFiber = ctx.plugin(Mcp, mcp.config);
+  await mcpFiber.await();
+  fibers.push(mcpFiber);
+  const handle = await ctx.agents.create({
+    sessionId: SessionId("parent"),
+    ...(seeded
+      ? {
+          seed: [],
+          inheritedEventCount: SessionLogOffset(0),
+          meta: { parentSession: SessionId("closed-source"), isSeeded: true },
+        }
+      : {}),
+    agentOptions: { provider: "test", model: "synthetic" },
+  });
+  let output = "";
+  ctx.on("session/event", (session, event) => {
+    if (session.id === "parent" && event.type === "assistant/message")
+      output += event.data.message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+  });
+  return {
+    ctx,
+    handle,
+    queries: mcp.queries,
+    checks: mcp.checks,
+    output: () => output,
+    async close() {
+      await handle.dispose();
+      for (const fiber of fibers.reverse()) await fiber.dispose();
+      mcp.close();
+      await rm(directory, { recursive: true, force: true });
+    },
+    start() {
+      handle.agent.followup({
+        id: MessageId("human"),
+        role: "user",
+        source: { kind: "user" },
+        content: [{ type: "text", text: "请并行分析并汇总" }],
+      });
+    },
+  };
+}

package/template/apps/agent-server/native/parallel-mcp-fixture.ts

@@ -0,0 +1,97 @@
+import { createBoundary } from "./boundary.js";
+import type { NativeWorker, WorkbenchManager } from "./manager.js";
+
+/** Synthetic product, real boundary + official MCP client. Never reads business data. */
+export function parallelMcpFixture() {
+  const previous = process.env.AI_TOOL_HOST_URL;
+  const queries: string[] = [];
+  let checks = 0;
+  const worker: Pick<
+    NativeWorker,
+    "authority" | "controller" | "admissionController"
+  > = {
+    authority: {
+      actorId: "fixture-user",
+      session: "p".repeat(43),
+      publicOrigin: "http://fixture.local",
+    },
+    controller: new AbortController(),
+    admissionController: new AbortController(),
+  };
+  const manager = {
+    byToken: (token: string) => (token === "w".repeat(43) ? worker : undefined),
+    current: async () => {
+      checks++;
+      return !worker.controller.signal.aborted;
+    },
+  } as unknown as WorkbenchManager;
+  const boundary = createBoundary({
+    manager,
+    completion: async () => new Response(null, { status: 500 }),
+  });
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    async fetch(request) {
+      if (new URL(request.url).pathname.startsWith("/internal/boundary"))
+        return boundary(request);
+      if (request.method !== "POST") return new Response(null, { status: 405 });
+      if (
+        request.headers.get("authorization") !==
+        `Bearer ${worker.authority.session}`
+      )
+        return new Response(null, { status: 401 });
+      const body = await request.json();
+      if (body.id === undefined) return new Response(null, { status: 202 });
+      let result: unknown = {};
+      if (body.method === "initialize")
+        result = {
+          protocolVersion: body.params.protocolVersion,
+          capabilities: { tools: {} },
+          serverInfo: { name: "synthetic-windy", version: "1" },
+        };
+      if (body.method === "tools/list")
+        result = {
+          tools: [
+            {
+              name: "query",
+              description: "Synthetic actor-authorized read-only query",
+              inputSchema: {
+                type: "object",
+                properties: { source: { type: "string" } },
+                required: ["source"],
+              },
+            },
+          ],
+        };
+      if (body.method === "tools/call") {
+        queries.push(body.params.arguments.source);
+        result = {
+          content: [
+            { type: "text", text: `data-${body.params.arguments.source}` },
+          ],
+        };
+      }
+      return Response.json({ jsonrpc: "2.0", id: body.id, result });
+    },
+  });
+  process.env.AI_TOOL_HOST_URL = `http://127.0.0.1:${server.port}`;
+  return {
+    queries,
+    checks: () => checks,
+    config: {
+      transport: "streamable-http" as const,
+      serverName: "windy",
+      url: `http://127.0.0.1:${server.port}/internal/boundary/mcp`,
+      headers: { authorization: `Bearer ${"w".repeat(43)}` },
+      failOnStartupError: true,
+      toolCallTimeoutMs: 2000,
+    },
+    close() {
+      worker.controller.abort();
+      server.stop(true);
+      if (previous === undefined) delete process.env.AI_TOOL_HOST_URL;
+      else process.env.AI_TOOL_HOST_URL = previous;
+    },
+  };
+}

package/template/apps/agent-server/native/parallel.test.ts

@@ -0,0 +1,256 @@
+import { test, expect } from "bun:test";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { ModelCapacity } from "../runtime/capacity.js";
+import { AdmissionQueue } from "./admission.js";
+import { SyntheticModel, harness, until } from "./parallel-harness.js";
+const delay = (ms: number) =>
+  new Promise<void>((accept) => setTimeout(accept, ms));
+
+test("official DSH spawns two simultaneous children, sees actor tools and delivers summary", async () => {
+  const model = new SyntheticModel();
+  const app = await harness(model);
+  try {
+    app.start();
+    await until(() => app.output().includes("汇总 A+B"));
+    expect(model.maximum).toBe(2);
+    expect(app.queries.sort()).toEqual(["a", "b"]);
+    expect(app.checks()).toBeGreaterThanOrEqual(5);
+  } finally {
+    await app.close();
+  }
+});
+
+test("human parent cancellation drains both official child model calls while root is idle", async () => {
+  const model = new SyntheticModel(4);
+  model.hold = true;
+  const app = await harness(model);
+  try {
+    app.start();
+    await until(
+      () => model.childActive === 2 && app.handle.agent.status === "idle",
+    );
+    (
+      app.ctx.get("sessionController") as unknown as {
+        cancel(request: { sessionId: string }): void;
+      }
+    ).cancel({ sessionId: "parent" });
+    await until(() => model.aborted === 2 && model.childActive === 0);
+  } finally {
+    await app.close();
+  }
+});
+
+test("native shared capacity queues without consuming canonical reserve and abort removes waiters", async () => {
+  const capacity = new ModelCapacity(3);
+  const first = await capacity.acquireNative(new AbortController().signal);
+  const second = await capacity.acquireNative(new AbortController().signal);
+  const controller = new AbortController();
+  const queued = capacity.acquireNative(controller.signal);
+  const rejection = queued.then(
+    () => false,
+    () => true,
+  );
+  expect(capacity.snapshot().activeModelCalls).toBe(2);
+  const canonical = capacity.acquire();
+  expect(capacity.snapshot().activeModelCalls).toBe(3);
+  controller.abort(new Error("cancelled"));
+  expect(await rejection).toBe(true);
+  canonical();
+  first();
+  second();
+  expect(capacity.snapshot().activeModelCalls).toBe(0);
+  const serial = new ModelCapacity(2);
+  const occupied = await serial.acquireNative(new AbortController().signal);
+  let admitted = false;
+  const waiting = serial
+    .acquireNative(new AbortController().signal)
+    .then((release) => {
+      admitted = true;
+      return release;
+    });
+  await delay(10);
+  expect(admitted).toBe(false);
+  occupied();
+  (await waiting)();
+  expect(admitted).toBe(true);
+  await expect(
+    new ModelCapacity(1).acquireNative(new AbortController().signal),
+  ).rejects.toMatchObject({ code: "RATE_LIMITED", status: 429 });
+});
+
+test("native FIFO has finite queue, timeout, cancellation and idempotent release", async () => {
+  const queue = new AdmissionQueue(1, 1, 20);
+  const first = await queue.acquire(new AbortController().signal);
+  const waiting = queue.acquire(new AbortController().signal);
+  await expect(queue.acquire(new AbortController().signal)).rejects.toThrow(
+    "NATIVE_QUEUE_FULL",
+  );
+  await expect(waiting).rejects.toThrow("NATIVE_QUEUE_TIMEOUT");
+  first();
+  first();
+  expect(queue.snapshot()).toEqual({ active: 0, queued: 0 });
+});
+
+test("one shared model budget covers parent and both children", async () => {
+  const model = new SyntheticModel();
+  const app = await harness(model, { maxModelCalls: 4 });
+  const queriesCompleted = Promise.withResolvers<void>();
+  const childrenDisposed = Promise.withResolvers<void>();
+  const liveChildren = new Set<string>();
+  let started = 0,
+    completedQueries = 0;
+  const subscriptions = [
+    app.ctx.on("subagent/start", ({ id }) => {
+      started++;
+      liveChildren.add(id);
+    }),
+    app.ctx.on("agent/disposed", ({ agent }) => {
+      liveChildren.delete(agent.id);
+      if (started === 2 && liveChildren.size === 0) childrenDisposed.resolve();
+    }),
+    app.ctx.on("tools/post-execute", async (execution, result, next) => {
+      if (execution.name === "mcp__windy__query" && !result.isError) {
+        // A fast child cannot enter its second model attempt and consume the
+        // shared budget before the other child's first authorized query ends.
+        if (++completedQueries === 2) queriesCompleted.resolve();
+        await queriesCompleted.promise;
+      }
+      return next();
+    }),
+  ];
+  try {
+    app.start();
+    await queriesCompleted.promise;
+    await childrenDisposed.promise;
+    expect(app.queries.sort()).toEqual(["a", "b"]);
+    expect(completedQueries).toBe(2);
+    expect(app.ctx.agents.list().length).toBe(1);
+    expect(
+      [...model.calls.values()].reduce((sum, count) => sum + count, 0),
+    ).toBeLessThanOrEqual(4);
+    expect(app.output()).not.toContain("汇总 A+B");
+  } finally {
+    queriesCompleted.resolve();
+    for (const unsubscribe of subscriptions) unsubscribe();
+    await app.close();
+  }
+});
+
+test("shared deadline cancels idle parent children still running", async () => {
+  const model = new SyntheticModel();
+  model.hold = true;
+  const app = await harness(model, { durationMs: 100 });
+  try {
+    app.start();
+    await until(() => model.aborted === 2 && model.childActive === 0);
+  } finally {
+    await app.close();
+  }
+});
+
+test("one native slot serializes real children without 429 or busy retry", async () => {
+  const model = new SyntheticModel(2);
+  const app = await harness(model);
+  try {
+    app.start();
+    await until(() => app.output().includes("汇总 A+B"));
+    expect(model.maximum).toBe(1);
+    expect(app.queries.sort()).toEqual(["a", "b"]);
+    expect(
+      [...model.calls.values()].reduce((sum, count) => sum + count, 0),
+    ).toBeLessThan(16);
+  } finally {
+    await app.close();
+  }
+});
+
+test("parent turn cancellation removes active and queued child provider calls", async () => {
+  const model = new SyntheticModel(2);
+  model.hold = true;
+  const app = await harness(model);
+  try {
+    app.start();
+    await until(() => model.childActive === 1);
+    app.handle.agent.cancel({ kind: "user" });
+    await until(
+      () => model.childActive === 0 && app.ctx.agents.list().length === 1,
+    );
+    expect(model.aborted).toBe(1);
+    expect(model.capacity.snapshot().activeModelCalls).toBe(0);
+  } finally {
+    await app.close();
+  }
+});
+
+test("shared tool budget prevents child queries from exceeding the family limit", async () => {
+  const model = new SyntheticModel();
+  const app = await harness(model, { maxToolCalls: 2 });
+  try {
+    app.start();
+    await until(() => model.maximum === 2);
+    await until(() => app.ctx.agents.list().length === 1);
+    expect(app.queries).toEqual([]);
+  } finally {
+    await app.close();
+  }
+});
+
+test("family total child budget denies additional delegation", async () => {
+  const model = new SyntheticModel();
+  const app = await harness(model, { maxChildren: 1 });
+  try {
+    app.start();
+    await until(() => app.queries.length === 1);
+    expect(model.maximum).toBe(1);
+    expect(app.queries).toEqual(["a"]);
+  } finally {
+    await app.close();
+  }
+});
+
+test("normal seeded conversation with an unloaded parent still delegates and summarizes", async () => {
+  const model = new SyntheticModel();
+  const app = await harness(model, {}, true);
+  try {
+    expect(app.ctx.agents.get(SessionId("closed-source"))).toBeUndefined();
+    expect(app.handle.agent.session.header.isSeeded).toBe(true);
+    app.start();
+    await until(() => app.output().includes("汇总 A+B"));
+    expect(model.maximum).toBe(2);
+  } finally {
+    await app.close();
+  }
+});
+
+test("an unrelated orphan subagent cannot break another family's cancellation", async () => {
+  const model = new SyntheticModel(4);
+  model.hold = true;
+  const app = await harness(model);
+  const orphan = await app.ctx.agents.create({
+    sessionId: SessionId("unrelated-orphan"),
+    meta: {
+      origin: "subagent",
+      parentSession: SessionId("missing-parent"),
+      delegationDepth: 1,
+    },
+    agentOptions: { provider: "test", model: "synthetic" },
+  });
+  try {
+    app.start();
+    await until(
+      () => model.childActive === 2 && app.handle.agent.status === "idle",
+    );
+    (
+      app.ctx.get("sessionController") as unknown as {
+        cancel(request: { sessionId: string }): void;
+      }
+    ).cancel({ sessionId: "parent" });
+    await until(() => model.aborted === 2 && model.childActive === 0);
+    expect(app.ctx.agents.get(SessionId("unrelated-orphan"))).toBe(
+      orphan.agent,
+    );
+  } finally {
+    await orphan.dispose();
+    await app.close();
+  }
+});