create-windy 0.8.3 → 0.10.0

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();
+  }
+});

package/template/apps/agent-server/native/profile-composition.test.ts

@@ -0,0 +1,147 @@
+import { expect, test } from "bun:test";
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import {
+  bundlePatchPaths,
+  composeEntries,
+  loadOverlayPatches,
+} from "@deepseek-ai/dsh-app-boot";
+import { nativeProfile } from "./profile";
+import { defaultHostFixture } from "./host-test-fixture.js";
+
+const require = createRequire(import.meta.url);
+function officialLayers() {
+  return ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app"].flatMap(
+    (name) => {
+      const path = require.resolve(`${name}/package.json`);
+      const manifest = JSON.parse(readFileSync(path, "utf8"));
+      return bundlePatchPaths(dirname(path), manifest.dsh.bundle).map((patch) =>
+        loadOverlayPatches("test", patch),
+      );
+    },
+  );
+}
+
+test("official profile composition replaces privileged services with managed adapters", () => {
+  const layers = officialLayers();
+  const appRoot = resolve(import.meta.dir, "..");
+  const entries = composeEntries([
+    ...layers,
+    nativeProfile(
+      {
+        appRoot,
+        gateUrl: "http://127.0.0.1:9999",
+        model: "fixture",
+        contextWindow: 32768,
+        maxOutputTokens: 4096,
+        userExtensions: true,
+      },
+      defaultHostFixture,
+    ),
+  ]);
+  for (const id of ["settings-controller", "subprocess"]) {
+    expect(entries.find((entry) => entry.id === id)?.disabled).toBe(true);
+    const replacement = entries.find((entry) => entry.id === `windy-${id}`);
+    expect(replacement?.disabled).not.toBe(true);
+    expect(replacement?.name).toBe(resolve(appRoot, "plugins", `${id}.mjs`));
+  }
+  // New upstream providers must remain outside the product's governed egress.
+  for (const id of [
+    "llm-deepseek",
+    "llm-deepseek-account",
+    "web-search-deepseek",
+    "web-deepseek-api",
+    "web-fetch-http",
+    "tool-plugin-manager",
+  ])
+    expect(entries.find((entry) => entry.id === id)?.disabled).toBe(true);
+});
+
+test("official composition inserts skill management with its explicit extension switch", () => {
+  const layers = officialLayers();
+  const appRoot = resolve(import.meta.dir, "..");
+  for (const enabled of [true, false]) {
+    const entries = composeEntries([
+      ...layers,
+      nativeProfile(
+        {
+          appRoot,
+          gateUrl: "http://127.0.0.1:9999",
+          model: "fixture",
+          contextWindow: 32768,
+          maxOutputTokens: 4096,
+          userExtensions: enabled,
+        },
+        defaultHostFixture,
+      ),
+    ]);
+    const management = entries.filter(
+      (entry) => entry.id === "windy-skill-library",
+    );
+    expect(management).toHaveLength(1);
+    expect(management[0]).toMatchObject({
+      disabled: !enabled,
+      name: resolve(appRoot, "plugins/skill-library/index.mjs"),
+      config: {
+        enabled,
+        defaultSkillDir: resolve(appRoot, "plugins/skills"),
+        extraDefaultSkillDirs: [],
+        draftModel: "fixture",
+        draftMaxTokens: 4096,
+      },
+    });
+  }
+});
+
+test("all declared upstream patch layers mount only the managed registry and fixed Windy preset without skipped replacements", () => {
+  const layers = officialLayers();
+  expect(layers.length).toBeGreaterThan(2);
+  const appRoot = resolve(import.meta.dir, "..");
+  for (const userExtensions of [true, false]) {
+    const warnings: string[] = [];
+    const entries = composeEntries(
+      [
+        ...layers,
+        nativeProfile(
+          {
+            appRoot,
+            gateUrl: "http://127.0.0.1:9999",
+            model: "fixture",
+            contextWindow: 32768,
+            maxOutputTokens: 4096,
+            userExtensions,
+          },
+          defaultHostFixture,
+        ),
+      ],
+      (message) => warnings.push(message),
+    );
+    expect(warnings).toEqual([]);
+    expect(
+      entries.find((entry) => entry.id === "agent-preset-registry"),
+    ).toMatchObject({
+      name: "@deepseek-ai/dsh-agent-preset-registry",
+      disabled: true,
+    });
+    const managed = entries.filter(
+      (entry) =>
+        entry.name === resolve(appRoot, "plugins/preset-registry.mjs") &&
+        entry.disabled !== true,
+    );
+    expect(managed).toHaveLength(1);
+    expect(managed[0]).toMatchObject({
+      id: "windy-agent-preset-registry",
+      config: { default: "windy" },
+    });
+    expect(
+      entries
+        .filter(
+          (entry) =>
+            entry.name === "@deepseek-ai/dsh-agent-preset" &&
+            entry.disabled !== true,
+        )
+        .map((entry) => entry.id),
+    ).toEqual(["preset-windy"]);
+  }
+});

