@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/notification-deep-link.test.ts

@@ -20,6 +20,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => null,
+}));
+
 // Mock destination-resolver for broadcaster tests
 mock.module("../notifications/destination-resolver.js", () => ({
   resolveDestinations: (channels: string[]) => {

package/src/__tests__/notification-guardian-path.test.ts

@@ -68,6 +68,25 @@ mock.module("../notifications/emit-signal.js", () => ({
   },
 }));
 
+// Guardian principalId is resolved from the gateway binding reader. Mirror the
+// seeded vellum binding so dispatch can resolve the principal.
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-vellum",
+      principalId: "test-principal-id",
+      address: "local",
+      status: "active",
+    },
+  ],
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: unknown[]) => list[0],
+}));
+
 import {
   createCallSession,
   createPendingQuestion,
@@ -78,7 +97,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { conversations } from "../memory/schema.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function ensureConversation(id: string): void {
   const db = getDb();

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

@@ -27,7 +27,7 @@ import { createEvent } from "../notifications/events-store.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type { NotificationDecision } from "../notifications/types.js";
 
-initializeDb();
+await initializeDb();
 
 beforeEach(() => {
   getDb().delete(notificationEvents).run();

package/src/__tests__/oauth-provider-profiles.test.ts

@@ -17,7 +17,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { getProvider } from "../oauth/oauth-store.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
 
-initializeDb();
+await initializeDb();
 seedOAuthProviders();
 
 describe("oauth provider profiles (DB-seeded)", () => {

package/src/__tests__/oauth-provider-visibility.test.ts

@@ -29,7 +29,7 @@ import { isProviderVisible } from "../oauth/provider-visibility.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 /** Create a minimal AssistantConfig for testing. */
 function makeConfig(): AssistantConfig {

package/src/__tests__/oauth-store.test.ts

@@ -72,7 +72,7 @@ import { seedOAuthProviders } from "../oauth/seed-providers.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { getMockFetchCalls, mockFetch, resetMockFetch } from "./mock-fetch.js";
 
-initializeDb();
+await initializeDb();
 
 /** Seed a minimal provider row for FK satisfaction. */
 function seedTestProvider(provider = "github"): void {

package/src/__tests__/pending-interactions-resolved-event.test.ts

@@ -155,7 +155,7 @@ describe("pendingInteractions.resolve emits interaction_resolved", () => {
 });
 
 describe("removeByConversation emits interaction_resolved per entry", () => {
-  test("emits superseded for every non-host interaction in the conversation", () => {
+  test("emits superseded for every confirmation/secret interaction in the conversation", () => {
     pendingInteractions.register("conf-1", {
       conversationId: "conv-x",
       kind: "confirmation",
@@ -182,13 +182,16 @@ describe("removeByConversation emits interaction_resolved per entry", () => {
     const events = publishedMessages.filter(
       (m) => m.type === "interaction_resolved",
     ) as Extract<ServerMessage, { type: "interaction_resolved" }>[];
-    expect(events).toHaveLength(3);
+    expect(events).toHaveLength(2);
     expect(events.every((e) => e.state === "superseded")).toBe(true);
     const requestIds = new Set(events.map((e) => e.requestId));
-    expect(requestIds).toEqual(new Set(["conf-1", "secret-1", "question-1"]));
+    expect(requestIds).toEqual(new Set(["conf-1", "secret-1"]));
 
-    // host_bash entries survive auto-deny — no event for them.
+    // host_bash and question entries both survive auto-deny — no event for
+    // either. host proxies are settled by their result POST; questions by the
+    // enqueue steer's turn abort (see removeByConversation's skip list).
     expect(pendingInteractions.get("host-bash-1")).toBeDefined();
+    expect(pendingInteractions.get("question-1")).toBeDefined();
     // Unrelated conversation is untouched.
     expect(pendingInteractions.get("conf-other")).toBeDefined();
   });

package/src/__tests__/persist-unsendable-image-downscale.test.ts

@@ -40,7 +40,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { persistUnsendableImageDowngrades } from "../plugins/defaults/image-recovery/recover.js";
 import type { ContentBlock } from "../providers/types.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/__tests__/persist-unsendable-image.test.ts

@@ -27,7 +27,7 @@ import {
 } from "../plugins/defaults/image-recovery/recover.js";
 import type { ContentBlock } from "../providers/types.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/__tests__/persona-resolver.test.ts

@@ -40,6 +40,7 @@ let mockAnyGuardian: {
   contact: { userFile: string | null };
   channels: Record<string, unknown>[];
 } | null = null;
+let mockContactsByAddress: Record<string, { userFile: string | null }> = {};
 
 // ── Mock modules (must precede imports from the module under test) ──
 
@@ -48,7 +49,8 @@ mock.module("../util/platform.js", () => ({
 }));
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByAddress: () => null,
+  findContactByAddress: (channelType: string, address: string) =>
+    mockContactsByAddress[`${channelType}:${address}`] ?? null,
   findGuardianForChannel: (channelType: string) =>
     channelType === "vellum" ? mockVellumGuardian : null,
   listGuardianChannels: () => mockAnyGuardian,
@@ -83,6 +85,7 @@ beforeEach(() => {
   mockWorkspaceDir = mkdtempSync(join(testRoot, "ws-"));
   mockVellumGuardian = null;
   mockAnyGuardian = null;
+  mockContactsByAddress = {};
 });
 
 afterEach(() => {
@@ -283,4 +286,39 @@ describe("resolveUserSlug (guardian trust, no requester identity)", () => {
 
     expect(resolveUserSlug(trustContext)).toBeNull();
   });
+
+  test("guardian identity from the verdict keys the guardian user-file info read", () => {
+    // The verdict-bound guardian is looked up by its address, not by the
+    // most-recently-verified channel guardian, so a different channel guardian
+    // does not shadow the verdict's binding.
+    mockVellumGuardian = {
+      contact: { userFile: "wrong-guardian.md" },
+      channel: {},
+    };
+    mockContactsByAddress["telegram:guardian-tg"] = {
+      userFile: "alice.md",
+    };
+
+    const trustContext = {
+      sourceChannel: "telegram",
+      trustClass: "guardian",
+      guardianExternalUserId: "guardian-tg",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBe("alice");
+  });
+
+  test("falls back to the channel guardian when the verdict carries no guardian identity", () => {
+    mockVellumGuardian = {
+      contact: { userFile: "alice.md" },
+      channel: {},
+    };
+
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBe("alice");
+  });
 });

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -128,7 +128,7 @@ import { PermissionPrompter } from "../permissions/prompter.js";
 import { ToolExecutor } from "../tools/executor.js";
 import type { ToolContext as TC } from "../tools/types.js";
 
-initializeDb();
+await initializeDb();
 
 function makeContext(overrides?: Partial<TC>): TC {
   return {

package/src/__tests__/playbook-execution.test.ts

@@ -33,7 +33,7 @@ import { compilePlaybooks } from "../playbooks/playbook-compiler.js";
 import { parsePlaybookStatement } from "../playbooks/types.js";
 import type { ToolContext } from "../tools/types.js";
 
-initializeDb();
+await initializeDb();
 
 function getRawDb(): Database {
   return (getDb() as unknown as { $client: Database }).$client;

package/src/__tests__/playbook-tools.test.ts

@@ -29,7 +29,7 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import type { ToolContext } from "../tools/types.js";
 
-initializeDb();
+await initializeDb();
 
 function getRawDb(): Database {
   return (getDb() as unknown as { $client: Database }).$client;

package/src/__tests__/plugin-api-model-profiles.test.ts

@@ -1,9 +1,39 @@
-import { writeFileSync } from "node:fs";
-import { afterEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { invalidateConfigCache } from "../config/loader.js";
-import { getModelProfiles } from "../plugin-api/index.js";
-import { getWorkspaceConfigPath } from "../util/platform.js";
+interface MockProfileEntry {
+  label?: string;
+  description?: string;
+  provider?: string;
+  model?: string;
+  status?: string;
+  mix?: unknown;
+}
+
+let mockProfiles: Record<string, MockProfileEntry> = {};
+let mockActiveProfile: string | undefined;
+let mockProfileOrder: string[] | undefined;
+
+const realConfigLoader = await import("../config/loader.js");
+
+mock.module("../config/loader.js", () => ({
+  ...realConfigLoader,
+  getConfig: () => ({
+    llm: {
+      profiles: mockProfiles,
+      activeProfile: mockActiveProfile,
+      profileOrder: mockProfileOrder,
+    },
+  }),
+  getConfigReadOnly: () => ({
+    llm: {
+      profiles: mockProfiles,
+      activeProfile: mockActiveProfile,
+      profileOrder: mockProfileOrder,
+    },
+  }),
+}));
+
+const { getModelProfiles } = await import("../plugin-api/index.js");
 
 /**
  * `getModelProfiles()` — the runtime handle a plugin (e.g. a model router) calls
@@ -14,14 +44,23 @@ import { getWorkspaceConfigPath } from "../util/platform.js";
  * description → null, isActive → `llm.activeProfile`).
  */
 
-function writeFixtureConfig(config: Record<string, unknown>): void {
-  writeFileSync(getWorkspaceConfigPath(), JSON.stringify(config), "utf-8");
-  invalidateConfigCache();
+function writeFixtureConfig(config: {
+  llm?: {
+    profiles?: Record<string, MockProfileEntry>;
+    activeProfile?: string;
+    profileOrder?: string[];
+  };
+}): void {
+  mockProfiles = config.llm?.profiles ?? {};
+  mockActiveProfile = config.llm?.activeProfile;
+  mockProfileOrder = config.llm?.profileOrder;
 }
 
 describe("getModelProfiles", () => {
-  afterEach(() => {
-    invalidateConfigCache();
+  beforeEach(() => {
+    mockProfiles = {};
+    mockActiveProfile = undefined;
+    mockProfileOrder = undefined;
   });
 
   test("orders profiles by profileOrder then the remaining keys alphabetically", () => {
@@ -29,7 +68,12 @@ describe("getModelProfiles", () => {
     // ("balanced") and a key that resolves to no profile ("ghost").
     writeFixtureConfig({
       llm: {
-        profiles: { zeta: {}, alpha: {}, balanced: {}, "cost-optimized": {} },
+        profiles: {
+          zeta: { provider: "anthropic" },
+          alpha: { provider: "anthropic" },
+          balanced: { provider: "anthropic" },
+          "cost-optimized": { provider: "anthropic" },
+        },
         profileOrder: ["balanced", "cost-optimized", "balanced", "ghost"],
       },
     });
@@ -45,8 +89,8 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          alpha: {},
-          beta: {},
+          alpha: { provider: "anthropic" },
+          beta: { provider: "anthropic" },
           blend: {
             mix: [
               { profile: "alpha", weight: 1 },
@@ -72,14 +116,14 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          alpha: {},
+          alpha: { provider: "anthropic" },
           blend: {
             mix: [
               { profile: "alpha", weight: 1 },
               { profile: "beta", weight: 1 },
             ],
           },
-          beta: {},
+          beta: { provider: "anthropic" },
         },
         profileOrder: ["alpha", "blend", "beta"],
         activeProfile: "blend",
@@ -98,8 +142,8 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          alpha: { status: "active" },
-          beta: { status: "disabled" },
+          alpha: { provider: "anthropic", status: "active" },
+          beta: { provider: "anthropic", status: "disabled" },
         },
         profileOrder: ["alpha", "beta"],
       },
@@ -117,7 +161,10 @@ describe("getModelProfiles", () => {
     // GIVEN a workspace where one profile sets a label and one does not.
     writeFixtureConfig({
       llm: {
-        profiles: { balanced: { label: "Balanced" }, terse: {} },
+        profiles: {
+          balanced: { provider: "anthropic", label: "Balanced" },
+          terse: { provider: "anthropic" },
+        },
         profileOrder: ["balanced", "terse"],
       },
     });
@@ -134,7 +181,10 @@ describe("getModelProfiles", () => {
     // GIVEN a workspace whose activeProfile is "beta".
     writeFixtureConfig({
       llm: {
-        profiles: { alpha: {}, beta: {} },
+        profiles: {
+          alpha: { provider: "anthropic" },
+          beta: { provider: "anthropic" },
+        },
         profileOrder: ["alpha", "beta"],
         activeProfile: "beta",
       },
@@ -153,8 +203,11 @@ describe("getModelProfiles", () => {
     writeFixtureConfig({
       llm: {
         profiles: {
-          documented: { description: "Cheaper models, slower" },
-          bare: {},
+          documented: {
+            provider: "anthropic",
+            description: "Cheaper models, slower",
+          },
+          bare: { provider: "anthropic" },
         },
         profileOrder: ["documented", "bare"],
       },

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

@@ -536,4 +536,82 @@ describe("plugin bootstrap", () => {
     // that snapshot, so its `onShutdown` must never fire.
     expect(shutdownFired).toBe(false);
   });
+
+  // ── .disabled sentinel gating ──────────────────────────────────────────
+  //
+  // A plugin is disabled when a `.disabled` file exists at
+  // <workspace>/plugins/<manifest-name>/.disabled. The bootstrap must
+  // skip the plugin entirely — no init, no tools, no routes, no shutdown
+  // hook — and remove it from the registry, mirroring the requiresFlag
+  // gate.
+
+  test(".disabled sentinel: init does not fire and plugin is unregistered", async () => {
+    let initFired = false;
+    const plugin = buildPlugin("sentinel-off", {
+      async init() {
+        initFired = true;
+      },
+    });
+    registerPlugin(plugin);
+
+    // Create the .disabled sentinel in the workspace plugins dir.
+    const sentinelDir = join(
+      TEST_WORKSPACE_DIR,
+      "plugins",
+      "sentinel-off",
+    );
+    const { mkdir, writeFile } = await import("node:fs/promises");
+    await mkdir(sentinelDir, { recursive: true });
+    await writeFile(join(sentinelDir, ".disabled"), "");
+
+    await bootstrapPlugins();
+
+    expect(initFired).toBe(false);
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("sentinel-off");
+
+    await rm(sentinelDir, { recursive: true, force: true });
+  });
+
+  test(".disabled sentinel absent: plugin inits normally", async () => {
+    let initFired = false;
+    const plugin = buildPlugin("sentinel-ok", {
+      async init() {
+        initFired = true;
+      },
+    });
+    registerPlugin(plugin);
+
+    // No .disabled sentinel created — plugin should init normally.
+    await bootstrapPlugins();
+
+    expect(initFired).toBe(true);
+  });
+
+  test(".disabled sentinel: no shutdown hook entry for the skipped plugin", async () => {
+    let shutdownFired = false;
+    const plugin = buildPlugin("sentinel-shutdown", {
+      async init() {},
+      async onShutdown() {
+        shutdownFired = true;
+      },
+    });
+    registerPlugin(plugin);
+
+    const sentinelDir = join(
+      TEST_WORKSPACE_DIR,
+      "plugins",
+      "sentinel-shutdown",
+    );
+    const { mkdir, writeFile } = await import("node:fs/promises");
+    await mkdir(sentinelDir, { recursive: true });
+    await writeFile(join(sentinelDir, ".disabled"), "");
+
+    await bootstrapPlugins();
+    await runShutdownHooks("test-shutdown");
+
+    expect(shutdownFired).toBe(false);
+
+    await rm(sentinelDir, { recursive: true, force: true });
+  });
 });

package/src/__tests__/provider-platform-proxy-integration.test.ts

@@ -212,6 +212,7 @@ const MANAGED_FALLBACK_PROVIDERS: string[] = [
   "gemini",
   "openai",
   "fireworks",
+  "together",
 ];
 
 function enableManagedProxy() {
@@ -335,18 +336,25 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("managed bootstrap registers anthropic, openai, gemini, and fireworks", async () => {
+    test("managed bootstrap registers anthropic, openai, gemini, fireworks, and together", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect(listProviders()).toEqual(
-        expect.arrayContaining(["anthropic", "openai", "gemini", "fireworks"]),
+        expect.arrayContaining([
+          "anthropic",
+          "openai",
+          "gemini",
+          "fireworks",
+          "together",
+        ]),
       );
-      expect(listProviders()).toHaveLength(4);
+      expect(listProviders()).toHaveLength(5);
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
       expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("together")).toBe("managed-proxy");
       expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
@@ -681,8 +689,14 @@ describe("config mode flip → provider reinit", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic, openai, gemini, and fireworks have metadata with managed=true and a proxyPath", () => {
-    for (const provider of ["anthropic", "openai", "gemini", "fireworks"]) {
+  test("anthropic, openai, gemini, fireworks, and together have metadata with managed=true and a proxyPath", () => {
+    for (const provider of [
+      "anthropic",
+      "openai",
+      "gemini",
+      "fireworks",
+      "together",
+    ]) {
       const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
@@ -715,6 +729,12 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
+  test("together routes through together proxy path", () => {
+    expect(PLATFORM_PROVIDER_META.together.proxyPath).toBe(
+      "/v1/runtime-proxy/together",
+    );
+  });
+
   test("openrouter is not managed proxy capable", () => {
     expect(PLATFORM_PROVIDER_META.openrouter.managed).toBe(false);
     expect(PLATFORM_PROVIDER_META.openrouter.proxyPath).toBeUndefined();

package/src/__tests__/provider-usage-tracking.test.ts

@@ -22,7 +22,7 @@ import { CallSiteConfiguredProvider } from "../providers/provider-send-message.j
 import type { Provider, ProviderResponse } from "../providers/types.js";
 import { UsageTrackingProvider } from "../providers/usage-tracking.js";
 
-initializeDb();
+await initializeDb();
 
 function setLlmConfig(raw: unknown): void {
   mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
@@ -200,3 +200,42 @@ describe("UsageTrackingProvider", () => {
     });
   });
 });
+
+describe("native web-search capability survives the wrapper chain", () => {
+  function leaf(supports: boolean | undefined): Provider {
+    return {
+      name: "anthropic",
+      ...(supports === undefined ? {} : { supportsNativeWebSearch: supports }),
+      async sendMessage(): Promise<ProviderResponse> {
+        return {
+          content: [{ type: "text", text: "" }],
+          model: "m",
+          usage: { inputTokens: 0, outputTokens: 0 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+  }
+
+  test("UsageTrackingProvider forwards supportsNativeWebSearch", () => {
+    expect(new UsageTrackingProvider(leaf(true)).supportsNativeWebSearch).toBe(
+      true,
+    );
+    expect(new UsageTrackingProvider(leaf(false)).supportsNativeWebSearch).toBe(
+      false,
+    );
+    expect(
+      new UsageTrackingProvider(leaf(undefined)).supportsNativeWebSearch,
+    ).toBeUndefined();
+  });
+
+  test("CallSiteConfiguredProvider forwards it through a nested wrapper", () => {
+    // The exact chain getConfiguredProvider returns: CallSiteConfigured →
+    // UsageTracking → leaf. The advisor consult reads the flag off the top.
+    const wrapped = new CallSiteConfiguredProvider(
+      new UsageTrackingProvider(leaf(true)),
+      "advisor",
+    );
+    expect(wrapped.supportsNativeWebSearch).toBe(true);
+  });
+});

package/src/__tests__/prune-old-conversations-job.test.ts

@@ -19,7 +19,7 @@ import {
   toolInvocations,
 } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 const STALE_ID = "conv-prune-job-stale";
 const FRESH_ID = "conv-prune-job-fresh";

package/src/__tests__/reaction-persistence.test.ts

@@ -63,7 +63,7 @@ import {
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/__tests__/registry.test.ts

@@ -36,6 +36,9 @@ function makeFakeTool(name: string): Tool {
     category: "test",
     defaultRiskLevel: RiskLevel.Low,
     executionTarget: "sandbox",
+    // Match the finalized shape the registry stores, so identity comparisons
+    // (`getTool(name)` toEqual coreTool) hold after registration fills defaults.
+    exclusive: false,
     input_schema: { type: "object", properties: {}, required: [] },
     async execute(
       _input: Record<string, unknown>,