create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/plugins/tool-catalog/discovery.mjs

@@ -0,0 +1,245 @@
+import { displayMetadata } from "./presentation.mjs";
+import { createScope } from "@deepseek-ai/dsh-scope";
+import { NativeToolExecutor } from "@deepseek-ai/dsh-tool-executor-native";
+export const DISCOVER = "discover_business_tools";
+const PREFIX = "mcp__windy__";
+export function businessTools(ctx, scope) {
+  return ctx.tools
+    .schemas(scope)
+    .filter((tool) => tool.name.startsWith(PREFIX))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function catalogue(
+  ctx,
+  {
+    query = "",
+    page = 1,
+    includeNative = false,
+    scope,
+    metadata,
+    pageSize = 20,
+    category = "",
+  } = {},
+) {
+  const terms = String(query).trim().toLowerCase().split(/\s+/).filter(Boolean);
+  const available = new Map(
+    businessTools(ctx, scope).map((tool) => [tool.name, tool]),
+  );
+  if (includeNative) {
+    for (const tool of ctx.tools.schemas()) available.set(tool.name, tool);
+    for (const agent of ctx.agents.list()) {
+      for (const tool of ctx.tools.schemas(agent))
+        available.set(tool.name, tool);
+    }
+  }
+  const all = [...available.values()]
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map((tool) => ({
+      name: tool.name,
+      ...displayMetadata(tool, metadata),
+      description: tool.description.slice(0, 240),
+      strategy: tool.name.startsWith(PREFIX) ? "on-demand" : "default",
+      source: tool.name.startsWith(PREFIX) ? "business-mcp" : "dsh",
+    }));
+  if (category && !all.some((tool) => tool.categoryKey === category))
+    throw new Error("TOOL_CATEGORY_NOT_IN_AUTHORIZED_CATALOGUE");
+  const matched = all.filter((tool) => {
+    const text =
+      `${tool.name} ${available.get(tool.name)?.description ?? ""} ${tool.displayName} ${tool.summary} ${tool.categoryLabel}`.toLowerCase();
+    return terms.every((term) => text.includes(term));
+  });
+  const groups = new Map();
+  for (const tool of matched) {
+    const group = groups.get(tool.categoryKey);
+    if (group) group.count++;
+    else
+      groups.set(tool.categoryKey, {
+        categoryKey: tool.categoryKey,
+        categoryLabel: tool.categoryLabel,
+        count: 1,
+      });
+  }
+  const items = matched.filter(
+    (tool) => !category || tool.categoryKey === category,
+  );
+  return {
+    total: items.length,
+    matchedTotal: matched.length,
+    category,
+    groups: [...groups.values()].sort((a, b) =>
+      a.categoryLabel.localeCompare(b.categoryLabel, "zh-CN"),
+    ),
+    page,
+    pageSize,
+    items: items.slice((page - 1) * pageSize, page * pageSize),
+  };
+}
+function discoveryDefinition(ctx, state, metadata) {
+  const all = businessTools(ctx, state.agent);
+  const preview = all
+    .slice(0, 12)
+    .map((tool) => `${tool.name}: ${tool.description.slice(0, 64)}`)
+    .join("\n")
+    .slice(0, 1600);
+  return {
+    name: DISCOVER,
+    description: `发现并按需加载Windy业务工具。先用 query 按业务关键词或工具名搜索目录（每页20项），可从groups返回的categoryKey选择category按业务模块筛选；使用简短关键词如“案件”“通联”，不要复制整句问题；无命中时缩短关键词或留空翻页。再用 names 选择最多8个工具加载完整参数；后续直接调用这些工具。不得猜工具名或提供身份、权限。当前目录共${all.length}项，以下仅为前12项预览，其余请搜索或翻页：\n${preview}`,
+    presentCall: () => ({
+      card: "generic",
+      title: "查找业务工具",
+      kind: "search",
+    }),
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        query: {
+          type: "string",
+          maxLength: 120,
+          description: "按工具名称或说明搜索，可为空。",
+        },
+        page: { type: "integer", minimum: 1, maximum: 1000 },
+        category: {
+          type: "string",
+          maxLength: 128,
+          description:
+            "从目录groups原样选择categoryKey；省略或空字符串表示全部。",
+        },
+        names: {
+          type: "array",
+          maxItems: 8,
+          uniqueItems: true,
+          items: { type: "string", maxLength: 128 },
+          description: "从目录原样选择工具名，替换本 Agent 已加载的业务工具。",
+        },
+      },
+    },
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }],
+    },
+    async execute(args, execution) {
+      execution.signal.throwIfAborted();
+      if (
+        !args ||
+        typeof args !== "object" ||
+        Array.isArray(args) ||
+        Object.keys(args).some(
+          (key) => !["query", "page", "names", "category"].includes(key),
+        ) ||
+        (args.query !== undefined &&
+          (typeof args.query !== "string" || args.query.length > 120)) ||
+        (args.category !== undefined &&
+          (typeof args.category !== "string" || args.category.length > 128)) ||
+        (args.page !== undefined &&
+          (!Number.isInteger(args.page) || args.page < 1 || args.page > 1000))
+      )
+        throw new Error("TOOL_DISCOVERY_INPUT_INVALID");
+      const listing = catalogue(ctx, { ...args, scope: state.agent, metadata });
+      if (args.names !== undefined) {
+        if (
+          !Array.isArray(args.names) ||
+          args.names.length > 8 ||
+          new Set(args.names).size !== args.names.length ||
+          args.names.some(
+            (name) =>
+              typeof name !== "string" ||
+              !name.startsWith(PREFIX) ||
+              !ctx.tools.get(name, state.agent),
+          )
+        )
+          throw new Error("TOOL_NOT_IN_AUTHORIZED_CATALOGUE");
+        state.selected = new Set(args.names);
+        state.refresh();
+      }
+      return {
+        ...listing,
+        loaded: [...state.selected],
+        loadedTools: [...state.selected].map((name) => ({
+          name,
+          displayName: displayMetadata(
+            ctx.tools.get(name, state.agent),
+            metadata,
+          ).displayName,
+        })),
+      };
+    },
+  };
+}
+/** Keep upstream registry restrictions intact; only the model assembly is narrowed. */
+export function installDiscovery(ctx, metadata = new Map()) {
+  const states = new Map();
+  let updating = false;
+  function synchronize(state) {
+    if (updating) return;
+    updating = true;
+    try {
+      for (const name of state.selected) {
+        if (!ctx.tools.get(name, state.agent)) state.selected.delete(name);
+      }
+      state.unregister?.();
+      state.unregister = state.scope.ctx.tools.register(
+        discoveryDefinition(ctx, state, metadata),
+      );
+    } finally {
+      updating = false;
+    }
+  }
+  function attach(agent) {
+    if (states.has(agent)) return;
+    const state = {
+      agent,
+      scope: createScope(ctx, agent),
+      selected: new Set(),
+      refresh: () => synchronize(state),
+    };
+    const executor = new NativeToolExecutor(state.scope.ctx);
+    state.scope.ctx.tools.setExecutor({
+      describe(tools) {
+        return executor.describe(
+          tools.filter(
+            (tool) =>
+              !tool.name.startsWith(PREFIX) || state.selected.has(tool.name),
+          ),
+        );
+      },
+      execute: (input) => executor.execute(input),
+    });
+    states.set(agent, state);
+    state.refresh();
+  }
+  ctx.on("agent/created", ({ agent }) => attach(agent));
+  ctx.on("agent/disposed", ({ agent }) => {
+    const state = states.get(agent);
+    states.delete(agent);
+    if (state) {
+      state.unregister?.();
+      void state.scope.dispose();
+    }
+  });
+  ctx.on("tools/change", () => {
+    if (!updating) for (const state of states.values()) state.refresh();
+  });
+  ctx.on("agent/pre-step", async ({ agent }, next) => {
+    attach(agent);
+    states.get(agent).refresh();
+    return next();
+  });
+  // The original MCP definition and every upstream scope restriction remain authoritative.
+  // This guard only denies unloaded calls; it cannot force-allow any upstream denial.
+  ctx.tools.guard((execution) => {
+    if (
+      execution.name.startsWith(PREFIX) &&
+      !states.get(execution.agent)?.selected.has(execution.name)
+    )
+      return "TOOL_NOT_LOADED_DISCOVER_FIRST";
+  });
+  for (const agent of ctx.agents.list()) attach(agent);
+  ctx.effect(() => async () => {
+    updating = true;
+    const owned = [...states.values()];
+    for (const state of owned) state.unregister?.();
+    await Promise.all(owned.map((state) => state.scope.dispose()));
+    states.clear();
+  });
+}

