@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/hooks-watch.test.ts

@@ -1,112 +0,0 @@
-import { mkdirSync, 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 { HookManager } from "../hooks/manager.js";
-
-let hooksDir: string;
-
-function makeManifest(
-  name: string,
-  events: string[] = ["pre-llm-call"],
-): string {
-  return JSON.stringify({
-    name,
-    description: `Test hook: ${name}`,
-    version: "1.0.0",
-    events,
-    script: "run.sh",
-  });
-}
-
-function installHook(name: string, events: string[] = ["pre-llm-call"]): void {
-  const hookDir = join(hooksDir, name);
-  mkdirSync(hookDir, { recursive: true });
-  writeFileSync(join(hookDir, "hook.json"), makeManifest(name, events));
-  writeFileSync(join(hookDir, "run.sh"), "#!/bin/sh\nexit 0\n", {
-    mode: 0o755,
-  });
-}
-
-function writeConfig(hooks: Record<string, { enabled: boolean }>): void {
-  writeFileSync(
-    join(hooksDir, "config.json"),
-    JSON.stringify({ version: 1, hooks }),
-  );
-}
-
-describe("hooks watch mode", () => {
-  let manager: HookManager;
-
-  beforeEach(() => {
-    hooksDir = join(
-      tmpdir(),
-      `hooks-watch-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    mkdirSync(hooksDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    if (manager) manager.stopWatching();
-    rmSync(hooksDir, { recursive: true, force: true });
-  });
-
-  test("reload() re-discovers hooks and rebuilds event index", () => {
-    installHook("hook-a", ["pre-llm-call"]);
-    writeConfig({ "hook-a": { enabled: true } });
-
-    manager = new HookManager();
-    // Initialize by discovering hooks from our temp dir
-    // We use a workaround since HookManager uses getHooksDir() internally
-    // Instead, test the reload behavior by checking the public API
-    const initialHooks = manager.getDiscoveredHooks();
-    expect(initialHooks).toHaveLength(0); // Not initialized yet
-
-    manager.initialize();
-    // After initialize, hooks depend on getHooksDir() which points elsewhere
-    // So we test reload conceptually: calling reload should not throw
-    expect(() => manager.reload()).not.toThrow();
-  });
-
-  test("stopWatching() cleans up watcher and timer", () => {
-    manager = new HookManager();
-    // stopWatching before watch should not throw
-    expect(() => manager.stopWatching()).not.toThrow();
-
-    // watch on a non-existent dir should not throw
-    manager.watch();
-    expect(() => manager.stopWatching()).not.toThrow();
-  });
-
-  test("watch() on non-existent directory does not throw", () => {
-    manager = new HookManager();
-    // The default hooks dir may not exist in test; should be safe
-    expect(() => manager.watch()).not.toThrow();
-    manager.stopWatching();
-  });
-
-  test("reload() updates enabled hooks count", () => {
-    manager = new HookManager();
-    manager.initialize();
-
-    // First reload
-    const hooks1 = manager.getDiscoveredHooks();
-
-    // Reload should work without error
-    manager.reload();
-    const hooks2 = manager.getDiscoveredHooks();
-
-    // Both should return the same result (consistent state)
-    expect(hooks1.length).toBe(hooks2.length);
-  });
-
-  test("multiple stopWatching() calls are idempotent", () => {
-    manager = new HookManager();
-    manager.watch();
-    manager.stopWatching();
-    manager.stopWatching();
-    manager.stopWatching();
-    // No errors thrown
-  });
-});

package/src/__tests__/notification-schedule-dedup.test.ts

@@ -1,213 +0,0 @@
-/**
- * Regression test: recurring schedule notifications must not be
- * deduplicated against prior firings of the same schedule.
- *
- * Before the fix, `schedule.complete` signals were emitted without a
- * producer dedupeKey. The LLM decision engine would generate a stable
- * key (e.g. `schedule:complete:<id>`) and `updateEventDedupeKey` would
- * write it back to the event row. On the next firing, `checkDedupe`
- * found the first row's stable key within the 1-hour window and
- * silently blocked the notification.
- *
- * The fix: always supply a unique per-firing dedupeKey from the
- * producer so `updateEventDedupeKey` is never called for schedule
- * signals, and `checkDedupe` never finds a matching row.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
-import { getDb, initializeDb } from "../memory/db.js";
-import { notificationEvents } from "../memory/schema.js";
-import { runDeterministicChecks } from "../notifications/deterministic-checks.js";
-import {
-  createEvent,
-  updateEventDedupeKey,
-} from "../notifications/events-store.js";
-import type { NotificationSignal } from "../notifications/signal.js";
-import type { NotificationDecision } from "../notifications/types.js";
-
-initializeDb();
-
-beforeEach(() => {
-  // Clear notification events between tests for isolation
-  getDb().delete(notificationEvents).run();
-});
-
-function makeSignal(
-  overrides?: Partial<NotificationSignal>,
-): NotificationSignal {
-  return {
-    signalId: `sig-${crypto.randomUUID()}`,
-    createdAt: Date.now(),
-    sourceChannel: "scheduler",
-    sourceContextId: "schedule-123",
-    sourceEventName: "schedule.complete",
-    contextPayload: { scheduleId: "schedule-123", name: "Drink water" },
-    attentionHints: {
-      requiresAction: false,
-      urgency: "medium",
-      isAsyncBackground: true,
-      visibleInSourceNow: false,
-    },
-    ...overrides,
-  };
-}
-
-function makeDecision(
-  overrides?: Partial<NotificationDecision>,
-): NotificationDecision {
-  return {
-    shouldNotify: true,
-    selectedChannels: ["vellum"],
-    reasoningSummary: "Schedule completed",
-    renderedCopy: {
-      vellum: { title: "Reminder", body: "Time to drink water" },
-    },
-    dedupeKey: "schedule:complete:schedule-123",
-    confidence: 0.9,
-    fallbackUsed: false,
-    ...overrides,
-  };
-}
-
-describe("recurring schedule notification dedup", () => {
-  test("second firing is blocked when LLM stable key is written to first event row (the bug)", async () => {
-    // Simulate the BROKEN behavior: producer sends no dedupeKey,
-    // LLM generates a stable key, and updateEventDedupeKey writes it
-    // to the first event row.
-
-    const stableKey = "schedule:complete:schedule-123";
-    const firstId = crypto.randomUUID();
-    const secondId = crypto.randomUUID();
-
-    // First firing: create event with null dedupeKey, then backfill with LLM key
-    const firstSignal = makeSignal({ signalId: firstId });
-    createEvent({
-      id: firstSignal.signalId,
-      sourceEventName: "schedule.complete",
-      sourceChannel: "scheduler",
-      sourceContextId: "schedule-123",
-      attentionHints: firstSignal.attentionHints,
-      payload: firstSignal.contextPayload,
-      // No dedupeKey — this is the bug scenario
-    });
-    // LLM decision generates a stable key, pipeline writes it back
-    updateEventDedupeKey(firstSignal.signalId, stableKey);
-
-    // Second firing: new event, same schedule
-    const secondSignal = makeSignal({ signalId: secondId });
-    createEvent({
-      id: secondSignal.signalId,
-      sourceEventName: "schedule.complete",
-      sourceChannel: "scheduler",
-      sourceContextId: "schedule-123",
-      attentionHints: secondSignal.attentionHints,
-      payload: secondSignal.contextPayload,
-    });
-
-    // LLM generates the same stable key for the second firing
-    const decision = makeDecision({ dedupeKey: stableKey });
-
-    const result = await runDeterministicChecks(secondSignal, decision, {
-      connectedChannels: ["vellum"],
-    });
-
-    // The second firing is BLOCKED — this is the bug
-    expect(result.passed).toBe(false);
-    expect(result.reason).toContain("Dedupe");
-  });
-
-  test("second firing passes when producer supplies unique per-firing dedupeKey (the fix)", async () => {
-    const stableKey = "schedule:complete:schedule-123";
-    const firstId = crypto.randomUUID();
-    const secondId = crypto.randomUUID();
-
-    // First firing: producer supplies a timestamped dedupeKey
-    const firstSignal = makeSignal({ signalId: firstId });
-    createEvent({
-      id: firstSignal.signalId,
-      sourceEventName: "schedule.complete",
-      sourceChannel: "scheduler",
-      sourceContextId: "schedule-123",
-      attentionHints: firstSignal.attentionHints,
-      payload: firstSignal.contextPayload,
-      dedupeKey: `schedule:complete:schedule-123:${Date.now() - 60_000}`,
-    });
-    // updateEventDedupeKey is NOT called because params.dedupeKey is truthy
-
-    // Second firing: new event with its own unique timestamped key
-    const secondSignal = makeSignal({ signalId: secondId });
-    createEvent({
-      id: secondSignal.signalId,
-      sourceEventName: "schedule.complete",
-      sourceChannel: "scheduler",
-      sourceContextId: "schedule-123",
-      attentionHints: secondSignal.attentionHints,
-      payload: secondSignal.contextPayload,
-      dedupeKey: `schedule:complete:schedule-123:${Date.now()}`,
-    });
-
-    // LLM still generates a stable key — but no row in the DB has it
-    const decision = makeDecision({ dedupeKey: stableKey });
-
-    const result = await runDeterministicChecks(secondSignal, decision, {
-      connectedChannels: ["vellum"],
-    });
-
-    // The second firing PASSES — the fix works
-    expect(result.passed).toBe(true);
-  });
-
-  test("notify mode with timestamped producer keys is not blocked", async () => {
-    const stableKey = "schedule:notify:schedule-123";
-    const firstId = crypto.randomUUID();
-    const secondId = crypto.randomUUID();
-
-    // First firing
-    const firstSignal = makeSignal({
-      signalId: firstId,
-      sourceEventName: "schedule.notify",
-    });
-    createEvent({
-      id: firstSignal.signalId,
-      sourceEventName: "schedule.notify",
-      sourceChannel: "scheduler",
-      sourceContextId: "schedule-123",
-      attentionHints: firstSignal.attentionHints,
-      payload: firstSignal.contextPayload,
-      dedupeKey: `schedule:notify:schedule-123:${Date.now() - 60_000}`,
-    });
-
-    // Second firing
-    const secondSignal = makeSignal({
-      signalId: secondId,
-      sourceEventName: "schedule.notify",
-    });
-    createEvent({
-      id: secondSignal.signalId,
-      sourceEventName: "schedule.notify",
-      sourceChannel: "scheduler",
-      sourceContextId: "schedule-123",
-      attentionHints: secondSignal.attentionHints,
-      payload: secondSignal.contextPayload,
-      dedupeKey: `schedule:notify:schedule-123:${Date.now()}`,
-    });
-
-    // LLM generates stable key — no matching row
-    const decision = makeDecision({ dedupeKey: stableKey });
-
-    const result = await runDeterministicChecks(secondSignal, decision, {
-      connectedChannels: ["vellum"],
-    });
-
-    expect(result.passed).toBe(true);
-  });
-});

package/src/__tests__/oauth-scope-policy.test.ts

@@ -1,180 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import type { ScopeResolverInput } from "../oauth/scope-policy.js";
-import { resolveScopes } from "../oauth/scope-policy.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Build a minimal scope resolver input for testing scope resolution. */
-function makeProfile(
-  overrides: Partial<ScopeResolverInput> = {},
-): ScopeResolverInput {
-  return {
-    service: "test-service",
-    defaultScopes: ["read", "write"],
-    scopePolicy: {
-      allowAdditionalScopes: false,
-      allowedOptionalScopes: [],
-      forbiddenScopes: [],
-    },
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("resolveScopes", () => {
-  it("returns default scopes when no requestedScopes are provided", () => {
-    const profile = makeProfile({ defaultScopes: ["read", "write"] });
-    const result = resolveScopes(profile);
-    expect(result).toEqual({ ok: true, scopes: ["read", "write"] });
-  });
-
-  it("returns default scopes when requestedScopes is undefined", () => {
-    const profile = makeProfile({ defaultScopes: ["read", "write"] });
-    const result = resolveScopes(profile, undefined);
-    expect(result).toEqual({ ok: true, scopes: ["read", "write"] });
-  });
-
-  it("returns default scopes when requestedScopes is an empty array", () => {
-    const profile = makeProfile({ defaultScopes: ["read", "write"] });
-    const result = resolveScopes(profile, []);
-    expect(result).toEqual({ ok: true, scopes: ["read", "write"] });
-  });
-
-  it("rejects a forbidden scope with a clear error message", () => {
-    const profile = makeProfile({
-      scopePolicy: {
-        allowAdditionalScopes: true,
-        allowedOptionalScopes: ["admin"],
-        forbiddenScopes: ["delete"],
-      },
-    });
-    const result = resolveScopes(profile, ["delete"]);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBe("Scope 'delete' is forbidden for test-service");
-    }
-  });
-
-  it("rejects additional scopes when allowAdditionalScopes is false", () => {
-    const profile = makeProfile({
-      defaultScopes: ["read", "write"],
-      scopePolicy: {
-        allowAdditionalScopes: false,
-        allowedOptionalScopes: [],
-        forbiddenScopes: [],
-      },
-    });
-    const result = resolveScopes(profile, ["admin"]);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toContain(
-        "Additional scopes are not allowed for test-service",
-      );
-      expect(result.allowedScopes).toEqual(["read", "write"]);
-    }
-  });
-
-  it("rejects a scope not in allowedOptionalScopes even when allowAdditionalScopes is true", () => {
-    const profile = makeProfile({
-      defaultScopes: ["read"],
-      scopePolicy: {
-        allowAdditionalScopes: true,
-        allowedOptionalScopes: ["write"],
-        forbiddenScopes: [],
-      },
-    });
-    const result = resolveScopes(profile, ["admin"]);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBe(
-        "Scope 'admin' is not in the allowed optional scopes for test-service",
-      );
-      expect(result.allowedScopes).toEqual(["read", "write"]);
-    }
-  });
-
-  it("accepts an additional scope when it is in allowedOptionalScopes and allowAdditionalScopes is true", () => {
-    const profile = makeProfile({
-      defaultScopes: ["read"],
-      scopePolicy: {
-        allowAdditionalScopes: true,
-        allowedOptionalScopes: ["write", "admin"],
-        forbiddenScopes: [],
-      },
-    });
-    const result = resolveScopes(profile, ["write"]);
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.scopes).toEqual(["read", "write"]);
-    }
-  });
-
-  it("deduplicates scopes in the result", () => {
-    const profile = makeProfile({
-      defaultScopes: ["read", "write"],
-      scopePolicy: {
-        allowAdditionalScopes: true,
-        allowedOptionalScopes: ["admin"],
-        forbiddenScopes: [],
-      },
-    });
-    // Request duplicates of existing defaults and a new scope twice
-    const result = resolveScopes(profile, ["read", "write", "admin", "admin"]);
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.scopes).toEqual(["read", "write", "admin"]);
-    }
-  });
-
-  it("keeps requested scopes that are already in defaults without error", () => {
-    const profile = makeProfile({
-      defaultScopes: ["read", "write"],
-      scopePolicy: {
-        allowAdditionalScopes: false,
-        allowedOptionalScopes: [],
-        forbiddenScopes: [],
-      },
-    });
-    // Requesting only default scopes should succeed even when
-    // allowAdditionalScopes is false
-    const result = resolveScopes(profile, ["read", "write"]);
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.scopes).toEqual(["read", "write"]);
-    }
-  });
-
-  it("checks forbidden scopes before allowAdditionalScopes policy", () => {
-    const profile = makeProfile({
-      defaultScopes: ["read"],
-      scopePolicy: {
-        allowAdditionalScopes: true,
-        allowedOptionalScopes: [],
-        forbiddenScopes: ["destroy"],
-      },
-    });
-    const result = resolveScopes(profile, ["destroy"]);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      // Should be the forbidden error, not the "not in optional scopes" error
-      expect(result.error).toContain("forbidden");
-    }
-  });
-
-  it("returns a defensive copy of defaultScopes (not the same array reference)", () => {
-    const defaults = ["read", "write"];
-    const profile = makeProfile({ defaultScopes: defaults });
-    const result = resolveScopes(profile);
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.scopes).toEqual(defaults);
-      expect(result.scopes).not.toBe(defaults);
-    }
-  });
-});

package/src/__tests__/send-notification-tool.test.ts

@@ -1,83 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-const emitNotificationSignalMock = mock(async (_params: unknown) => {});
-
-mock.module("../notifications/emit-signal.js", () => ({
-  emitNotificationSignal: (params: unknown) =>
-    emitNotificationSignalMock(params),
-}));
-
-import { run } from "../config/bundled-skills/notifications/tools/send-notification.js";
-
-describe("send-notification tool", () => {
-  beforeEach(() => {
-    emitNotificationSignalMock.mockClear();
-  });
-
-  test("emits a notification signal with normalized routing context", async () => {
-    const result = await run(
-      {
-        message: "Your verification code is 123456",
-        title: "Verification code",
-        urgency: "high",
-        conversation_id: "conv-override",
-        requires_action: true,
-        preferred_channels: ["vellum"],
-        deep_link_metadata: { conversationId: "conv-deeplink" },
-        dedupe_key: "voice-code-123456",
-      },
-      {
-        workingDir: "/tmp",
-        conversationId: "conv-1",
-        assistantId: "ast-alpha",
-        trustClass: "guardian" as const,
-      },
-    );
-
-    expect(result.isError).toBe(false);
-    expect(emitNotificationSignalMock).toHaveBeenCalledTimes(1);
-    expect(emitNotificationSignalMock).toHaveBeenCalledWith({
-      sourceEventName: "user.send_notification",
-      sourceChannel: "assistant_tool",
-      sourceContextId: "conv-override",
-      attentionHints: {
-        requiresAction: true,
-        urgency: "high",
-        deadlineAt: undefined,
-        isAsyncBackground: false,
-        visibleInSourceNow: false,
-      },
-      contextPayload: {
-        requestedMessage: "Your verification code is 123456",
-        requestedByTool: "send_notification",
-        requestedByContextId: "conv-1",
-        requestedTitle: "Verification code",
-        requestedByConversationId: "conv-override",
-        preferredChannels: ["vellum"],
-        deepLinkMetadata: { conversationId: "conv-deeplink" },
-      },
-      dedupeKey: "voice-code-123456",
-      throwOnError: true,
-    });
-  });
-
-  test("returns an error when the notification pipeline throws", async () => {
-    emitNotificationSignalMock.mockImplementationOnce(async () => {
-      throw new Error("database unavailable");
-    });
-
-    const result = await run(
-      { message: "test notification" },
-      {
-        workingDir: "/tmp",
-        conversationId: "conv-1",
-        assistantId: "ast-alpha",
-        trustClass: "guardian" as const,
-      },
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("database unavailable");
-    expect(emitNotificationSignalMock).toHaveBeenCalledTimes(1);
-  });
-});