package/template/apps/agent-server/native/profile.ts

@@ -0,0 +1,307 @@
+import { resolve } from "node:path";
+import { officePreviewPlugin } from "./office-preview.js";
+import { conversationInstructions } from "./conversation-instructions.js";
+import { projectHost } from "../project/host.js";
+import type { DshHostConfiguration } from "../host-contracts.js";
+import { hostPresetId, hostReplacements } from "./host-profile.js";
+
+/** Final deployment overlay keeps identity and shared-model routing application-owned. */
+export function nativeProfile(
+  config: {
+    appRoot: string;
+    gateUrl: string;
+    model: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    userExtensions?: boolean;
+  },
+  host: DshHostConfiguration = projectHost,
+) {
+  const presetId = hostPresetId(host);
+  const replacements = hostReplacements(host);
+  const plugins = resolve(config.appRoot, "plugins");
+  const userExtensions = config.userExtensions ?? true;
+  const toolConfig: Record<string, unknown> = {
+    "agent-instructions": { maxBytes: 32768 },
+    "tool-fs-search": { sampleOverCapGlobResults: false },
+    "tool-todo": { allowParallelInProgress: false },
+  };
+  const disable = [
+    "llm-deepseek",
+    "llm-deepseek-account",
+    "deepseek-account",
+    "web-search-deepseek",
+    "web-deepseek-api",
+    "web-fetch-http",
+    "tool-plugin-manager",
+    "account-controller",
+    "ui-settings-models",
+    "ui-settings-account",
+    "ui-settings-session-log",
+    "ui-agent-preset",
+    "agent-preset-registry",
+    "session-log-deepseek",
+    "open-in-app",
+    "settings-controller",
+    "subprocess",
+    "session-title-llm",
+    "ui-brand-official",
+    "preset-standard",
+    "preset-minimal",
+    "preset-ptc",
+    "preset-cordis",
+    // First parallel slice uses fresh, managed children, with one fixed preset.
+    "tool-subagent-fork",
+    "tool-workflow",
+    ...replacements,
+  ];
+  return [
+    ...disable.map((id) => ({ id, disabled: true })),
+    ...[
+      "plugin-manager",
+      "hmr",
+      "client-hmr",
+      "config-editor",
+      "settings",
+      "ui-plugin-manager",
+      "ui-settings-plugin-inventory",
+      "ui-settings-plugins",
+    ].map((id) => ({ id, disabled: !userExtensions })),
+    {
+      id: "llm-pi-ai",
+      config: {
+        providers: {
+          windy: {
+            api: "openai-completions",
+            apiKeyEnv: "WINDY_WORKER_TOKEN",
+            baseURL: `${config.gateUrl}/v1`,
+            timeoutMs: 120000,
+            streamIdleTimeoutMs: 30000,
+            retryPolicy: { mode: "normal", maxRetries: 0 },
+            compat: {
+              supportsDeveloperRole: false,
+              maxTokensField: "max_tokens",
+            },
+            models: [
+              {
+                id: config.model,
+                contextWindow: config.contextWindow,
+                maxTokens: config.maxOutputTokens,
+                input: ["text", "image"],
+              },
+            ],
+          },
+        },
+      },
+    },
+    {
+      id: "agent-default-model",
+      config: { provider: "windy", model: config.model },
+    },
+    { id: "agent-loop", config: { agents: [], maxParallelToolCalls: 1 } },
+    { id: "locale", config: { preference: "zh" } },
+    officePreviewPlugin(),
+    { id: "subagent", config: { maxDepth: 1, maxActiveSubagents: 2 } },
+    {
+      id: "tool-subagent",
+      config: {
+        provider: "spawn",
+        toolName: "subagent",
+        agentPreset: presetId,
+        maxDepth: 1,
+        modelSelectionSettings: false,
+      },
+    },
+    {
+      id: "web-runtime",
+      config: {
+        openBrowser: false,
+        printUrl: false,
+        publicUrl: process.env.WINDY_PUBLIC_URL,
+        surfaceContext: true,
+      },
+    },
+    {
+      id: "workspace-controller",
+      config: { documentsDirectory: process.cwd() },
+    },
+    {
+      id: "permission",
+      config: {
+        presets: {
+          "read-only": { sandbox: "read-only", approval: "ask" },
+          "workspace-write": { sandbox: "workspace-write", approval: "ask" },
+        },
+      },
+    },
+    { id: "sandbox", config: {} },
+    {
+      insert: [
+        {
+          id: "windy-agent-preset-registry",
+          name: resolve(plugins, "preset-registry.mjs"),
+          config: { default: presetId },
+        },
+        {
+          id: "windy-skill-library",
+          disabled: !userExtensions,
+          name: resolve(plugins, "skill-library", "index.mjs"),
+          config: {
+            enabled: userExtensions,
+            defaultSkillDir: resolve(plugins, "skills"),
+            extraDefaultSkillDirs: host.skillDirectories.map((directory) =>
+              resolve(config.appRoot, directory),
+            ),
+            draftModel: config.model,
+            draftMaxTokens: Math.min(config.maxOutputTokens, 8192),
+          },
+        },
+        {
+          id: "windy-settings-controller",
+          name: resolve(plugins, "settings-controller.mjs"),
+        },
+        // Retain the deployment fence even for wider approved DSH modes.
+        { id: "windy-subprocess", name: resolve(plugins, "subprocess.mjs") },
+        {
+          id: "windy-access",
+          name: resolve(plugins, "access.mjs"),
+          config: { presetId },
+        },
+        {
+          id: "windy-shared-skills",
+          name: resolve(plugins, "shared-skills.mjs"),
+        },
+        {
+          id: "windy-tool-catalog",
+          name: resolve(plugins, "tool-catalog", "index.mjs"),
+        },
+        {
+          id: "windy-tool-presentation",
+          name: resolve(plugins, "tool-presentation", "index.mjs"),
+        },
+        {
+          id: "windy-skill-presentation",
+          name: resolve(plugins, "skill-library", "presentation", "index.mjs"),
+        },
+        {
+          id: "windy-drop-overlay",
+          name: resolve(plugins, "drop-overlay", "index.mjs"),
+        },
+        {
+          id: "windy-settings",
+          name: resolve(plugins, "settings", "index.mjs"),
+        },
+        {
+          id: "windy-workspace",
+          name: resolve(plugins, "workspace", "index.mjs"),
+          config: { label: host.workspaceLabel },
+        },
+        { id: "windy-parallel", name: resolve(plugins, "parallel.mjs") },
+        {
+          id: "windy-locale",
+          name: resolve(plugins, "locale", "index.mjs"),
+        },
+        {
+          id: "windy-theme",
+          name: resolve(plugins, "theme", "index.mjs"),
+        },
+        {
+          id: "windy-branding",
+          name: resolve(plugins, "branding", "index.mjs"),
+        },
+        {
+          id: "windy-downloads",
+          name: resolve(plugins, "downloads", "index.mjs"),
+        },
+        ...host.plugins.map((plugin) => ({
+          id: `project-${plugin.key}`,
+          name: resolve(config.appRoot, plugin.path),
+          ...(plugin.config ? { config: plugin.config } : {}),
+        })),
+        {
+          id: `preset-${presetId}`,
+          name: "@deepseek-ai/dsh-agent-preset",
+          config: {
+            id: presetId,
+            name: host.assistantName,
+            description: host.assistantDescription,
+            order: 1,
+            plugins: [
+              {
+                id: "persona",
+                name: "@deepseek-ai/dsh-persona",
+                config: {
+                  prefix: [conversationInstructions, ...host.instructions].join(
+                    "\n",
+                  ),
+                },
+              },
+              ...[
+                "agent-instructions",
+                "tool-bash",
+                "tool-fs",
+                "tool-fs-search",
+                "tool-skill",
+                "tool-ask-user",
+                "tool-todo",
+                "tool-present",
+              ].map((id) => ({
+                id,
+                name: `@deepseek-ai/dsh-${id}`,
+                ...(toolConfig[id] ? { config: toolConfig[id] } : {}),
+              })),
+              {
+                id: "skill-filesystem",
+                name: "@deepseek-ai/dsh-skill-filesystem",
+                config: {
+                  includeDefaultRoots: userExtensions,
+                  customSkillDirs: [
+                    resolve(plugins, "skills"),
+                    ...host.skillDirectories.map((path) =>
+                      resolve(config.appRoot, path),
+                    ),
+                  ],
+                },
+              },
+              {
+                id: "compaction",
+                name: "cordis:group",
+                group: true,
+                isolate: { compaction: true, toolResultPruner: true },
+                config: [
+                  {
+                    id: "compaction-basic",
+                    name: resolve(plugins, "compaction.mjs"),
+                    config: {
+                      headroomTokens: Math.min(
+                        2048,
+                        Math.floor(config.contextWindow / 8),
+                      ),
+                      maxTokens: Math.min(1024, config.maxOutputTokens),
+                      thresholdRatio: 0.8,
+                      retainRatio: 0.16,
+                      compactionRetries: 0,
+                    },
+                  },
+                  {
+                    id: "tool-result-pruner",
+                    name: "@deepseek-ai/dsh-compaction-tool-result-pruner",
+                    config: {
+                      thresholdChars: 4096,
+                      headChars: 2048,
+                      tailChars: 512,
+                    },
+                  },
+                  {
+                    id: "command-compact",
+                    name: "@deepseek-ai/dsh-command-compact",
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      ],
+    },
+  ];
+}