package/template/apps/agent-server/plugins/tool-catalog/discovery.test.ts

@@ -0,0 +1,291 @@
+import { afterEach, expect, test } from "bun:test";
+import { Context } from "@deepseek-ai/cordis";
+import SystemPrompt from "@deepseek-ai/dsh-system-prompt";
+import ToolRuntime from "@deepseek-ai/dsh-tools";
+import * as NativeToolExecutor from "@deepseek-ai/dsh-tool-executor-native";
+import { createScope } from "@deepseek-ai/dsh-scope";
+import { createMcpToolDefinition } from "@deepseek-ai/dsh-mcp-client";
+import { ToolCallId } from "@deepseek-ai/dsh-llm";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { catalogue, DISCOVER, installDiscovery } from "./discovery.mjs";
+const cleanups: (() => Promise<unknown>)[] = [];
+afterEach(async () => {
+  for (const close of cleanups.splice(0).reverse()) await close();
+});
+async function toolScope(ctx: Context, agent: Agent) {
+  let scope!: ReturnType<typeof createScope>;
+  const fiber = ctx.plugin({
+    name: "fixture-tool-scope",
+    inject: ["tools"],
+    apply(pluginCtx: Context) {
+      scope = createScope(pluginCtx, agent);
+    },
+  });
+  await fiber.await();
+  cleanups.push(() => fiber.dispose());
+  return scope;
+}
+async function fixture(count = 76) {
+  const ctx = new Context();
+  const prompt = ctx.plugin(SystemPrompt, {
+    includeHarnessIdentity: false,
+    includeRuntimeContext: false,
+  });
+  await prompt.await();
+  const runtime = ctx.plugin(ToolRuntime);
+  await runtime.await();
+  const executor = ctx.plugin(NativeToolExecutor);
+  await executor.await();
+  cleanups.push(async () => {
+    await executor.dispose();
+    await runtime.dispose();
+    await prompt.dispose();
+  });
+  const agent = { ctx } as unknown as Agent;
+  const other = { ctx } as unknown as Agent;
+  const firstScope = createScope(ctx, agent),
+    secondScope = createScope(ctx, other);
+  Object.assign(agent, { ctx: firstScope.ctx });
+  Object.assign(other, { ctx: secondScope.ctx });
+  cleanups.push(async () => {
+    await secondScope.dispose();
+    await firstScope.dispose();
+  });
+  ctx.provide("agents", { list: () => [agent, other] } as never);
+  let authorized = true;
+  const calls: string[] = [],
+    disposers: (() => void)[] = [];
+  for (let i = 0; i < count; i++) {
+    const name = `mcp__windy__case_${String(i).padStart(3, "0")}`;
+    disposers.push(
+      ctx.tools.register(
+        createMcpToolDefinition(ctx, {
+          name,
+          rawName: name,
+          description: `案件查询 ${i}`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              keyword: { type: "string", description: "a".repeat(400) },
+            },
+            additionalProperties: false,
+          },
+          call: async () => {
+            if (!authorized) throw new Error("RBAC_REVOKED");
+            calls.push(name);
+            return { content: [{ type: "text", text: "authorized-data" }] };
+          },
+        }),
+      ),
+    );
+  }
+  const discovery = ctx.plugin({
+    name: "test-discovery",
+    inject: ["tools", "agents"],
+    apply: installDiscovery,
+  });
+  await discovery.await();
+  cleanups.push(() => discovery.dispose());
+  const execute = async (name: string, args: unknown, subject = agent) => {
+    const signal = new AbortController().signal;
+    const toolSet = await ctx.tools.resolve({
+      agent: subject,
+      modelSelection: { provider: "fixture", model: "fixture" },
+      signal,
+    });
+    try {
+      const { results } = await ctx.tools.execute({
+        calls: [
+          {
+            type: "tool-call",
+            name,
+            arguments: JSON.stringify(args),
+            id: ToolCallId(crypto.randomUUID()),
+          },
+        ],
+        agent: subject,
+        signal,
+        toolSet,
+      });
+      return results[0]!.result;
+    } finally {
+      toolSet.dispose();
+    }
+  };
+  return {
+    ctx,
+    agent,
+    other,
+    execute,
+    calls,
+    disposers,
+    revoke: () => {
+      authorized = false;
+    },
+  };
+}
+test("76 MCP schemas stay outside the first request; discovery loads only selected tools in one Agent", async () => {
+  const f = await fixture();
+  const first = (await f.ctx.systemPrompt.assemble({ scope: f.agent })).tools;
+  expect(first.map((tool) => tool.name)).toEqual([DISCOVER]);
+  expect(JSON.stringify(first).length).toBeLessThan(5000);
+  expect(JSON.stringify(first)).not.toContain("a".repeat(400));
+  const categorized = await f.execute(DISCOVER, {
+    category: "business",
+    page: 2,
+  });
+  expect(categorized.isError).toBe(false);
+  expect(categorized.value).toMatchObject({
+    total: 76,
+    matchedTotal: 76,
+    category: "business",
+    groups: [{ categoryKey: "business", categoryLabel: "业务工具", count: 76 }],
+  });
+  expect(
+    (
+      await f.execute(DISCOVER, {
+        category: "not-authorized",
+        names: ["mcp__windy__case_003"],
+      })
+    ).isError,
+  ).toBe(true);
+  expect(
+    (await f.ctx.systemPrompt.assemble({ scope: f.agent })).tools.map(
+      (tool) => tool.name,
+    ),
+  ).toEqual([DISCOVER]);
+  const listing = await f.execute(DISCOVER, { query: "案件", page: 2 });
+  expect(listing.isError).toBe(false);
+  expect((listing.value as { total: number }).total).toBe(76);
+  expect((listing.value as { page: number }).page).toBe(2);
+  expect((listing.value as { items: unknown[] }).items).toHaveLength(20);
+  const chosen = "mcp__windy__case_003";
+  expect((await f.execute(DISCOVER, { names: [chosen] })).isError).toBe(false);
+  expect(
+    (await f.ctx.systemPrompt.assemble({ scope: f.agent })).tools
+      .map((tool) => tool.name)
+      .sort(),
+  ).toEqual([DISCOVER, chosen].sort());
+  expect(
+    (await f.ctx.systemPrompt.assemble({ scope: f.other })).tools.map(
+      (tool) => tool.name,
+    ),
+  ).toEqual([DISCOVER]);
+  expect((await f.execute(chosen, {})).isError).toBe(false);
+  expect(f.calls).toEqual([chosen]);
+  f.revoke();
+  expect((await f.execute(chosen, {})).isError).toBe(true);
+  expect(f.calls).toEqual([chosen]);
+});
+test("unknown names, authority arguments, and removed generations cannot expand tools", async () => {
+  const f = await fixture(2);
+  expect(
+    (await f.execute(DISCOVER, { names: ["mcp__windy__not_authorized"] }))
+      .isError,
+  ).toBe(true);
+  expect(
+    (
+      await f.execute(DISCOVER, {
+        actor: "admin",
+        names: ["mcp__windy__case_000"],
+      })
+    ).isError,
+  ).toBe(true);
+  expect((await f.execute("mcp__windy__case_000", {})).isError).toBe(true);
+  await f.execute(DISCOVER, { names: ["mcp__windy__case_000"] });
+  f.disposers[0]!();
+  expect(
+    (await f.ctx.systemPrompt.assemble({ scope: f.agent })).tools.map(
+      (tool) => tool.name,
+    ),
+  ).toEqual([DISCOVER]);
+  expect((await f.execute("mcp__windy__case_000", {})).isError).toBe(true);
+  expect(catalogue(f.ctx).total).toBe(1);
+  expect(f.calls).toEqual([]);
+});
+test("settings catalogue combines the current MCP generation and scope-owned native tools", async () => {
+  const f = await fixture(1);
+  const scoped = await toolScope(f.ctx, f.agent);
+  const unregister = scoped.ctx.tools.register({
+    name: "local_read",
+    description: "Read current workspace",
+    parameters: { type: "object" },
+    output: { schema: { type: "object" }, render: () => [] },
+    execute: async () => ({}),
+  });
+  const list = catalogue(f.ctx, { includeNative: true });
+  expect(list.items.find((tool) => tool.name === "local_read")).toMatchObject({
+    name: "local_read",
+    description: "Read current workspace",
+    strategy: "default",
+    source: "dsh",
+  });
+  expect(
+    list.items.find((tool) => tool.name.startsWith("mcp__")),
+  ).toMatchObject({ strategy: "on-demand", source: "business-mcp" });
+  unregister();
+  expect(
+    catalogue(f.ctx, { includeNative: true }).items.some(
+      (tool) => tool.name === "local_read",
+    ),
+  ).toBe(false);
+});
+
+test("loading cannot bypass an existing Agent tool restriction", async () => {
+  const f = await fixture(2);
+  const policy = await toolScope(f.ctx, f.agent);
+  const denied = "mcp__windy__case_001";
+  policy.ctx.tools.restrict({ deny: [denied] });
+  expect(
+    catalogue(f.ctx, { scope: f.agent }).items.some(
+      (tool) => tool.name === denied,
+    ),
+  ).toBe(false);
+  expect((await f.execute(DISCOVER, { names: [denied] })).isError).toBe(true);
+  expect((await f.execute(denied, {})).isError).toBe(true);
+  const allowed = "mcp__windy__case_000";
+  expect((await f.execute(DISCOVER, { names: [allowed] })).isError).toBe(false);
+  expect((await f.execute(allowed, {})).isError).toBe(false);
+  expect(f.calls).toEqual([allowed]);
+  await policy.dispose();
+});
+
+test("discovery selection cannot bypass upstream step admission", async () => {
+  const f = await fixture(0);
+  const name = "mcp__windy__conditional";
+  let calls = 0;
+  const unregister = f.ctx.tools.register(
+    {
+      name,
+      description: "Conditional business tool",
+      parameters: { type: "object" },
+      output: { schema: { type: "object" }, render: () => [] },
+      execute: async () => {
+        calls++;
+        return {};
+      },
+    },
+    { when: () => false },
+  );
+  try {
+    expect((await f.execute(DISCOVER, { names: [name] })).isError).toBe(false);
+    const toolSet = await f.ctx.tools.resolve({
+      agent: f.agent,
+      modelSelection: { provider: "fixture", model: "fixture" },
+      signal: new AbortController().signal,
+    });
+    try {
+      const assembly = await f.ctx.systemPrompt.assemble({
+        scope: f.agent,
+        toolSet,
+      });
+      expect(assembly.tools.map((tool) => tool.name)).toEqual([DISCOVER]);
+    } finally {
+      toolSet.dispose();
+    }
+    expect((await f.execute(name, {})).isError).toBe(true);
+    expect(calls).toBe(0);
+  } finally {
+    unregister();
+  }
+});

