@vellumai/assistant 0.9.0 → 0.10.0-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.9.0",
+  "version": "0.10.0-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -53,6 +53,7 @@
     "@vellumai/twilio-client": "file:../packages/twilio-client",
     "commander": "13.1.0",
     "croner": "10.0.1",
+    "diff": "8.0.4",
     "dotenv": "17.3.1",
     "drizzle-orm": "0.45.2",
     "jszip": "3.10.1",

package/scripts/sync-llm-catalog.ts

@@ -3,19 +3,13 @@
  * Generate `llm-provider-catalog.json` from the canonical
  * `PROVIDER_CATALOG` in `assistant/src/providers/model-catalog.ts`.
  *
- * The JSON file is the client-facing catalog bundled into native clients
- * (macOS, web). Keeping it generated — rather than hand-mirrored — eliminates
- * the recurring "I edited model-catalog.ts and forgot the JSON" failure mode
- * that the parity test only catches after push.
+ * The JSON file is the client-facing catalog. Keeping it generated — rather
+ * than hand-mirrored — eliminates the recurring "I edited model-catalog.ts and
+ * forgot the JSON" failure mode that the parity test only catches after push.
  *
- * Two byte-identical copies are written:
+ * Output:
  *   - `meta/llm-provider-catalog.json` — primary checked-in artifact, read
- *      by web codegen (§D) and any non-Swift consumer.
- *   - `clients/shared/Resources/llm-provider-catalog.json` — SwiftPM resource
- *      bundled into `VellumAssistantShared`. SwiftPM cannot reach files
- *      outside a target's source directory, so this mirror is necessary;
- *      both files are produced by the same generator and asserted equal by
- *      the parity test, making drift impossible.
+ *      by web codegen (§D) and any downstream consumer.
  *
  * The projection drops daemon-only fields (today: `apiKeyUrl`, which clients
  * read from `credentialsGuide.url` instead) and pins field order so the
@@ -37,10 +31,7 @@ import {
 } from "../src/providers/model-catalog.js";
 
 const ROOT = resolve(import.meta.dir, "../..");
