@vellumai/assistant 0.5.5 → 0.5.7

package/src/__tests__/swarm-plan-validator.test.ts

@@ -1,384 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type { SwarmPlan } from "../swarm/index.js";
-import {
-  resolveSwarmLimits,
-  SwarmPlanValidationError,
-  validateAndNormalizePlan,
-} from "../swarm/index.js";
-
-const DEFAULT_LIMITS = resolveSwarmLimits({
-  maxWorkers: 3,
-  maxTasks: 8,
-  maxRetriesPerTask: 1,
-  workerTimeoutSec: 900,
-});
-
-function makePlan(overrides?: Partial<SwarmPlan>): SwarmPlan {
-  return {
-    objective: "Test objective",
-    tasks: [
-      {
-        id: "task-1",
-        role: "coder",
-        objective: "Write code",
-        dependencies: [],
-      },
-    ],
-    ...overrides,
-  };
-}
-
-describe("validateAndNormalizePlan", () => {
-  test("accepts a valid single-task plan", () => {
-    const plan = makePlan();
-    const result = validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-    expect(result.tasks).toHaveLength(1);
-    expect(result.tasks[0].id).toBe("task-1");
-  });
-
-  test("accepts a valid multi-task DAG", () => {
-    const plan = makePlan({
-      tasks: [
-        {
-          id: "research",
-          role: "researcher",
-          objective: "Research",
-          dependencies: [],
-        },
-        {
-          id: "code",
-          role: "coder",
-          objective: "Code",
-          dependencies: ["research"],
-        },
-        {
-          id: "review",
-          role: "reviewer",
-          objective: "Review",
-          dependencies: ["code"],
-        },
-      ],
-    });
-    const result = validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-    expect(result.tasks).toHaveLength(3);
-  });
-
-  test("accepts parallel independent tasks", () => {
-    const plan = makePlan({
-      tasks: [
-        { id: "a", role: "coder", objective: "Task A", dependencies: [] },
-        { id: "b", role: "coder", objective: "Task B", dependencies: [] },
-        {
-          id: "c",
-          role: "reviewer",
-          objective: "Review both",
-          dependencies: ["a", "b"],
-        },
-      ],
-    });
-    const result = validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-    expect(result.tasks).toHaveLength(3);
-  });
-
-  test("rejects empty tasks array", () => {
-    expect(() =>
-      validateAndNormalizePlan(makePlan({ tasks: [] }), DEFAULT_LIMITS),
-    ).toThrow(SwarmPlanValidationError);
-  });
-
-  test("rejects duplicate task IDs", () => {
-    const plan = makePlan({
-      tasks: [
-        { id: "dup", role: "coder", objective: "A", dependencies: [] },
-        { id: "dup", role: "coder", objective: "B", dependencies: [] },
-      ],
-    });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false); // should not reach here
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      expect((e as SwarmPlanValidationError).issues).toContainEqual(
-        expect.stringContaining("Duplicate task id"),
-      );
-    }
-  });
-
-  test("rejects invalid role", () => {
-    const plan = makePlan({
-      tasks: [
-        {
-          id: "bad",
-          role: "hacker" as any,
-          objective: "Hack",
-          dependencies: [],
-        },
-      ],
-    });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      expect((e as SwarmPlanValidationError).issues).toContainEqual(
-        expect.stringContaining("invalid role"),
-      );
-    }
-  });
-
-  test("rejects unknown dependency reference", () => {
-    const plan = makePlan({
-      tasks: [
-        {
-          id: "a",
-          role: "coder",
-          objective: "A",
-          dependencies: ["nonexistent"],
-        },
-      ],
-    });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      expect((e as SwarmPlanValidationError).issues).toContainEqual(
-        expect.stringContaining('unknown task "nonexistent"'),
-      );
-    }
-  });
-
-  test("detects simple cycle (A -> B -> A)", () => {
-    const plan = makePlan({
-      tasks: [
-        { id: "a", role: "coder", objective: "A", dependencies: ["b"] },
-        { id: "b", role: "coder", objective: "B", dependencies: ["a"] },
-      ],
-    });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      expect((e as SwarmPlanValidationError).issues).toContainEqual(
-        expect.stringContaining("cycle"),
-      );
-    }
-  });
-
-  test("detects self-cycle", () => {
-    const plan = makePlan({
-      tasks: [{ id: "a", role: "coder", objective: "A", dependencies: ["a"] }],
-    });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      expect((e as SwarmPlanValidationError).issues).toContainEqual(
-        expect.stringContaining("cycle"),
-      );
-    }
-  });
-
-  test("detects longer cycle (A -> B -> C -> A)", () => {
-    const plan = makePlan({
-      tasks: [
-        { id: "a", role: "coder", objective: "A", dependencies: ["c"] },
-        { id: "b", role: "coder", objective: "B", dependencies: ["a"] },
-        { id: "c", role: "coder", objective: "C", dependencies: ["b"] },
-      ],
-    });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      expect((e as SwarmPlanValidationError).issues).toContainEqual(
-        expect.stringContaining("cycle"),
-      );
-    }
-  });
-
-  test("truncates tasks exceeding maxTasks limit", () => {
-    const tasks = Array.from({ length: 12 }, (_, i) => ({
-      id: `t${i}`,
-      role: "coder" as const,
-      objective: `Task ${i}`,
-      dependencies: [] as string[],
-    }));
-    const plan = makePlan({ tasks });
-    // Use a limit of 5
-    const limits = resolveSwarmLimits({
-      maxWorkers: 3,
-      maxTasks: 5,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-    });
-    const result = validateAndNormalizePlan(plan, limits);
-    expect(result.tasks).toHaveLength(5);
-    expect(result.tasks[0].id).toBe("t0");
-    expect(result.tasks[4].id).toBe("t4");
-  });
-
-  test("strips dependencies that point to tasks removed by truncation", () => {
-    const plan = makePlan({
-      tasks: [
-        { id: "t0", role: "coder", objective: "Task 0", dependencies: [] },
-        { id: "t1", role: "coder", objective: "Task 1", dependencies: ["t4"] },
-        {
-          id: "t2",
-          role: "reviewer",
-          objective: "Task 2",
-          dependencies: ["t0"],
-        },
-        { id: "t3", role: "coder", objective: "Task 3", dependencies: [] },
-        { id: "t4", role: "coder", objective: "Task 4", dependencies: [] },
-      ],
-    });
-    const limits = resolveSwarmLimits({
-      maxWorkers: 3,
-      maxTasks: 3,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-    });
-
-    const result = validateAndNormalizePlan(plan, limits);
-    expect(result.tasks).toHaveLength(3);
-    const t1 = result.tasks.find((task) => task.id === "t1");
-    expect(t1?.dependencies).toEqual([]);
-  });
-
-  test("rejects empty objective", () => {
-    const plan = makePlan({ objective: "" });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      expect((e as SwarmPlanValidationError).issues).toContainEqual(
-        expect.stringContaining("objective"),
-      );
-    }
-  });
-
-  test("normalizes missing dependencies to empty array", () => {
-    const plan: SwarmPlan = {
-      objective: "Test",
-      tasks: [
-        {
-          id: "a",
-          role: "coder",
-          objective: "A",
-          dependencies: undefined as any,
-        },
-      ],
-    };
-    const result = validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-    expect(result.tasks[0].dependencies).toEqual([]);
-  });
-
-  test("collects multiple issues in a single error", () => {
-    const plan = makePlan({
-      objective: "",
-      tasks: [
-        {
-          id: "a",
-          role: "invalid" as any,
-          objective: "A",
-          dependencies: ["nonexistent"],
-        },
-        { id: "a", role: "coder", objective: "B", dependencies: [] },
-      ],
-    });
-    try {
-      validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(true).toBe(false);
-    } catch (e) {
-      expect(e).toBeInstanceOf(SwarmPlanValidationError);
-      const err = e as SwarmPlanValidationError;
-      // Should have at least 3 issues: empty objective, invalid role, duplicate id
-      expect(err.issues.length).toBeGreaterThanOrEqual(3);
-    }
-  });
-
-  test("accepts all valid roles", () => {
-    const roles = ["router", "researcher", "coder", "reviewer"] as const;
-    for (const role of roles) {
-      const plan = makePlan({
-        tasks: [
-          {
-            id: `task-${role}`,
-            role,
-            objective: `${role} task`,
-            dependencies: [],
-          },
-        ],
-      });
-      const result = validateAndNormalizePlan(plan, DEFAULT_LIMITS);
-      expect(result.tasks[0].role).toBe(role);
-    }
-  });
-});
-
-describe("resolveSwarmLimits", () => {
-  test("clamps maxWorkers to hard ceiling", () => {
-    const limits = resolveSwarmLimits({
-      maxWorkers: 100,
-      maxTasks: 8,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-    });
-    expect(limits.maxWorkers).toBe(6);
-  });
-
-  test("clamps maxTasks to hard ceiling", () => {
-    const limits = resolveSwarmLimits({
-      maxWorkers: 3,
-      maxTasks: 100,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-    });
-    expect(limits.maxTasks).toBe(20);
-  });
-
-  test("clamps maxRetriesPerTask to hard ceiling", () => {
-    const limits = resolveSwarmLimits({
-      maxWorkers: 3,
-      maxTasks: 8,
-      maxRetriesPerTask: 100,
-      workerTimeoutSec: 900,
-    });
-    expect(limits.maxRetriesPerTask).toBe(3);
-  });
-
-  test("clamps zero/negative values to minimums", () => {
-    const limits = resolveSwarmLimits({
-      maxWorkers: 0,
-      maxTasks: -1,
-      maxRetriesPerTask: -5,
-      workerTimeoutSec: 0,
-    });
-    expect(limits.maxWorkers).toBe(1);
-    expect(limits.maxTasks).toBe(1);
-    expect(limits.maxRetriesPerTask).toBe(0);
-    expect(limits.workerTimeoutSec).toBe(1);
-  });
-
-  test("passes through valid values unchanged", () => {
-    const limits = resolveSwarmLimits({
-      maxWorkers: 3,
-      maxTasks: 8,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-    });
-    expect(limits).toEqual({
-      maxWorkers: 3,
-      maxTasks: 8,
-      maxRetriesPerTask: 1,
-      workerTimeoutSec: 900,
-      roleTimeoutsSec: {},
-    });
-  });
-});

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

