@vellumai/assistant 0.9.0 → 0.10.0-staging.2

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

@@ -32,18 +32,14 @@ import {
 // ── Mock state ────────────────────────────────────────────────────
 
 let mockWorkspaceDir: string = "";
-let mockVellumGuardian:
-  | {
-      contact: { userFile: string | null };
-      channel: Record<string, unknown>;
-    }
-  | null = null;
-let mockAnyGuardian:
-  | {
-      contact: { userFile: string | null };
-      channels: Record<string, unknown>[];
-    }
-  | null = null;
+let mockVellumGuardian: {
+  contact: { userFile: string | null };
+  channel: Record<string, unknown>;
+} | null = null;
+let mockAnyGuardian: {
+  contact: { userFile: string | null };
+  channels: Record<string, unknown>[];
+} | null = null;
 
 // ── Mock modules (must precede imports from the module under test) ──
 
@@ -52,7 +48,7 @@ mock.module("../util/platform.js", () => ({
 }));
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByChannelExternalId: () => null,
+  findContactByAddress: () => null,
   findGuardianForChannel: (channelType: string) =>
     channelType === "vellum" ? mockVellumGuardian : null,
   listGuardianChannels: () => mockAnyGuardian,
@@ -60,12 +56,14 @@ mock.module("../contacts/contact-store.js", () => ({
 
 // Import AFTER mocks so the module under test binds to the stubbed
 // implementations.
+import type { TrustContext } from "../daemon/trust-context.js";
 import {
   ensureGuardianPersonaFile,
   isGuardianPersonaCustomized,
   resolveGuardianPersona,
   resolveGuardianPersonaPath,
   resolveGuardianPersonaStrict,
+  resolveUserSlug,
 } from "../prompts/persona-resolver.js";
 
 // ── Temp workspace scaffold ───────────────────────────────────────
@@ -138,7 +136,8 @@ describe("ensureGuardianPersonaFile", () => {
     const userFile = "alice.md";
     const dir = join(mockWorkspaceDir, "users");
     const filePath = join(dir, userFile);
-    const existingContent = "# Existing user notes\n\n- Likes sparkling water\n";
+    const existingContent =
+      "# Existing user notes\n\n- Likes sparkling water\n";
 
     mkdirSync(dir, { recursive: true });
     writeFileSync(filePath, existingContent, "utf-8");
@@ -249,3 +248,39 @@ describe("isGuardianPersonaCustomized", () => {
     expect(isGuardianPersonaCustomized(filePath)).toBe(true);
   });
 });
+
+// ── resolveUserSlug — background/scheduled guardian turns ──────────
+//
+// Background and scheduled turns carry a guardian trust context with no
+// `requesterExternalUserId`. They must resolve the guardian's user file
+// (parity with foreground guardian turns), not fall through to default.
+
+describe("resolveUserSlug (guardian trust, no requester identity)", () => {
+  test("guardian trust context without requesterExternalUserId resolves the guardian user file", () => {
+    mockVellumGuardian = {
+      contact: { userFile: "alice.md" },
+      channel: {},
+    };
+
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBe("alice");
+  });
+
+  test("non-guardian trust context without requesterExternalUserId does not borrow the guardian persona", () => {
+    mockVellumGuardian = {
+      contact: { userFile: "alice.md" },
+      channel: {},
+    };
+
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "trusted_contact",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBeNull();
+  });
+});

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

@@ -0,0 +1,178 @@
+import { writeFileSync } from "node:fs";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { invalidateConfigCache } from "../config/loader.js";
+import { getModelProfiles } from "../plugin-api/index.js";
+import { getWorkspaceConfigPath } from "../util/platform.js";
+
+/**
+ * `getModelProfiles()` — the runtime handle a plugin (e.g. a model router) calls
+ * to learn which inference profiles a workspace defines. These tests pin its
+ * contract: presentation ordering (`profileOrder` then alphabetical tail), mix
+ * profiles included and flagged via `isMix`, disabled profiles included and
+ * flagged via `isDisabled`, and the per-field fallbacks (label → key,
+ * description → null, isActive → `llm.activeProfile`).
+ */
+
+function writeFixtureConfig(config: Record<string, unknown>): void {
+  writeFileSync(getWorkspaceConfigPath(), JSON.stringify(config), "utf-8");
+  invalidateConfigCache();
+}
+
+describe("getModelProfiles", () => {
+  afterEach(() => {
+    invalidateConfigCache();
+  });
+
+  test("orders profiles by profileOrder then the remaining keys alphabetically", () => {
+    // GIVEN a workspace whose profileOrder names some keys, with a duplicate
+    // ("balanced") and a key that resolves to no profile ("ghost").
+    writeFixtureConfig({
+      llm: {
+        profiles: { zeta: {}, alpha: {}, balanced: {}, "cost-optimized": {} },
+        profileOrder: ["balanced", "cost-optimized", "balanced", "ghost"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const keys = getModelProfiles().map((p) => p.key);
+    // THEN profileOrder keys come first (deduped, existing-only), then the rest
+    // alphabetically.
+    expect(keys).toEqual(["balanced", "cost-optimized", "alpha", "zeta"]);
+  });
+
+  test("includes mix profiles and flags them via isMix", () => {
+    // GIVEN a workspace with a weighted mix profile alongside plain ones.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          alpha: {},
+          beta: {},
+          blend: {
+            mix: [
+              { profile: "alpha", weight: 1 },
+              { profile: "beta", weight: 1 },
+            ],
+          },
+        },
+        profileOrder: ["alpha", "beta", "blend"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const flags = getModelProfiles().map((p) => [p.key, p.isMix]);
+    // THEN the mix profile is present and flagged isMix, while plain profiles are not.
+    expect(flags).toEqual([
+      ["alpha", false],
+      ["beta", false],
+      ["blend", true],
+    ]);
+  });
+
+  test("marks an active mix profile via isActive", () => {
+    // GIVEN a workspace whose activeProfile is itself a weighted mix.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          alpha: {},
+          blend: {
+            mix: [
+              { profile: "alpha", weight: 1 },
+              { profile: "beta", weight: 1 },
+            ],
+          },
+          beta: {},
+        },
+        profileOrder: ["alpha", "blend", "beta"],
+        activeProfile: "blend",
+      },
+    });
+    // WHEN the profiles are listed.
+    const active = getModelProfiles()
+      .filter((p) => p.isActive)
+      .map((p) => p.key);
+    // THEN the active mix profile is the one flagged isActive.
+    expect(active).toEqual(["blend"]);
+  });
+
+  test("includes disabled profiles and flags them via isDisabled", () => {
+    // GIVEN a workspace with one active and one disabled profile.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          alpha: { status: "active" },
+          beta: { status: "disabled" },
+        },
+        profileOrder: ["alpha", "beta"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const flags = getModelProfiles().map((p) => [p.key, p.isDisabled]);
+    // THEN the disabled profile is present and marked isDisabled.
+    expect(flags).toEqual([
+      ["alpha", false],
+      ["beta", true],
+    ]);
+  });
+
+  test("falls back to the key when a profile has no label", () => {
+    // GIVEN a workspace where one profile sets a label and one does not.
+    writeFixtureConfig({
+      llm: {
+        profiles: { balanced: { label: "Balanced" }, terse: {} },
+        profileOrder: ["balanced", "terse"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const byKey = Object.fromEntries(
+      getModelProfiles().map((p) => [p.key, p.label]),
+    );
+    // THEN the unlabeled profile's label falls back to its key.
+    expect(byKey.balanced).toBe("Balanced");
+    expect(byKey.terse).toBe("terse");
+  });
+
+  test("marks the workspace active profile via isActive", () => {
+    // GIVEN a workspace whose activeProfile is "beta".
+    writeFixtureConfig({
+      llm: {
+        profiles: { alpha: {}, beta: {} },
+        profileOrder: ["alpha", "beta"],
+        activeProfile: "beta",
+      },
+    });
+    // WHEN the profiles are listed.
+    const flags = getModelProfiles().map((p) => [p.key, p.isActive]);
+    // THEN only the active profile is marked isActive.
+    expect(flags).toEqual([
+      ["alpha", false],
+      ["beta", true],
+    ]);
+  });
+
+  test("reports description as null when a profile sets none", () => {
+    // GIVEN a workspace where one profile has a description and one does not.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          documented: { description: "Cheaper models, slower" },
+          bare: {},
+        },
+        profileOrder: ["documented", "bare"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const byKey = Object.fromEntries(
+      getModelProfiles().map((p) => [p.key, p.description]),
+    );
+    // THEN a missing description is reported as null.
+    expect(byKey.documented).toBe("Cheaper models, slower");
+    expect(byKey.bare).toBeNull();
+  });
+
+  test("returns an empty list when the workspace defines no profiles", () => {
+    // GIVEN a workspace with no profiles defined.
+    writeFixtureConfig({ llm: { profiles: {}, profileOrder: [] } });
+    // WHEN the profiles are listed.
+    // THEN the result is empty.
+    expect(getModelProfiles()).toEqual([]);
+  });
+});

package/src/__tests__/plugin-api-provider.test.ts

@@ -0,0 +1,24 @@
+/**
+ * `getConfiguredProvider` is part of the public `@vellumai/plugin-api` runtime
+ * surface, so a user-installable plugin can run inference through the
+ * workspace's configured profiles/credentials (managed-proxy or BYOK) without
+ * supplying its own API key.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { PLUGIN_API_EXPORTS } from "../embedded/plugin-api.js";
+import * as pluginApi from "../plugin-api/index.js";
+
+describe("plugin-api provider access", () => {
+  test("getConfiguredProvider is exported as a runtime value", () => {
+    expect(typeof pluginApi.getConfiguredProvider).toBe("function");
+  });
+
+  test("getConfiguredProvider is in the shim-rebound runtime surface", () => {
+    // The boot-time shim re-binds every name in PLUGIN_API_EXPORTS from the
+    // globalThis-parked namespace, so a plugin importing the bare specifier
+    // gets the assistant's real resolver (bound to its initialized provider
+    // registry), not a disjoint, uninitialized module copy.
+    expect(PLUGIN_API_EXPORTS).toContain("getConfiguredProvider");
+  });
+});

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -190,13 +190,16 @@ describe("plugin tool contributions", () => {
     registerPlugin(plugin);
 
     await bootstrapPlugins();
-    // No tool should have been registered.
-    expect(getAllTools()).toHaveLength(0);
+    // `bootstrapPlugins` also registers the first-party defaults (the advisor
+    // default contributes the `advisor` tool), so the global tool set is not
+    // empty. What matters here is that the no-tools plugin contributed nothing
+    // of its own — its tool refcount stays at zero.
+    expect(getPluginRefCount("no-tools")).toBe(0);
 
     // Shutdown must also be safe — `unregisterPluginTools` is idempotent for
     // plugins that never contributed any tools.
     await runShutdownHooks("test-shutdown");
-    expect(getAllTools()).toHaveLength(0);
+    expect(getPluginRefCount("no-tools")).toBe(0);
   });
 
   test("tools declared before init() runs are only visible after bootstrap", async () => {

package/src/__tests__/post-compaction-reinjection-idempotency.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Post-compaction re-injection idempotency.
+ *
+ * The agent loop hands the post-compaction hook the full injected continuation
+ * history (it does not pre-strip it), so the hook must clear the tail's stale
+ * per-turn injection blocks before re-applying them. Without that strip,
+ * `applyRuntimeInjections` double-stacks every non-presence-gated block —
+ * `<turn_context>`, `<config_reset_notice>`, `<active_documents>`,
+ * `<document_comments>` — because it appends to the tail without removing an
+ * existing copy. These tests cover the strip primitive directly and the
+ * end-to-end re-injection it protects.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.js";
+import { stripTailInjectionsForReinjection } from "../plugins/defaults/memory-retrieval/tail-reinjection-strip.js";
+import type { Message } from "../providers/types.js";
+
+const WORKSPACE_BLOCK = "<workspace>\nRoot: /sandbox\n</workspace>";
+const INFO_BLOCK = "<info>\nRemembered fact about project-x\n</info>";
+const TURN_CONTEXT_BLOCK =
+  "<turn_context>\ncurrent_time: noon\n</turn_context>";
+const CONFIG_RESET_BLOCK =
+  "<config_reset_notice>\nSettings were reset.\n</config_reset_notice>";
+const ACTIVE_DOCUMENTS_BLOCK =
+  "<active_documents>\nThe following documents are open: notes.md\n</active_documents>";
+const DOCUMENT_COMMENTS_BLOCK =
+  "<document_comments>\nOpen comments on notes.md\n</document_comments>";
+const TURN_BODY = "Please continue the task.";
+
+function userMsg(...texts: string[]): Message {
+  return {
+    role: "user",
+    content: texts.map((text) => ({ type: "text" as const, text })),
+  };
+}
+
+function assistantMsg(text: string): Message {
+  return { role: "assistant", content: [{ type: "text", text }] };
+}
+
+function tailContentTexts(messages: Message[]): string[] {
+  const last = messages[messages.length - 1];
+  return last.content.map((block) => (block.type === "text" ? block.text : ""));
+}
+
+function countTailBlocksWithPrefix(
+  messages: Message[],
+  prefix: string,
+): number {
+  return tailContentTexts(messages).filter((text) => text.startsWith(prefix))
+    .length;
+}
+
+describe("stripTailInjectionsForReinjection", () => {
+  test("clears every per-turn injection block from the tail user message", () => {
+    // GIVEN a tail user message carrying the real turn body plus the full
+    // per-turn injection set, including the four blocks compaction keeps in
+    // durable history
+    const messages: Message[] = [
+      userMsg(
+        TURN_BODY,
+        WORKSPACE_BLOCK,
+        INFO_BLOCK,
+        TURN_CONTEXT_BLOCK,
+        CONFIG_RESET_BLOCK,
+        ACTIVE_DOCUMENTS_BLOCK,
+        DOCUMENT_COMMENTS_BLOCK,
+      ),
+    ];
+
+    // WHEN the tail injections are stripped for re-injection
+    const result = stripTailInjectionsForReinjection(messages);
+
+    // THEN only the real turn body survives on the tail
+    expect(tailContentTexts(result)).toEqual([TURN_BODY]);
+  });
+
+  test("leaves injection blocks on earlier messages untouched", () => {
+    // GIVEN an earlier user message and the tail both carrying a turn-context
+    // block
+    const messages: Message[] = [
+      userMsg("Earlier turn", TURN_CONTEXT_BLOCK),
+      assistantMsg("Working on it."),
+      userMsg(TURN_BODY, TURN_CONTEXT_BLOCK),
+    ];
+
+    // WHEN the tail injections are stripped
+    const result = stripTailInjectionsForReinjection(messages);
+
+    // THEN the earlier message keeps its historical turn-context grounding
+    expect(result[0].content).toHaveLength(2);
+    expect((result[0].content[1] as { text: string }).text).toBe(
+      TURN_CONTEXT_BLOCK,
+    );
+    // AND only the tail is cleared
+    expect(tailContentTexts(result)).toEqual([TURN_BODY]);
+  });
+
+  test("returns the messages unchanged when the tail carries no injections", () => {
+    // GIVEN a tail with only real user content
+    const messages: Message[] = [userMsg(TURN_BODY)];
+
+    // WHEN the tail injections are stripped
+    const result = stripTailInjectionsForReinjection(messages);
+
+    // THEN the array is returned unchanged
+    expect(result).toBe(messages);
+  });
+
+  test("preserves the tail user message even when every block is stripped", () => {
+    // GIVEN a tail composed entirely of injection blocks
+    const messages: Message[] = [
+      assistantMsg("Earlier reply."),
+      userMsg(WORKSPACE_BLOCK, TURN_CONTEXT_BLOCK),
+    ];
+
+    // WHEN the tail injections are stripped
+    const result = stripTailInjectionsForReinjection(messages);
+
+    // THEN the tail user message remains so the re-injection tail invariant
+    // holds, just with empty content
+    expect(result).toHaveLength(2);
+    expect(result[1].role).toBe("user");
+    expect(result[1].content).toHaveLength(0);
+  });
+
+  test("is idempotent — stripping an already-stripped tail is a no-op", () => {
+    // GIVEN a tail that has already been stripped once
+    const messages: Message[] = [userMsg(TURN_BODY, TURN_CONTEXT_BLOCK)];
+    const once = stripTailInjectionsForReinjection(messages);
+
+    // WHEN it is stripped again
+    const twice = stripTailInjectionsForReinjection(once);
+
+    // THEN the second strip changes nothing
+    expect(twice).toBe(once);
+    expect(tailContentTexts(twice)).toEqual([TURN_BODY]);
+  });
+});
+
+describe("applyRuntimeInjections re-injection idempotency", () => {
+  // `applyRuntimeInjections` synthesizes this conversation id when no
+  // turnContext is supplied, so the injectors resolve their blocks from the
+  // registry under this key.
+  const FALLBACK_CONVERSATION_ID = "runtime-assembly-fallback";
+
+  // Seed the fallback conversation with a workspace block (presence-gated) and
+  // a frozen temporal snapshot so the non-presence-gated `<turn_context>` block
+  // is produced every assembly.
+  function seedConversation(): void {
+    setConversation(FALLBACK_CONVERSATION_ID, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: WORKSPACE_BLOCK,
+      workspaceTopLevelDirty: false,
+      currentTurnTemporalSnapshot: { clientTimezone: null },
+    } as never);
+  }
+
+  afterEach(() => {
+    clearConversations();
+  });
+
+  test("re-injecting an already-injected base without the strip double-stacks the non-presence-gated block", async () => {
+    // GIVEN a fresh turn assembled once, so its tail carries one workspace and
+    // one turn-context block
+    seedConversation();
+    const { messages: injectedOnce } = await applyRuntimeInjections(
+      [userMsg(TURN_BODY)],
+      { conversationId: FALLBACK_CONVERSATION_ID },
+    );
+    expect(countTailBlocksWithPrefix(injectedOnce, "<turn_context>")).toBe(1);
+
+    // WHEN injections are applied again to that already-injected base
+    const { messages: injectedTwice } = await applyRuntimeInjections(
+      injectedOnce,
+      { conversationId: FALLBACK_CONVERSATION_ID },
+    );
+
+    // THEN the non-presence-gated turn-context block double-stacks
+    expect(countTailBlocksWithPrefix(injectedTwice, "<turn_context>")).toBe(2);
+    // AND the presence-gated workspace block stays single
+    expect(countTailBlocksWithPrefix(injectedTwice, "<workspace>")).toBe(1);
+  });
+
+  test("stripping the tail before re-injecting keeps every block single", async () => {
+    // GIVEN a fresh turn assembled once
+    seedConversation();
+    const { messages: injectedOnce } = await applyRuntimeInjections(
+      [userMsg(TURN_BODY)],
+      { conversationId: FALLBACK_CONVERSATION_ID },
+    );
+
+    // WHEN the tail is stripped before re-injection, exactly as the
+    // post-compaction hook does
+    const { messages: reinjected } = await applyRuntimeInjections(
+      stripTailInjectionsForReinjection(injectedOnce),
+      { conversationId: FALLBACK_CONVERSATION_ID },
+    );
+
+    // THEN both the non-presence-gated and presence-gated blocks stay single
+    expect(countTailBlocksWithPrefix(reinjected, "<turn_context>")).toBe(1);
+    expect(countTailBlocksWithPrefix(reinjected, "<workspace>")).toBe(1);
+    // AND the real turn body survives
+    expect(
+      tailContentTexts(reinjected).some((text) => text === TURN_BODY),
+    ).toBe(true);
+  });
+});

package/src/__tests__/provider-send-message-override-profile.test.ts

@@ -261,3 +261,79 @@ describe("SendMessageOptions.config.overrideProfile", () => {
     expect(captured?.overrideProfile).toBeUndefined();
   });
 });
+
+describe("SendMessageOptions.config.forceOverrideProfile", () => {
+  test("CallSiteConfiguredProvider forwards forceOverrideProfile into the send config", async () => {
+    let captured: SendMessageOptions | undefined;
+    const inner: Provider = {
+      name: "anthropic",
+      async sendMessage(
+        _messages: Message[],
+        options?: SendMessageOptions,
+      ): Promise<ProviderResponse> {
+        captured = options;
+        return makeResponse("anthropic");
+      },
+    };
+
+    const provider = new CallSiteConfiguredProvider(
+      inner,
+      "inference",
+      "strong",
+      true,
+    );
+    await provider.sendMessage(DUMMY_MESSAGES, {});
+
+    expect(captured?.config).toMatchObject({
+      callSite: "inference",
+      overrideProfile: "strong",
+      forceOverrideProfile: true,
+    });
+  });
+
+  test("forceOverrideProfile floats the override above a call-site profile pin", async () => {
+    // The advisor scenario in miniature: the `inference` call site is pinned to
+    // a cheap profile, but a caller forces a stronger profile for its own send.
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      profiles: {
+        cheap: { provider: "anthropic", model: "claude-haiku-4-5-20251001" },
+        strong: { provider: "anthropic", model: "claude-opus-4-8" },
+      },
+      callSites: { inference: { profile: "cheap" } },
+    });
+
+    const send = async (force: boolean) => {
+      let captured: Record<string, unknown> | undefined;
+      const inner: Provider = {
+        name: "anthropic",
+        async sendMessage(
+          _messages: Message[],
+          options?: SendMessageOptions,
+        ): Promise<ProviderResponse> {
+          captured = options?.config as Record<string, unknown> | undefined;
+          return makeResponse("anthropic");
+        },
+      };
+      const provider = new RetryProvider(inner);
+      await provider.sendMessage(DUMMY_MESSAGES, {
+        config: {
+          callSite: "inference",
+          overrideProfile: "strong",
+          ...(force ? { forceOverrideProfile: true } : {}),
+        },
+      });
+      return captured;
+    };
+
+    // Without the flag, the call-site pin (`cheap`) outranks `overrideProfile`.
+    expect((await send(false))?.model).toBe("claude-haiku-4-5-20251001");
+
+    // With the flag, the forced `strong` profile wins over the call-site pin.
+    const forced = await send(true);
+    expect(forced?.model).toBe("claude-opus-4-8");
+    // The routing keys are stripped before the provider wire request.
+    expect(forced?.overrideProfile).toBeUndefined();
+    expect(forced?.forceOverrideProfile).toBeUndefined();
+  });
+});