-const OUTPUT_PATHS = [
-  join(ROOT, "meta/llm-provider-catalog.json"),
-  join(ROOT, "clients/shared/Resources/llm-provider-catalog.json"),
-] as const;
+const OUTPUT_PATHS = [join(ROOT, "meta/llm-provider-catalog.json")] as const;
 
 /**
  * Bumped when the *shape* of the client catalog JSON changes in a way native

package/scripts/sync-web-search-catalog.ts

@@ -4,7 +4,7 @@
  * canonical `SEARCH_PROVIDER_CATALOG` in
  * `assistant/src/providers/search-provider-catalog.ts`.
  *
- * Two byte-identical copies are written:
+ * Output:
  *   - `meta/web-search-provider-catalog.json` — primary checked-in artifact,
  *      consumed by:
  *        - `cli/src/__tests__/search-provider-env-var-parity.test.ts`
@@ -12,13 +12,8 @@
  *        - Downstream `vellum-assistant-platform/web/src/lib/generated/
  *          web-search-provider-catalog.json` (manually sync'd today; the
  *          scheduled sync workflow is a planned follow-up).
- *   - `clients/shared/Resources/web-search-provider-catalog.json` — SwiftPM
- *      resource bundled into `VellumAssistantShared`. SwiftPM cannot reach
- *      files outside a target's source directory, so this mirror is
- *      necessary; both files are produced by the same generator and
- *      asserted equal by the parity test, making drift impossible.
  *
- * Companion to `sync-llm-catalog.ts`; same dual-write pattern.
+ * Companion to `sync-llm-catalog.ts`.
  *
  * Usage:
  *   cd assistant && bun run scripts/sync-web-search-catalog.ts
@@ -37,7 +32,6 @@ import {
 const ROOT = resolve(import.meta.dir, "../..");
 const OUTPUT_PATHS = [
   join(ROOT, "meta/web-search-provider-catalog.json"),
-  join(ROOT, "clients/shared/Resources/web-search-provider-catalog.json"),
 ] as const;
 
 /**
@@ -108,9 +102,7 @@ async function main(): Promise<void> {
         continue;
       }
       if (existing !== next) {
-        console.error(
-          `${rel} is stale. Run: bun run sync:web-search-catalog`,
-        );
+        console.error(`${rel} is stale. Run: bun run sync:web-search-catalog`);
         anyStale = true;
         continue;
       }

package/src/__tests__/access-request-card-view.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  buildAccessRequestCardView,
+  parseAccessRequestPayload,
+} from "../notifications/access-request-copy.js";
+
+function view(raw: Record<string, unknown>) {
+  return buildAccessRequestCardView(parseAccessRequestPayload(raw));
+}
+
+const TAB = String.fromCharCode(9);
+
+describe("buildAccessRequestCardView", () => {
+  test("prefers actorDisplayName, falls back to senderIdentifier then 'Someone'", () => {
+    expect(
+      view({ actorDisplayName: "Alice", senderIdentifier: "U999" }).displayName,
+    ).toBe("Alice");
+    expect(view({ senderIdentifier: "U999" }).displayName).toBe("U999");
+    expect(view({}).displayName).toBe("Someone");
+  });
+
+  test("sanitizes identity fields (strips control characters)", () => {
+    const v = view({
+      actorDisplayName: `Al${TAB}ice`,
+      actorUsername: `a${TAB}lice`,
+      actorExternalId: `U9${TAB}99`,
+    });
+    expect(v.displayName).toBe("Al ice");
+    expect(v.username).toBe("a lice");
+    expect(v.externalId).toBe("U9 99");
+  });
+
+  test("username and externalId are undefined when absent", () => {
+    const v = view({ actorDisplayName: "Alice" });
+    expect(v.username).toBeUndefined();
+    expect(v.externalId).toBeUndefined();
+  });
+
+  test("detects Slack DM conversations", () => {
+    expect(
+      view({ sourceChannel: "slack", conversationExternalId: "D01XYZ" })
+        .isSlackDm,
+    ).toBe(true);
+    expect(
+      view({ sourceChannel: "slack", conversationExternalId: "C01ABC" })
+        .isSlackDm,
+    ).toBe(false);
+    expect(
+      view({ sourceChannel: "telegram", conversationExternalId: "D01XYZ" })
+        .isSlackDm,
+    ).toBe(false);
+  });
+
+  test("builds a Slack permalink only with slack source + conversation + ts", () => {
+    expect(
+      view({
+        sourceChannel: "slack",
+        conversationExternalId: "C01ABC",
+        messageTs: "1700000000.000100",
+      }).messagePermalink,
+    ).toBe("https://slack.com/archives/C01ABC/p1700000000000100");
+    expect(
+      view({ sourceChannel: "slack", conversationExternalId: "C01ABC" })
+        .messagePermalink,
+    ).toBeUndefined();
+    expect(
+      view({
+        sourceChannel: "telegram",
+        conversationExternalId: "C01ABC",
+        messageTs: "1.2",
+      }).messagePermalink,
+    ).toBeUndefined();
+  });
+
+  test("sanitizes message preview and yields undefined when blank after sanitizing", () => {
+    expect(view({ messagePreview: "  hello  " }).messagePreview).toBe("hello");
+    // Blank / control-character-only previews sanitize to empty → undefined
+    // (no empty quote block is rendered downstream).
+    expect(view({ messagePreview: "" }).messagePreview).toBeUndefined();
+    expect(view({ messagePreview: "   " }).messagePreview).toBeUndefined();
+    expect(view({}).messagePreview).toBeUndefined();
+  });
+
+  test("collects trust/security warnings", () => {
+    const v = view({
+      isStranger: true,
+      isRestricted: true,
+      previousMemberStatus: "revoked",
+    });
+    expect(v.warnings).toEqual([
+      "This user was previously revoked.",
+      "External Slack user (not in this workspace).",
+      "Guest / restricted account.",
+    ]);
+    expect(view({}).warnings).toEqual([]);
+  });
+});

package/src/__tests__/access-request-seed-content-blocks.test.ts

@@ -1,9 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  buildAccessRequestSeedContentBlocks,
-  parseAccessRequestPayload,
-} from "../notifications/access-request-copy.js";
+import { parseAccessRequestPayload } from "../notifications/access-request-copy.js";
+import { buildAccessRequestSeedContentBlocks } from "../notifications/approval-card-data.js";
 
 describe("buildAccessRequestSeedContentBlocks", () => {
   const basePayload: Record<string, unknown> = {

package/src/__tests__/actor-trust-resolver-address-fallback.test.ts

@@ -1,16 +1,14 @@
 /**
- * Tests for the address-fallback path in resolveActorTrust.
+ * Tests for address-based member resolution in resolveActorTrust.
  *
- * Phone channels registered by the inbound name-capture flow have `address`
- * set (E.164) but `externalUserId` = NULL until DTMF verification completes.
- * The primary `findContactByChannelExternalId` lookup misses these channels,
- * which historically caused the relay router to fall into the name-capture
- * ("I don't recognize this number") path instead of the unverified-caller
- * guidance path.
+ * All member lookups use the canonical (type, address) path — the address
+ * column is the sole identity for all channel types. Phone channels
+ * registered by the inbound name-capture flow have `address` set (E.164)
+ * and are discovered through the same path as every other channel.
  *
- * This suite verifies that the address-based fallback fires correctly and
- * that the returned `memberRecord` carries the right channel/status so
- * relay-setup-router can emit the `unverified_caller` outcome.
+ * This suite verifies that address-based lookup returns the correct
+ * `memberRecord` with the right channel/status so relay-setup-router
+ * can emit the appropriate outcome (e.g. `unverified_caller`).
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -22,18 +20,14 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // ── Contact store stubs — filled in per test ─────────────────────────────────
-let _byExternalId: ReturnType<
-  typeof import("../contacts/contact-store.js")["findContactByChannelExternalId"]
-> = null;
 let _byAddress: ReturnType<
-  typeof import("../contacts/contact-store.js")["findContactByAddress"]
+  (typeof import("../contacts/contact-store.js"))["findContactByAddress"]
 > = null;
 let _guardian: ReturnType<
-  typeof import("../contacts/contact-store.js")["findGuardianForChannel"]
+  (typeof import("../contacts/contact-store.js"))["findGuardianForChannel"]
 > = null;
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByChannelExternalId: (_type: string, _id: string) => _byExternalId,
   findContactByAddress: (_type: string, _addr: string) => _byAddress,
   findGuardianForChannel: (_channel: string) => _guardian,
 }));
@@ -49,7 +43,6 @@ const PHONE = "+15559871234";
 function makeContact(
   role: "guardian" | "contact" = "contact",
   status: "unverified" | "active" = "unverified",
-  externalUserId: string | null = null,
 ): ContactWithChannels {
   const channelId = "ch-test";
   return {
@@ -69,8 +62,7 @@ function makeContact(
         id: channelId,
         contactId: "contact-test",
         type: "phone",
-        address: PHONE.toLowerCase(),
-        externalUserId,
+        address: PHONE,
         externalChatId: null,
         isPrimary: true,
         status,
@@ -94,14 +86,13 @@ function makeContact(
 
 describe("resolveActorTrust — address fallback", () => {
   beforeEach(() => {
-    _byExternalId = null;
     _byAddress = null;
     _guardian = null;
   });
 
   test("finds unverified channel via address when externalUserId is null", () => {
     // Simulate a contact registered by name-capture: address set, externalUserId null.
-    _byAddress = makeContact("contact", "unverified", null);
+    _byAddress = makeContact("contact", "unverified");
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -113,16 +104,13 @@ describe("resolveActorTrust — address fallback", () => {
     expect(result.memberRecord).not.toBeNull();
     expect(result.memberRecord?.contact.displayName).toBe("Patrick Test");
     expect(result.memberRecord?.channel.status).toBe("unverified");
-    // trustClass is 'unknown' for an unverified member (correct — not yet active)
-    expect(result.trustClass).toBe("unknown");
+    // trustClass is 'unverified_contact' for a member whose channel is
+    // pending or unverified — known to the guardian but not yet verified.
+    expect(result.trustClass).toBe("unverified_contact");
   });
 
-  test("externalUserId path takes priority over address path", () => {
-    // Both lookups return a contact; the externalUserId one should win.
-    const primaryContact = makeContact("contact", "active", PHONE);
-    const addressContact = makeContact("contact", "unverified", null);
-    _byExternalId = primaryContact;
-    _byAddress = addressContact;
+  test("address lookup is the sole member resolution path", () => {
+    _byAddress = makeContact("contact", "active");
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -132,11 +120,10 @@ describe("resolveActorTrust — address fallback", () => {
     });
 
     expect(result.memberRecord?.channel.status).toBe("active");
-    expect(result.memberRecord?.channel.externalUserId).toBe(PHONE);
+    expect(result.memberRecord?.channel.address).toBe(PHONE);
   });
 
   test("returns null memberRecord when neither lookup finds the number", () => {
-    _byExternalId = null;
     _byAddress = null;
 
     const result = resolveActorTrust({
@@ -153,7 +140,7 @@ describe("resolveActorTrust — address fallback", () => {
   test("address-found active channel elevates trust to trusted_contact", () => {
     // An active channel found via address (e.g. after manual verify without externalUserId set)
     // should still yield trusted_contact trust class.
-    _byAddress = makeContact("contact", "active", null);
+    _byAddress = makeContact("contact", "active");
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -166,4 +153,57 @@ describe("resolveActorTrust — address fallback", () => {
     expect(result.memberRecord?.channel.status).toBe("active");
     expect(result.trustClass).toBe("trusted_contact");
   });
+
+  test("pending-status member is classified as unverified_contact", () => {
+    // Mirrors the unverified branch but for `pending` status (e.g. a phone
+    // contact registered by name-capture awaiting the DTMF challenge).
+    const contact = makeContact("contact", "unverified");
+    // Override status to "pending" — makeContact only accepts unverified/active
+    contact.channels[0]!.status = "pending";
+    _byAddress = contact;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord?.channel.status).toBe("pending");
+    expect(result.trustClass).toBe("unverified_contact");
+  });
+
+  test("blocked-status member is classified as unknown (not unverified_contact)", () => {
+    // Hard-deny statuses (blocked, revoked) stay `unknown` — admission-layer
+    // re-checks channel.status and emits the hard-deny reasons.
+    const contact = makeContact("contact", "unverified");
+    contact.channels[0]!.status = "blocked";
+    _byAddress = contact;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord?.channel.status).toBe("blocked");
+    expect(result.trustClass).toBe("unknown");
+  });
+
+  test("revoked-status member is classified as unknown", () => {
+    const contact = makeContact("contact", "unverified");
+    contact.channels[0]!.status = "revoked";
+    _byAddress = contact;
+
+    const result = resolveActorTrust({
+      assistantId: "asst-1",
+      sourceChannel: "phone",
+      conversationExternalId: PHONE,
+      actorExternalId: PHONE,
+    });
+
+    expect(result.memberRecord?.channel.status).toBe("revoked");
+    expect(result.trustClass).toBe("unknown");
+  });
 });

package/src/__tests__/agent-loop-compaction-strip.test.ts

@@ -0,0 +1,241 @@
+/**
+ * The compaction summarizer's input.
+ *
+ * Both the budget gate and overflow recovery summarize the *injected* history
+ * (the genuine conversation as the agent saw it) so the summary call's prompt
+ * prefix matches the agent's warm prefix cache — a cache read rather than a
+ * fresh cache write. The agent loop hands the full injected history to
+ * compaction unconditionally; the post-compaction re-injection hook owns
+ * injection idempotency by stripping the tail's per-turn blocks before
+ * re-applying them.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type { PostCompactContext } from "@vellumai/plugin-api";
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import type { ContextWindowConfig } from "../config/types.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import { HOOKS } from "../plugin-api/constants.js";
+import {
+  createContextWindowManager,
+  disposeContextWindowManager,
+  getContextWindowManager,
+} from "../plugins/defaults/compaction/manager-store.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+import { ContextOverflowError } from "../providers/types.js";
+
+const testPostCompactPlugin = {
+  manifest: { name: "test-post-compact", version: "0.0.0" },
+  hooks: {
+    [HOOKS.POST_COMPACT]: async (input: PostCompactContext): Promise<void> => {
+      void input;
+    },
+  },
+};
+
+const CONVERSATION_ID = "compaction-strip-conversation";
+
+/**
+ * A runtime `<workspace>` injection block. Its presence in the summarizer's
+ * input proves compaction received the injected history rather than a stripped
+ * copy.
+ */
+const WORKSPACE_INJECTION =
+  "<workspace>\nActive workspace: project-x\n</workspace>";
+const TURN_BODY = "Hello there, this is the turn body.";
+
+/**
+ * A user turn carrying a real text block plus a runtime injection block, both
+ * of which ride into compaction's input as-is.
+ */
+const injectedUserMessage: Message = {
+  role: "user",
+  content: [
+    { type: "text", text: TURN_BODY },
+    { type: "text", text: WORKSPACE_INJECTION },
+  ],
+};
+
+function textResponse(text: string): ProviderResponse {
+  return {
+    content: [{ type: "text", text }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+  };
+}
+
+function createMockProvider(responses: ProviderResponse[]): Provider {
+  let callIndex = 0;
+  return {
+    name: "mock",
+    async sendMessage(
+      _messages: Message[],
+      _options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      const response = responses[callIndex] ?? responses[responses.length - 1];
+      callIndex++;
+      return response;
+    },
+  };
+}
+
+interface CompactionInputCapture {
+  budget: Message[] | null;
+  overflow: Message[] | null;
+}
+
+/**
+ * Install a per-conversation manager that records the messages handed to the
+ * budget summarizer (`maybeCompact`) and to overflow recovery
+ * (`recoverContextOverflow`).
+ */
+function installCapturingManager(capture: CompactionInputCapture): {
+  trust: TrustContext;
+} {
+  createContextWindowManager({
+    provider: { name: "mock-provider" } as unknown as Provider,
+    systemPrompt: "system",
+    config: {} as unknown as ContextWindowConfig,
+    conversationId: CONVERSATION_ID,
+  });
+  const manager = getContextWindowManager(CONVERSATION_ID);
+  if (manager) {
+    manager.maybeCompact = (async (messages: Message[]) => {
+      capture.budget = messages;
+      return {
+        messages: [injectedUserMessage],
+        compacted: true,
+        exhausted: false,
+      };
+    }) as unknown as typeof manager.maybeCompact;
+    manager.recoverContextOverflow = (async (messages: Message[]) => {
+      capture.overflow = messages;
+      return {
+        messages: [injectedUserMessage],
+        compacted: true,
+        exhausted: false,
+      };
+    }) as unknown as typeof manager.recoverContextOverflow;
+  }
+  return { trust: { sourceChannel: "vellum", trustClass: "unknown" } };
+}
+
+function serialize(messages: Message[] | null): string {
+  return JSON.stringify(messages ?? []);
+}
+
+describe("AgentLoop compaction summarizer input", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(testPostCompactPlugin);
+  });
+
+  afterEach(() => {
+    disposeContextWindowManager(CONVERSATION_ID);
+  });
+
+  test("budget-gate compaction summarizes the injected history", async () => {
+    // GIVEN a history whose user turn carries a runtime-injection block
+    const capture: CompactionInputCapture = { budget: null, overflow: null };
+    const provider = createMockProvider([
+      textResponse("done after compaction"),
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    const events: AgentEvent[] = [];
+
+    // WHEN the budget gate trips and in-place compaction runs
+    await loop.run({
+      requestId: "req",
+      messages: [injectedUserMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installCapturingManager(capture),
+    });
+
+    // THEN the budget summarizer received the injected history, injection intact
+    expect(capture.budget).not.toBeNull();
+    expect(serialize(capture.budget)).toContain("<workspace>");
+    // AND overflow recovery was not invoked
+    expect(capture.overflow).toBeNull();
+    // AND the history-stripped marker still fires for the durable base
+    expect(events.some((e) => e.type === "history_stripped")).toBe(true);
+  });
+
+  test("overflow-driven compaction summarizes the injected history", async () => {
+    // GIVEN a history whose user turn carries a runtime-injection block
+    const capture: CompactionInputCapture = { budget: null, overflow: null };
+
+    // AND a provider that rejects the first call as context-too-large
+    let throwOnce = true;
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(): Promise<ProviderResponse> {
+        if (throwOnce) {
+          throwOnce = false;
+          throw new ContextOverflowError("prompt too long", "mock", {
+            actualTokens: 999_999,
+          });
+        }
+        return textResponse("done after overflow recovery");
+      },
+    };
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    // A blocking watermark plus `compactInPlace: false` keep the budget gate
+    // from firing, so only the overflow rejection drives compaction.
+    loop.compactionCircuit.lastPostCompactionEstimate = 0;
+    const events: AgentEvent[] = [];
+
+    // WHEN the provider overflow forces overflow recovery
+    await loop.run({
+      requestId: "req",
+      messages: [injectedUserMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: false,
+      ...installCapturingManager(capture),
+    });
+
+    // THEN overflow recovery received the injected history, injection intact
+    expect(capture.overflow).not.toBeNull();
+    expect(serialize(capture.overflow)).toContain("<workspace>");
+    // AND the real turn body is present alongside the injection
+    expect(serialize(capture.overflow)).toContain(TURN_BODY);
+    // AND the budget summarizer was not invoked
+    expect(capture.budget).toBeNull();
+  });
+});