@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/__tests__/plugin-pipeline.test.ts

@@ -1,96 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { runHook } from "../plugins/pipeline.js";
-import {
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
-
-beforeEach(() => {
-  resetPluginRegistryForTests();
-});
-
-describe("plugin pipeline", () => {
-  test("logs and skips failed hooks while preserving threaded mutations", async () => {
-    registerPlugin({
-      manifest: {
-        name: "test-first-hook",
-        version: "1.0.0",
-      },
-      hooks: {
-        "user-prompt-submit": async () => ({
-          value: 1,
-        }),
-      },
-    });
-    registerPlugin({
-      manifest: {
-        name: "test-throwing-hook",
-        version: "1.0.0",
-      },
-      hooks: {
-        "user-prompt-submit": async () => {
-          throw new Error("hook failed");
-        },
-      },
-    });
-    registerPlugin({
-      manifest: {
-        name: "test-final-hook",
-        version: "1.0.0",
-      },
-      hooks: {
-        "user-prompt-submit": async (ctx: { value: number }) => ({
-          value: ctx.value + 1,
-        }),
-      },
-    });
-
-    const result = await runHook("user-prompt-submit", { value: 0 });
-
-    expect(result).toEqual({ value: 2 });
-  });
-
-  test("discards in-place mutations from a failed hook", async () => {
-    registerPlugin({
-      manifest: {
-        name: "test-first-hook",
-        version: "1.0.0",
-      },
-      hooks: {
-        "user-prompt-submit": async (ctx: { items: string[] }) => {
-          ctx.items.push("first");
-        },
-      },
-    });
-    registerPlugin({
-      manifest: {
-        name: "test-throwing-hook",
-        version: "1.0.0",
-      },
-      hooks: {
-        "user-prompt-submit": async (ctx: { items: string[] }) => {
-          ctx.items.push("failed");
-          throw new Error("hook failed");
-        },
-      },
-    });
-    registerPlugin({
-      manifest: {
-        name: "test-final-hook",
-        version: "1.0.0",
-      },
-      hooks: {
-        "user-prompt-submit": async (ctx: { items: string[] }) => {
-          ctx.items.push("final");
-        },
-      },
-    });
-
-    const result = await runHook<{ items: string[] }>("user-prompt-submit", {
-      items: [],
-    });
-
-    expect(result.items).toEqual(["first", "final"]);
-  });
-});

package/src/__tests__/sse-actor-principal-guardian-source.test.ts

@@ -1,102 +0,0 @@
-/**
- * Regression: the SSE subscribe path must resolve the actor principal from the
- * SAME guardian source as the send/result routes.
- *
- * The send/result routes resolve the actor principal via the async,
- * gateway-first `findLocalGuardianPrincipalId`. The SSE eager-subscribe path
- * cannot await and uses the sync `findLocalGuardianPrincipalIdFromStore`. When
- * the gateway binding is canonical but the local contact row is stale/missing
- * (after a guardian reset or gateway-owned binding update), the sync path must
- * still land on the gateway principal — otherwise the event hub registers the
- * SSE client under a DIFFERENT principal than the turn/result paths use, and
- * targeted result submissions 403.
- *
- * These tests pin the invariant by priming the gateway-delivery cache with a
- * principal that differs from the stale local store and asserting both
- * resolvers agree; and that a cold cache falls back to the local store.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { GuardianDelivery } from "@vellumai/gateway-client";
-
-// ── Controllable IPC mock (drives the gateway-delivery cache) ────────────────
-
-let ipcGuardians: GuardianDelivery[] = [];
-
-mock.module("../ipc/gateway-client.js", () => ({
-  ipcCall: async () => ({ guardians: ipcGuardians }),
-  ipcCallPersistent: async () => undefined,
-  resetPersistentClient: () => {},
-}));
-
-// ── Local store mock (the stale fallback source) ─────────────────────────────
-
-let storePrincipalId: string | undefined;
-
-mock.module("../contacts/contact-store.js", () => ({
-  findGuardianForChannel: (channelType: string) =>
-    storePrincipalId && channelType === "vellum"
-      ? { contact: { principalId: storePrincipalId }, channel: {} }
-      : null,
-}));
-
-import {
-  __resetGuardianDeliveryCacheForTest,
-  getGuardianDelivery,
-} from "../contacts/guardian-delivery-reader.js";
-import {
-  findLocalGuardianPrincipalId,
-  findLocalGuardianPrincipalIdFromStore,
-} from "../runtime/local-actor-identity.js";
-
-const gatewayVellumGuardian: GuardianDelivery = {
-  channelType: "vellum",
-  contactId: "contact-gw",
-  principalId: "guardian-from-gateway",
-  address: "vellum:self",
-  status: "active",
-};
-
-describe("SSE actor principal resolves from the same guardian source as send/result routes", () => {
-  beforeEach(() => {
-    __resetGuardianDeliveryCacheForTest();
-    ipcGuardians = [];
-    storePrincipalId = undefined;
-  });
-
-  test("warm gateway cache: sync (SSE) and async (send/result) resolve the SAME principal despite a stale local store", async () => {
-    // Gateway binding is canonical; local store row is stale (different id).
-    ipcGuardians = [gatewayVellumGuardian];
-    storePrincipalId = "guardian-stale-local";
-
-    // Prime the cache the way the async hot paths do.
-    const asyncPrincipalId = await findLocalGuardianPrincipalId();
-    expect(asyncPrincipalId).toBe("guardian-from-gateway");
-
-    // SSE's sync resolver reads the same cached gateway snapshot, NOT the
-    // stale store — so the principals match and host-proxy targeting works.
-    expect(findLocalGuardianPrincipalIdFromStore()).toBe(asyncPrincipalId);
-  });
-
-  test("cold cache: sync resolver falls back to the local store as before", () => {
-    // Nothing primed the cache; only the local store has a binding.
-    storePrincipalId = "guardian-stale-local";
-
-    expect(findLocalGuardianPrincipalIdFromStore()).toBe("guardian-stale-local");
-  });
-
-  test("cold cache with no store binding: sync resolver returns undefined", () => {
-    expect(findLocalGuardianPrincipalIdFromStore()).toBeUndefined();
-  });
-
-  test("warm gateway cache primes via the vellum-filtered read the async path uses", async () => {
-    ipcGuardians = [gatewayVellumGuardian];
-
-    // The async path filters by channelType vellum; the sync peek must read
-    // the same cache key, not the unfiltered "ALL" entry.
-    await getGuardianDelivery({ channelTypes: ["vellum"] });
-
-    expect(findLocalGuardianPrincipalIdFromStore()).toBe("guardian-from-gateway");
-  });
-});

package/src/__tests__/steer-on-enqueue-question.test.ts

@@ -1,181 +0,0 @@
-/**
- * Enqueue-steer contract: when a chat message is enqueued while an
- * `ask_question` prompt is open for the same conversation, the user has chosen
- * to move on rather than answer it. `steerOnEnqueuedMessageIfQuestionParked`
- * steers to that message — aborting the parked turn (which settles the open
- * question via its turn-abort signal) and draining the message — instead of
- * stranding it behind a prompt no one will answer.
- *
- * Only `kind: "question"` interactions trigger the steer; pending confirmations
- * are handled separately by the enqueue path's auto-deny.
- */
-import { afterEach, describe, expect, test } from "bun:test";
-
-import type { Conversation } from "../daemon/conversation.js";
-import {
-  deleteConversation,
-  setConversation,
-} from "../daemon/conversation-registry.js";
-import {
-  steerOnEnqueuedMessageIfQuestionParked,
-  supersedePendingInteractionsOnEnqueue,
-} from "../daemon/handlers/conversations.js";
-import * as pendingInteractions from "../runtime/pending-interactions.js";
-
-interface ParkedTurn {
-  abortCount: () => number;
-  fake: { pendingSteerRepair: boolean };
-}
-
-/**
- * Register a fake conversation whose in-flight turn is parked. The fake exposes
- * just the surface `steerToMessage` touches: a processing flag, a queue whose
- * head can be promoted, an abort controller that records aborts, and the
- * confirmation-deny hook.
- */
-function registerParkedTurn(id: string): ParkedTurn {
-  let abortCount = 0;
-  const fake = {
-    isProcessing: () => true,
-    queue: {
-      promoteToHead: (requestId: string) => ({ requestId }),
-    },
-    pendingSteerRepair: false,
-    abortController: {
-      abort: () => {
-        abortCount += 1;
-      },
-    },
-    hasAnyPendingConfirmation: () => false,
-    denyAllPendingConfirmations: () => {},
-  };
-  setConversation(id, fake as unknown as Conversation);
-  return { abortCount: () => abortCount, fake };
-}
-
-const registeredRequestIds: string[] = [];
-function registerInteraction(
-  conversationId: string,
-  kind: "question" | "confirmation",
-): void {
-  const requestId = `pending-${kind}-${conversationId}`;
-  pendingInteractions.register(requestId, { conversationId, kind });
-  registeredRequestIds.push(requestId);
-}
-
-const QUESTION_CONV = "steer-enqueue-question";
-const CONFIRMATION_CONV = "steer-enqueue-confirmation";
-const NONE_CONV = "steer-enqueue-none";
-
-describe("steerOnEnqueuedMessageIfQuestionParked", () => {
-  afterEach(() => {
-    for (const id of registeredRequestIds) {
-      pendingInteractions.resolve(id, "cancelled");
-    }
-    registeredRequestIds.length = 0;
-    deleteConversation(QUESTION_CONV);
-    deleteConversation(CONFIRMATION_CONV);
-    deleteConversation(NONE_CONV);
-  });
-
-  test("steers to the enqueued message when an ask_question is parked", () => {
-    const conv = registerParkedTurn(QUESTION_CONV);
-    registerInteraction(QUESTION_CONV, "question");
-
-    const steered = steerOnEnqueuedMessageIfQuestionParked(
-      QUESTION_CONV,
-      "msg-1",
-    );
-
-    // The parked turn is aborted (which settles the open question) and marked
-    // for tool-result repair so the drain path can pick up the new message.
-    expect(steered).toBe(true);
-    expect(conv.abortCount()).toBe(1);
-    expect(conv.fake.pendingSteerRepair).toBe(true);
-  });
-
-  test("steers for a parked question even when a confirmation is also pending", () => {
-    // A single model response can open an ask_question and a confirmation
-    // concurrently (tools run via Promise.all), so both interactions can be
-    // registered at once. The steer must still fire for the question — the
-    // enqueue path runs it before the confirmation auto-deny clears entries.
-    const conv = registerParkedTurn(QUESTION_CONV);
-    registerInteraction(QUESTION_CONV, "confirmation");
-    registerInteraction(QUESTION_CONV, "question");
-
-    const steered = steerOnEnqueuedMessageIfQuestionParked(
-      QUESTION_CONV,
-      "msg-1",
-    );
-
-    expect(steered).toBe(true);
-    expect(conv.abortCount()).toBe(1);
-  });
-
-  test("does not steer for a pending confirmation (not a question)", () => {
-    const conv = registerParkedTurn(CONFIRMATION_CONV);
-    registerInteraction(CONFIRMATION_CONV, "confirmation");
-
-    const steered = steerOnEnqueuedMessageIfQuestionParked(
-      CONFIRMATION_CONV,
-      "msg-1",
-    );
-
-    expect(steered).toBe(false);
-    expect(conv.abortCount()).toBe(0);
-  });
-
-  test("does not steer when no prompt is parked", () => {
-    const conv = registerParkedTurn(NONE_CONV);
-
-    const steered = steerOnEnqueuedMessageIfQuestionParked(NONE_CONV, "msg-1");
-
-    expect(steered).toBe(false);
-    expect(conv.abortCount()).toBe(0);
-  });
-
-  test("supersedePendingInteractionsOnEnqueue steers a parked question", () => {
-    // The centralized routine is invoked by both the HTTP send handler and the
-    // CLI signal path. With no pending confirmation it steers a parked question
-    // — the behavior the CLI signal path previously lacked.
-    const conv = registerParkedTurn(QUESTION_CONV);
-    registerInteraction(QUESTION_CONV, "question");
-
-    supersedePendingInteractionsOnEnqueue(QUESTION_CONV, "msg-1");
-
-    expect(conv.abortCount()).toBe(1);
-    expect(conv.fake.pendingSteerRepair).toBe(true);
-  });
-});
-
-describe("removeByConversation preserves question interactions", () => {
-  // The enqueue path's confirmation auto-deny calls removeByConversation before
-  // the steer runs. Questions must survive it — they are settled instead by the
-  // steer's turn abort — or, when an ask_question and a confirmation are pending
-  // concurrently, the queued message would strand behind a question whose entry
-  // was cleared (and whose Promise was never settled) before the steer fired.
-  const CONV = "remove-by-conv-preserve-question";
-  const ids: string[] = [];
-  function register(kind: "question" | "confirmation"): void {
-    const requestId = `rbc-${kind}`;
-    pendingInteractions.register(requestId, { conversationId: CONV, kind });
-    ids.push(requestId);
-  }
-
-  afterEach(() => {
-    for (const id of ids) pendingInteractions.resolve(id, "cancelled");
-    ids.length = 0;
-  });
-
-  test("removes confirmations but leaves questions registered", () => {
-    register("confirmation");
-    register("question");
-
-    pendingInteractions.removeByConversation(CONV);
-
-    const remaining = pendingInteractions
-      .getByConversation(CONV)
-      .map((interaction) => interaction.kind);
-    expect(remaining).toEqual(["question"]);
-  });
-});

package/src/__tests__/workspace-migration-111-prune-seeded-callsite-defaults.test.ts

@@ -1,208 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { pruneSeededCallsiteDefaultsMigration } from "../workspace/migrations/111-prune-seeded-callsite-defaults.js";
-import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
-
-let workspaceDir: string;
-let previousOverlayPath: string | undefined;
-
-function writeConfig(data: Record<string, unknown>): void {
-  writeFileSync(
-    join(workspaceDir, "config.json"),
-    JSON.stringify(data, null, 2) + "\n",
-  );
-}
-
-function readConfig(): Record<string, unknown> {
-  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
-}
-
-function readLlm(): Record<string, unknown> | undefined {
-  return readConfig().llm as Record<string, unknown> | undefined;
-}
-
-function latencySeed(): Record<string, unknown> {
-  return {
-    model: "claude-haiku-4-5-20251001",
-    effort: "low",
-    thinking: { enabled: false },
-  };
-}
-
-function fullSeededCallSites(): Record<string, Record<string, unknown>> {
-  return {
-    guardianQuestionCopy: latencySeed(),
-    interactionClassifier: latencySeed(),
-    skillCategoryInference: latencySeed(),
-    inviteInstructionGenerator: latencySeed(),
-    notificationDecision: latencySeed(),
-    preferenceExtraction: latencySeed(),
-    commitMessage: {
-      model: "claude-haiku-4-5-20251001",
-      maxTokens: 120,
-      temperature: 0.2,
-      effort: "low",
-      thinking: { enabled: false },
-    },
-    conversationStarters: latencySeed(),
-    conversationSummarization: {
-      model: "claude-opus-4-7",
-      effort: "low",
-      thinking: { enabled: false },
-    },
-    recall: {
-      profile: "cost-optimized",
-      maxTokens: 4096,
-      effort: "low",
-      thinking: { enabled: false, streamThinking: false },
-      temperature: 0,
-      disableCache: true,
-    },
-    heartbeatAgent: {
-      profile: "cost-optimized",
-      maxTokens: 2048,
-      effort: "low",
-      temperature: 0,
-      thinking: { enabled: false, streamThinking: false },
-      contextWindow: { maxInputTokens: 16000 },
-    },
-    replySuggestion: {
-      model: "claude-haiku-4-5-20251001",
-      effort: "low",
-      thinking: { enabled: false },
-      disableCache: true,
-    },
-    memoryRouter: {
-      profile: "cost-optimized",
-      contextWindow: { maxInputTokens: 1_000_000 },
-    },
-  };
-}
-
-beforeEach(() => {
-  workspaceDir = join(
-    tmpdir(),
-    `vellum-migration-111-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-  mkdirSync(workspaceDir, { recursive: true });
-  previousOverlayPath = process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
-  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
-});
-
-afterEach(() => {
-  if (previousOverlayPath === undefined) {
-    delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
-  } else {
-    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = previousOverlayPath;
-  }
-  if (existsSync(workspaceDir)) {
-    rmSync(workspaceDir, { recursive: true, force: true });
-  }
-});
-
-describe("111-prune-seeded-callsite-defaults migration", () => {
-  test("is registered last", () => {
-    expect(WORKSPACE_MIGRATIONS.at(-1)).toBe(
-      pruneSeededCallsiteDefaultsMigration,
-    );
-  });
-
-  test("no-op when config.json does not exist", () => {
-    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
-    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
-  });
-
-  test("gracefully handles invalid JSON", () => {
-    writeFileSync(join(workspaceDir, "config.json"), "not-valid-json");
-    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
-    expect(readFileSync(join(workspaceDir, "config.json"), "utf-8")).toBe(
-      "not-valid-json",
-    );
-  });
-
-  test("removes exact system-owned call-site default materializations", () => {
-    writeConfig({
-      llm: {
-        activeProfile: "balanced",
-        advisorProfile: "frontier",
-        callSites: fullSeededCallSites(),
-      },
-    });
-
-    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
-
-    expect(readLlm()?.activeProfile).toBe("balanced");
-    expect(readLlm()?.advisorProfile).toBe("frontier");
-    expect(readLlm()?.callSites).toBeUndefined();
-  });
-
-  test("preserves user-customized call-site entries", () => {
-    writeConfig({
-      llm: {
-        callSites: {
-          ...fullSeededCallSites(),
-          commitMessage: {
-            model: "claude-haiku-4-5-20251001",
-            maxTokens: 256,
-            temperature: 0.2,
-            effort: "low",
-            thinking: { enabled: false },
-          },
-          recall: {
-            profile: "cost-optimized",
-            maxTokens: 4096,
-            effort: "low",
-            thinking: { enabled: false, streamThinking: false },
-            temperature: 0,
-            disableCache: false,
-          },
-          customSite: { profile: "frontier" },
-        },
-      },
-    });
-
-    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
-
-    const callSites = readLlm()?.callSites as Record<
-      string,
-      Record<string, unknown>
-    >;
-    expect(Object.keys(callSites).sort()).toEqual([
-      "commitMessage",
-      "customSite",
-      "recall",
-    ]);
-    expect(callSites.commitMessage?.maxTokens).toBe(256);
-    expect(callSites.recall?.disableCache).toBe(false);
-    expect(callSites.customSite).toEqual({ profile: "frontier" });
-  });
-
-  test("platform-style config keeps gateway settings while pruning seeded call sites", () => {
-    writeConfig({
-      gateway: {
-        unmappedPolicy: "default",
-        defaultAssistantId: "self",
-      },
-      llm: {
-        callSites: fullSeededCallSites(),
-      },
-    });
-
-    pruneSeededCallsiteDefaultsMigration.run(workspaceDir);
-
-    expect(readConfig().gateway).toEqual({
-      unmappedPolicy: "default",
-      defaultAssistantId: "self",
-    });
-    expect(readLlm()?.callSites).toBeUndefined();
-  });
-});