package/template/apps/agent-server/plugins/tool-catalog/index.d.mts

@@ -0,0 +1,5 @@
+import type { Context } from "@deepseek-ai/cordis";
+export const name: string;
+export const inject: string[];
+export function apply(ctx: Context): void;
+export type { ToolDisplayMetadata } from "./presentation.mjs";

package/template/apps/agent-server/plugins/tool-catalog/index.mjs

@@ -0,0 +1,91 @@
+import { readFileSync } from "node:fs";
+import { loadToolMetadata } from "./presentation.mjs";
+import { catalogue, installDiscovery } from "./discovery.mjs";
+export const name = "windy-tool-catalog";
+export const inject = ["tools", "agents", "webServer", "connection"];
+const styles = readFileSync(new URL("./style.css", import.meta.url), "utf8");
+export function apply(ctx) {
+  const metadata = new Map(),
+    lifetime = new AbortController();
+  let pending,
+    refreshedAt = 0;
+  const refreshMetadata = () => {
+    if (Date.now() - refreshedAt < 15000) return Promise.resolve();
+    return (pending ??= loadToolMetadata(lifetime.signal)
+      .then((next) => {
+        metadata.clear();
+        for (const [name, value] of next) metadata.set(name, value);
+        refreshedAt = Date.now();
+      })
+      .catch(() => {})
+      .finally(() => {
+        pending = undefined;
+      }));
+  };
+  ctx.effect(() => () => lifetime.abort());
+  void refreshMetadata();
+  installDiscovery(ctx, metadata);
+  ctx.on("webserver/index-inject", (table) => {
+    table.push({ kind: "style", text: styles });
+    table.push({
+      kind: "global",
+      name: "__WINDY_TOOL_DISPLAY__",
+      value: catalogue(ctx, { includeNative: true, metadata, pageSize: 512 })
+        .items,
+    });
+  });
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: "exact",
+        path: "/windy/tool-catalog",
+        async handler(request, response) {
+          const denied = ctx.connection.requestRejection(request);
+          if (denied || request.method !== "GET") {
+            response.writeHead(denied || 405);
+            response.end();
+            return;
+          }
+          const url = new URL(request.url, "http://native.invalid");
+          const page = Number(url.searchParams.get("page") || 1);
+          const query = url.searchParams.get("query") || "";
+          const category = url.searchParams.get("category") || "";
+          if (
+            !Number.isInteger(page) ||
+            page < 1 ||
+            page > 1000 ||
+            query.length > 120 ||
+            category.length > 128
+          ) {
+            response.writeHead(400);
+            response.end();
+            return;
+          }
+          await refreshMetadata();
+          let listing;
+          try {
+            listing = catalogue(ctx, {
+              page,
+              query,
+              category,
+              includeNative: true,
+              metadata,
+              pageSize: url.searchParams.get("display") === "all" ? 512 : 20,
+            });
+          } catch (error) {
+            if (error?.message !== "TOOL_CATEGORY_NOT_IN_AUTHORIZED_CATALOGUE")
+              throw error;
+            response.writeHead(400);
+            response.end();
+            return;
+          }
+          response.writeHead(200, {
+            "content-type": "application/json",
+            "cache-control": "no-store",
+          });
+          response.end(JSON.stringify(listing));
+        },
+      }),
+    "windy.tool-catalog",
+  );
+}

package/template/apps/agent-server/plugins/tool-catalog/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@southwind-ai/dsh-tool-catalog",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./index.mjs",
+    "./client": "./client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ]
+    }
+  }
+}

package/template/apps/agent-server/plugins/tool-catalog/presentation.d.mts

@@ -0,0 +1,21 @@
+export interface ToolDisplayMetadata {
+  displayName: string;
+  description?: string;
+  moduleKey?: string;
+  moduleLabel?: string;
+}
+export function publicMcpName(rawName: string): string;
+export function displayMetadata(
+  tool: { name: string; description?: string },
+  metadata?: Map<string, ToolDisplayMetadata>,
+): {
+  displayName: string;
+  summary: string;
+  sourceLabel: string;
+  strategyLabel: string;
+  categoryKey: string;
+  categoryLabel: string;
+};
+export function loadToolMetadata(
+  signal?: AbortSignal,
+): Promise<Map<string, ToolDisplayMetadata>>;