@vellumai/assistant 0.5.5 → 0.5.7

package/src/__tests__/swarm-router-planner.test.ts

@@ -1,234 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type { Provider, ProviderResponse } from "../providers/types.js";
-import { resolveSwarmLimits } from "../swarm/limits.js";
-import {
-  generatePlan,
-  makeFallbackPlan,
-  parsePlanJSON,
-} from "../swarm/router-planner.js";
-
-const DEFAULT_LIMITS = resolveSwarmLimits({
-  maxWorkers: 3,
-  maxTasks: 8,
-  maxRetriesPerTask: 1,
-  workerTimeoutSec: 900,
-});
-
-function makeProvider(responseText: string): Provider {
-  return {
-    name: "test",
-    async sendMessage(): Promise<ProviderResponse> {
-      return {
-        content: [{ type: "text", text: responseText }],
-        model: "test-model",
-        usage: { inputTokens: 100, outputTokens: 50 },
-        stopReason: "end_turn",
-      };
-    },
-  };
-}
-
-function makeFailingProvider(): Provider {
-  return {
-    name: "test",
-    async sendMessage(): Promise<ProviderResponse> {
-      throw new Error("API error");
-    },
-  };
-}
-
-describe("parsePlanJSON", () => {
-  test("parses bare JSON", () => {
-    const result = parsePlanJSON(
-      '{"tasks":[{"id":"a","role":"coder","objective":"do stuff","dependencies":[]}]}',
-    );
-    expect(result).not.toBeNull();
-    expect(result!.tasks).toHaveLength(1);
-    expect(result!.tasks[0].id).toBe("a");
-  });
-
-  test("parses fenced JSON", () => {
-    const raw =
-      '```json\n{"tasks":[{"id":"a","role":"coder","objective":"do stuff","dependencies":[]}]}\n```';
-    const result = parsePlanJSON(raw);
-    expect(result).not.toBeNull();
-    expect(result!.tasks).toHaveLength(1);
-  });
-
-  test("parses fenced code block without json tag", () => {
-    const raw =
-      '```\n{"tasks":[{"id":"a","role":"coder","objective":"do stuff","dependencies":[]}]}\n```';
-    const result = parsePlanJSON(raw);
-    expect(result).not.toBeNull();
-  });
-
-  test("returns null for invalid JSON", () => {
-    expect(parsePlanJSON("this is not json")).toBeNull();
-  });
-
-  test("returns null for JSON without tasks array", () => {
-    expect(parsePlanJSON('{"plan":"something"}')).toBeNull();
-  });
-
-  test("returns null for empty string", () => {
-    expect(parsePlanJSON("")).toBeNull();
-  });
-
-  test("finds plan JSON in second fenced block when first is not valid JSON", () => {
-    const raw =
-      '```\nHere is my thinking about the plan\n```\n\n```json\n{"tasks":[{"id":"a","role":"coder","objective":"do stuff","dependencies":[]}]}\n```';
-    const result = parsePlanJSON(raw);
-    expect(result).not.toBeNull();
-    expect(result!.tasks).toHaveLength(1);
-    expect(result!.tasks[0].id).toBe("a");
-  });
-
-  test("finds plan JSON in second fenced block when first has no tasks array", () => {
-    const raw =
-      '```json\n{"note":"not a plan"}\n```\n\n```json\n{"tasks":[{"id":"b","role":"researcher","objective":"research","dependencies":[]}]}\n```';
-    const result = parsePlanJSON(raw);
-    expect(result).not.toBeNull();
-    expect(result!.tasks[0].id).toBe("b");
-  });
-});
-
-describe("makeFallbackPlan", () => {
-  test("creates single coder task", () => {
-    const plan = makeFallbackPlan("Build a feature");
-    expect(plan.objective).toBe("Build a feature");
-    expect(plan.tasks).toHaveLength(1);
-    expect(plan.tasks[0].role).toBe("coder");
-    expect(plan.tasks[0].id).toBe("fallback-coder");
-    expect(plan.tasks[0].dependencies).toEqual([]);
-  });
-});
-
-describe("generatePlan", () => {
-  test("generates a valid plan from LLM response", async () => {
-    const responseText = JSON.stringify({
-      tasks: [
-        {
-          id: "research",
-          role: "researcher",
-          objective: "Find docs",
-          dependencies: [],
-        },
-        {
-          id: "code",
-          role: "coder",
-          objective: "Implement",
-          dependencies: ["research"],
-        },
-      ],
-    });
-    const plan = await generatePlan({
-      objective: "Build feature X",
-      provider: makeProvider(responseText),
-      modelIntent: "latency-optimized",
-      limits: DEFAULT_LIMITS,
-    });
-    expect(plan.tasks).toHaveLength(2);
-    expect(plan.tasks[0].id).toBe("research");
-    expect(plan.tasks[1].dependencies).toContain("research");
-  });
-
-  test("falls back on invalid LLM JSON", async () => {
-    const plan = await generatePlan({
-      objective: "Build feature X",
-      provider: makeProvider("Sorry, I cannot help with that."),
-      modelIntent: "latency-optimized",
-      limits: DEFAULT_LIMITS,
-    });
-    expect(plan.tasks).toHaveLength(1);
-    expect(plan.tasks[0].id).toBe("fallback-coder");
-  });
-
-  test("falls back when provider throws", async () => {
-    const plan = await generatePlan({
-      objective: "Build feature X",
-      provider: makeFailingProvider(),
-      modelIntent: "latency-optimized",
-      limits: DEFAULT_LIMITS,
-    });
-    expect(plan.tasks).toHaveLength(1);
-    expect(plan.tasks[0].id).toBe("fallback-coder");
-  });
-
-  test("falls back when LLM plan has invalid roles", async () => {
-    const responseText = JSON.stringify({
-      tasks: [
-        {
-          id: "hack",
-          role: "hacker",
-          objective: "Hack stuff",
-          dependencies: [],
-        },
-      ],
-    });
-    const plan = await generatePlan({
-      objective: "Build feature X",
-      provider: makeProvider(responseText),
-      modelIntent: "latency-optimized",
-      limits: DEFAULT_LIMITS,
-    });
-    // Plan validator rejects invalid roles, so generatePlan catches and falls back
-    expect(plan.tasks).toHaveLength(1);
-    expect(plan.tasks[0].id).toBe("fallback-coder");
-  });
-
-  test("falls back when LLM plan has cycles", async () => {
-    const responseText = JSON.stringify({
-      tasks: [
-        { id: "a", role: "coder", objective: "A", dependencies: ["b"] },
-        { id: "b", role: "coder", objective: "B", dependencies: ["a"] },
-      ],
-    });
-    const plan = await generatePlan({
-      objective: "Build feature X",
-      provider: makeProvider(responseText),
-      modelIntent: "latency-optimized",
-      limits: DEFAULT_LIMITS,
-    });
-    expect(plan.tasks).toHaveLength(1);
-    expect(plan.tasks[0].id).toBe("fallback-coder");
-  });
-
-  test("truncates plans exceeding maxTasks", async () => {
-    const tasks = Array.from({ length: 15 }, (_, i) => ({
-      id: `t${i}`,
-      role: "coder",
-      objective: `Task ${i}`,
-      dependencies: [],
-    }));
-    const plan = await generatePlan({
-      objective: "Big feature",
-      provider: makeProvider(JSON.stringify({ tasks })),
-      modelIntent: "latency-optimized",
-      limits: DEFAULT_LIMITS,
-    });
-    expect(plan.tasks.length).toBeLessThanOrEqual(DEFAULT_LIMITS.maxTasks);
-  });
-
-  test("handles response with no text content", async () => {
-    const provider: Provider = {
-      name: "test",
-      async sendMessage(): Promise<ProviderResponse> {
-        return {
-          content: [],
-          model: "test-model",
-          usage: { inputTokens: 0, outputTokens: 0 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-    const plan = await generatePlan({
-      objective: "Build feature",
-      provider,
-      modelIntent: "latency-optimized",
-      limits: DEFAULT_LIMITS,
-    });
-    expect(plan.tasks).toHaveLength(1);
-    expect(plan.tasks[0].id).toBe("fallback-coder");
-  });
-});

package/src/__tests__/swarm-tool.test.ts

@@ -1,185 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — declared before imports that depend on them
-// ---------------------------------------------------------------------------
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    provider: "anthropic",
-    providerOrder: ["anthropic"],
-    swarm: {
-      enabled: true,
-      maxWorkers: 3,
-      maxTasks: 8,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-      roleTimeoutsSec: {},
-      plannerModelIntent: "latency-optimized",
-      synthesizerModelIntent: "quality-optimized",
-    },
-    services: {
-      inference: {
-        mode: "your-own",
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-      },
-      "image-generation": {
-        mode: "your-own",
-        provider: "gemini",
-        model: "gemini-3.1-flash-image-preview",
-      },
-      "web-search": { mode: "your-own", provider: "inference-provider-native" },
-    },
-  }),
-  getSwarmDisabledConfig: () => ({
-    provider: "anthropic",
-    providerOrder: ["anthropic"],
-    swarm: {
-      enabled: false,
-      maxWorkers: 3,
-      maxTasks: 8,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-      roleTimeoutsSec: {},
-      plannerModelIntent: "latency-optimized",
-      synthesizerModelIntent: "quality-optimized",
-    },
-  }),
-}));
-
-// Mock provider registry — returns a mock provider
-const mockProvider = {
-  name: "test",
-  async sendMessage() {
-    return {
-      content: [
-        {
-          type: "text",
-          text: '{"tasks":[{"id":"t1","role":"coder","objective":"Do it","dependencies":[]}]}',
-        },
-      ],
-      model: "test",
-      usage: { inputTokens: 10, outputTokens: 10 },
-      stopReason: "end_turn",
-    };
-  },
-};
-mock.module("../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async () => "test-api-key",
-  getProviderKeyAsync: async () => "test-api-key",
-}));
-
-mock.module("../providers/registry.js", () => ({
-  getProvider: () => mockProvider,
-  getFailoverProvider: () => mockProvider,
-}));
-
-// Mock the Agent SDK to prevent real subprocess spawning
-mock.module("@anthropic-ai/claude-agent-sdk", () => ({
-  query: () => ({
-    async *[Symbol.asyncIterator]() {
-      yield {
-        type: "result" as const,
-        session_id: "test-session",
-        subtype: "success" as const,
-        result:
-          '```json\n{"summary":"Done","artifacts":[],"issues":[],"nextSteps":[]}\n```',
-      };
-    },
-  }),
-}));
-
-import {
-  _resetSwarmActive,
-  swarmDelegateTool,
-} from "../tools/swarm/delegate.js";
-import type { ToolContext } from "../tools/types.js";
-
-function makeContext(overrides?: Partial<ToolContext>): ToolContext {
-  return {
-    conversationId: "test-session",
-    workingDir: "/tmp/test",
-    trustClass: "guardian",
-    onOutput: () => {},
-    ...overrides,
-  } as ToolContext;
-}
-
-describe("swarm_delegate tool", () => {
-  beforeEach(() => {
-    _resetSwarmActive();
-  });
-
-  test("getDefinition returns valid schema", () => {
-    const def = swarmDelegateTool.getDefinition();
-    expect(def.name).toBe("swarm_delegate");
-    const props = (def.input_schema as Record<string, unknown>)
-      .properties as Record<string, unknown>;
-    expect(props.objective).toBeDefined();
-    expect(props.context).toBeDefined();
-    expect(props.max_workers).toBeDefined();
-  });
-
-  test("executes successfully with a simple objective", async () => {
-    const outputs: string[] = [];
-    const result = await swarmDelegateTool.execute(
-      { objective: "Build a simple feature" },
-      makeContext({ onOutput: (text: string) => outputs.push(text) }),
-    );
-
-    expect(result.isError).toBeFalsy();
-    expect(result.content).toBeTruthy();
-    expect(outputs.length).toBeGreaterThan(0);
-  });
-
-  test("blocks nested swarm invocation", async () => {
-    // Simulate active swarm by calling _resetSwarmActive then manually setting it
-    // We test this by running two sequential calls where the first doesn't finish
-    // Actually, we can test by checking the recursion guard directly
-    const result1Promise = swarmDelegateTool.execute(
-      { objective: "First task" },
-      makeContext(),
-    );
-
-    // While first is running, try a second
-    // Since the mock backend resolves instantly, we need to be creative
-    // Let's just verify the guard works by testing post-execution
-    await result1Promise;
-
-    // After completion, the flag should be reset
-    const result2 = await swarmDelegateTool.execute(
-      { objective: "Second task" },
-      makeContext(),
-    );
-    expect(result2.isError).toBeFalsy();
-  });
-
-  test("handles objective with context", async () => {
-    const result = await swarmDelegateTool.execute(
-      { objective: "Build feature", context: "This is a React project" },
-      makeContext(),
-    );
-    expect(result.isError).toBeFalsy();
-  });
-
-  test("short-circuits when signal is already aborted", async () => {
-    const controller = new AbortController();
-    controller.abort();
-    const result = await swarmDelegateTool.execute(
-      { objective: "Should not run" },
-      makeContext({ signal: controller.signal }),
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toBe("Cancelled");
-  });
-});

package/src/__tests__/swarm-worker-backend.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type { WorkerProfile } from "../swarm/worker-backend.js";
-import { getProfilePolicy, roleToProfile } from "../swarm/worker-backend.js";
-
-describe("roleToProfile", () => {
-  test("maps researcher role to researcher profile", () => {
-    expect(roleToProfile("researcher")).toBe("researcher");
-  });
-
-  test("maps coder role to coder profile", () => {
-    expect(roleToProfile("coder")).toBe("coder");
-  });
-
-  test("maps reviewer role to reviewer profile", () => {
-    expect(roleToProfile("reviewer")).toBe("reviewer");
-  });
-
-  test("maps router role to general profile", () => {
-    expect(roleToProfile("router")).toBe("general");
-  });
-});
-
-describe("getProfilePolicy", () => {
-  const READ_ONLY_TOOLS = [
-    "Read",
-    "Glob",
-    "Grep",
-    "WebSearch",
-    "WebFetch",
-    "LS",
-    "Bash(grep *)",
-    "Bash(rg *)",
-    "Bash(find *)",
-  ];
-
-  const WRITE_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit"];
-
-  describe("general profile", () => {
-    const policy = getProfilePolicy("general");
-
-    test("allows read-only tools", () => {
-      for (const tool of READ_ONLY_TOOLS) {
-        expect(policy.allow.has(tool)).toBe(true);
-      }
-    });
-
-    test("has no hard denies", () => {
-      expect(policy.deny.size).toBe(0);
-    });
-
-    test("requires approval for write tools and Bash", () => {
-      for (const tool of WRITE_TOOLS) {
-        expect(policy.approvalRequired.has(tool)).toBe(true);
-      }
-      expect(policy.approvalRequired.has("Bash")).toBe(true);
-    });
-  });
-
-  describe("researcher profile", () => {
-    const policy = getProfilePolicy("researcher");
-
-    test("allows read-only tools", () => {
-      for (const tool of READ_ONLY_TOOLS) {
-        expect(policy.allow.has(tool)).toBe(true);
-      }
-    });
-
-    test("denies write tools and Bash", () => {
-      for (const tool of WRITE_TOOLS) {
-        expect(policy.deny.has(tool)).toBe(true);
-      }
-      expect(policy.deny.has("Bash")).toBe(true);
-    });
-  });
-
-  describe("coder profile", () => {
-    const policy = getProfilePolicy("coder");
-
-    test("allows read-only tools", () => {
-      for (const tool of READ_ONLY_TOOLS) {
-        expect(policy.allow.has(tool)).toBe(true);
-      }
-    });
-
-    test("has no hard denies", () => {
-      expect(policy.deny.size).toBe(0);
-    });
-
-    test("requires approval for write tools and Bash", () => {
-      for (const tool of WRITE_TOOLS) {
-        expect(policy.approvalRequired.has(tool)).toBe(true);
-      }
-      expect(policy.approvalRequired.has("Bash")).toBe(true);
-    });
-  });
-
-  describe("reviewer profile", () => {
-    const policy = getProfilePolicy("reviewer");
-
-    test("allows read-only tools", () => {
-      for (const tool of READ_ONLY_TOOLS) {
-        expect(policy.allow.has(tool)).toBe(true);
-      }
-    });
-
-    test("denies write tools and Bash", () => {
-      for (const tool of WRITE_TOOLS) {
-        expect(policy.deny.has(tool)).toBe(true);
-      }
-      expect(policy.deny.has("Bash")).toBe(true);
-    });
-  });
-
-  test("all profiles allow the same read-only tool set", () => {
-    const profiles: WorkerProfile[] = [
-      "general",
-      "researcher",
-      "coder",
-      "reviewer",
-    ];
-    for (const profile of profiles) {
-      const policy = getProfilePolicy(profile);
-      for (const tool of READ_ONLY_TOOLS) {
-        expect(policy.allow.has(tool)).toBe(true);
-      }
-    }
-  });
-
-  test("denied tools are never also in allow set", () => {
-    const profiles: WorkerProfile[] = [
-      "general",
-      "researcher",
-      "coder",
-      "reviewer",
-    ];
-    for (const profile of profiles) {
-      const policy = getProfilePolicy(profile);
-      for (const tool of policy.deny) {
-        expect(policy.allow.has(tool)).toBe(false);
-      }
-    }
-  });
-});