@@ -1,197 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Gate that the SDK mock waits on, letting us hold a swarm active while
-// attempting a second invocation.
-// ---------------------------------------------------------------------------
-
-let gate: { promise: Promise<void>; resolve: () => void } | null = null;
-
-function openGate() {
-  let resolve!: () => void;
-  const promise = new Promise<void>((r) => {
-    resolve = r;
-  });
-  gate = { promise, resolve };
-}
-
-function closeGate() {
-  gate?.resolve();
-  gate = null;
-}
-
-// ---------------------------------------------------------------------------
-// Mocks — declared before imports
-// ---------------------------------------------------------------------------
-
-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" },
-    },
-  }),
-}));
-
-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.module("@anthropic-ai/claude-agent-sdk", () => ({
-  query: () => ({
-    async *[Symbol.asyncIterator]() {
-      // If a gate is open, wait on it — this holds the swarm active
-      if (gate) await gate.promise;
-      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-conv",
-    workingDir: "/tmp/test",
-    trustClass: "guardian",
-    onOutput: () => {},
-    ...overrides,
-  } as ToolContext;
-}
-
-describe("swarm recursion guard (concurrent)", () => {
-  beforeEach(() => {
-    _resetSwarmActive();
-    closeGate();
-  });
-
-  test("rejects second invocation on same session while first is still active", async () => {
-    openGate();
-
-    // Start first swarm — it will pause at the SDK mock
-    const first = swarmDelegateTool.execute(
-      { objective: "First task" },
-      makeContext({ conversationId: "session-A" }),
-    );
-
-    // Yield to let first reach the SDK gate (executeSwarm path)
-    await new Promise((r) => setTimeout(r, 50));
-
-    // Second invocation on the same session should be rejected
-    const second = await swarmDelegateTool.execute(
-      { objective: "Second task" },
-      makeContext({ conversationId: "session-A" }),
-    );
-    expect(second.isError).toBe(true);
-    expect(second.content).toContain("already executing");
-
-    // Release the gate so first completes
-    closeGate();
-    const firstResult = await first;
-    expect(firstResult.isError).toBeFalsy();
-  });
-
-  test("allows concurrent swarms on different sessions", async () => {
-    openGate();
-
-    // Start first swarm on session A
-    const first = swarmDelegateTool.execute(
-      { objective: "Conversation A task" },
-      makeContext({ conversationId: "session-A" }),
-    );
-
-    // Yield to let first reach the gate
-    await new Promise((r) => setTimeout(r, 50));
-
-    // Release the gate before starting session B so both can complete
-    closeGate();
-
-    // Second swarm on a different session should succeed
-    const second = await swarmDelegateTool.execute(
-      { objective: "Conversation B task" },
-      makeContext({ conversationId: "session-B" }),
-    );
-    expect(second.isError).toBeFalsy();
-
-    const firstResult = await first;
-    expect(firstResult.isError).toBeFalsy();
-  });
-
-  test("guard is released after first swarm completes", async () => {
-    // Run and complete first swarm (no gate)
-    const first = await swarmDelegateTool.execute(
-      { objective: "First task" },
-      makeContext({ conversationId: "session-A" }),
-    );
-    expect(first.isError).toBeFalsy();
-
-    // Same session should now be allowed again
-    const second = await swarmDelegateTool.execute(
-      { objective: "Second task" },
-      makeContext({ conversationId: "session-A" }),
-    );
-    expect(second.isError).toBeFalsy();
-  });
-});