@vellumai/assistant 0.5.1 → 0.5.3

package/src/__tests__/memory-regressions.test.ts

@@ -3207,8 +3207,9 @@ describe("Memory regressions", () => {
       .filter((j) => JSON.parse(j.payload).messageId === "msg-untrusted-gate");
     expect(extractJobs.length).toBe(0);
 
-    // enqueuedJobs should reflect: embed jobs + summary (1), no extract (0)
-    const expectedJobs = result.indexedSegments + 1; // embed per segment + summary
+    // enqueuedJobs reflects legacy embed_segment + archive embed_chunk per
+    // segment, plus the summary job, with extract_items gated off.
+    const expectedJobs = result.indexedSegments * 2 + 1;
     expect(result.enqueuedJobs).toBe(expectedJobs);
   });
 
@@ -3389,8 +3390,9 @@ describe("Memory regressions", () => {
       .filter((j) => JSON.parse(j.payload).messageId === "msg-unverified-gate");
     expect(extractJobs.length).toBe(0);
 
-    // enqueuedJobs should reflect: embed jobs + summary (1), no extract (0)
-    const expectedJobs = result.indexedSegments + 1; // embed per segment + summary
+    // enqueuedJobs reflects legacy embed_segment + archive embed_chunk per
+    // segment, plus the summary job, with extract_items gated off.
+    const expectedJobs = result.indexedSegments * 2 + 1;
     expect(result.enqueuedJobs).toBe(expectedJobs);
   });
 

package/src/__tests__/memory-simplified-config.test.ts

@@ -0,0 +1,281 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that depend on platform/logger
+// ---------------------------------------------------------------------------
+
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-simplified-mem-test-${randomBytes(4).toString("hex")}`,
+);
+const WORKSPACE_DIR = join(TEST_DIR, "workspace");
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  const dirs = [
+    TEST_DIR,
+    WORKSPACE_DIR,
+    join(TEST_DIR, "data"),
+    join(TEST_DIR, "memory"),
+    join(TEST_DIR, "memory", "knowledge"),
+    join(TEST_DIR, "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => TEST_DIR,
+  getWorkspaceDir: () => WORKSPACE_DIR,
+  getWorkspaceConfigPath: () => CONFIG_PATH,
+  getDataDir: () => join(TEST_DIR, "data"),
+  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
+  ensureDataDir: () => ensureTestDir(),
+  isMacOS: () => false,
+  isLinux: () => false,
+  isWindows: () => false,
+}));
+
+import { invalidateConfigCache, loadConfig } from "../config/loader.js";
+import { AssistantConfigSchema } from "../config/schema.js";
+import { MemorySimplifiedConfigSchema } from "../config/schemas/memory-simplified.js";
+import { _setStorePath } from "../security/encrypted-store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function writeConfig(obj: unknown): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj));
+}
+
+// ---------------------------------------------------------------------------
+// Tests: MemorySimplifiedConfigSchema (unit)
+// ---------------------------------------------------------------------------
+
+describe("MemorySimplifiedConfigSchema", () => {
+  test("parses empty object with all defaults", () => {
+    const result = MemorySimplifiedConfigSchema.parse({});
+    expect(result).toEqual({
+      enabled: false,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("accepts explicit enabled=true", () => {
+    const result = MemorySimplifiedConfigSchema.parse({ enabled: true });
+    expect(result.enabled).toBe(true);
+  });
+
+  test("accepts custom brief.maxTokens", () => {
+    const result = MemorySimplifiedConfigSchema.parse({
+      brief: { maxTokens: 8000 },
+    });
+    expect(result.brief.maxTokens).toBe(8000);
+  });
+
+  test("accepts custom reducer values", () => {
+    const result = MemorySimplifiedConfigSchema.parse({
+      reducer: { idleDelayMs: 60_000, switchWaitMs: 10_000 },
+    });
+    expect(result.reducer.idleDelayMs).toBe(60_000);
+    expect(result.reducer.switchWaitMs).toBe(10_000);
+  });
+
+  test("accepts custom archiveRecall.maxSnippets", () => {
+    const result = MemorySimplifiedConfigSchema.parse({
+      archiveRecall: { maxSnippets: 20 },
+    });
+    expect(result.archiveRecall.maxSnippets).toBe(20);
+  });
+
+  test("rejects non-boolean enabled", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      enabled: "yes",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive brief.maxTokens", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      brief: { maxTokens: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-integer brief.maxTokens", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      brief: { maxTokens: 3.5 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive reducer.idleDelayMs", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      reducer: { idleDelayMs: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive reducer.switchWaitMs", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      reducer: { switchWaitMs: -1 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-positive archiveRecall.maxSnippets", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      archiveRecall: { maxSnippets: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-integer archiveRecall.maxSnippets", () => {
+    const result = MemorySimplifiedConfigSchema.safeParse({
+      archiveRecall: { maxSnippets: 2.5 },
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Wired into AssistantConfigSchema
+// ---------------------------------------------------------------------------
+
+describe("AssistantConfigSchema memory.simplified", () => {
+  test("empty config exposes memory.simplified with defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.memory.simplified).toEqual({
+      enabled: false,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("memory.simplified does not disturb legacy memory config", () => {
+    const result = AssistantConfigSchema.parse({});
+    // Legacy fields still present with their defaults
+    expect(result.memory.enabled).toBe(true);
+    expect(result.memory.retrieval).toBeDefined();
+    expect(result.memory.jobs).toBeDefined();
+    expect(result.memory.cleanup).toBeDefined();
+    expect(result.memory.extraction).toBeDefined();
+    expect(result.memory.summarization).toBeDefined();
+    expect(result.memory.segmentation).toBeDefined();
+    expect(result.memory.embeddings).toBeDefined();
+    expect(result.memory.qdrant).toBeDefined();
+    expect(result.memory.retention).toBeDefined();
+  });
+
+  test("accepts memory.simplified overrides alongside legacy config", () => {
+    const result = AssistantConfigSchema.parse({
+      memory: {
+        enabled: true,
+        simplified: {
+          enabled: true,
+          brief: { maxTokens: 6000 },
+        },
+      },
+    });
+    expect(result.memory.enabled).toBe(true);
+    expect(result.memory.simplified.enabled).toBe(true);
+    expect(result.memory.simplified.brief.maxTokens).toBe(6000);
+    // Defaults preserved for unset simplified fields
+    expect(result.memory.simplified.reducer.idleDelayMs).toBe(30_000);
+    expect(result.memory.simplified.archiveRecall.maxSnippets).toBe(10);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: loadConfig integration (empty config file loads cleanly)
+// ---------------------------------------------------------------------------
+
+describe("loadConfig with memory.simplified", () => {
+  beforeEach(() => {
+    ensureTestDir();
+    const resetPaths = [
+      CONFIG_PATH,
+      join(TEST_DIR, "keys.enc"),
+      join(TEST_DIR, "data"),
+      join(TEST_DIR, "memory"),
+    ];
+    for (const path of resetPaths) {
+      if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+      }
+    }
+    ensureTestDir();
+    _setStorePath(join(TEST_DIR, "keys.enc"));
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    invalidateConfigCache();
+  });
+
+  test("empty config file loads cleanly with simplified defaults", () => {
+    writeConfig({});
+    const config = loadConfig();
+    expect(config.memory.simplified).toEqual({
+      enabled: false,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("no config file loads cleanly with simplified defaults", () => {
+    const config = loadConfig();
+    expect(config.memory.simplified).toEqual({
+      enabled: false,
+      brief: { maxTokens: 4000 },
+      reducer: { idleDelayMs: 30_000, switchWaitMs: 5_000 },
+      archiveRecall: { maxSnippets: 10 },
+    });
+  });
+
+  test("existing memory config with simplified addition loads cleanly", () => {
+    writeConfig({
+      memory: {
+        enabled: true,
+        simplified: { enabled: true, brief: { maxTokens: 2000 } },
+      },
+    });
+    const config = loadConfig();
+    expect(config.memory.enabled).toBe(true);
+    expect(config.memory.simplified.enabled).toBe(true);
+    expect(config.memory.simplified.brief.maxTokens).toBe(2000);
+    expect(config.memory.simplified.reducer.idleDelayMs).toBe(30_000);
+  });
+});

package/src/__tests__/migration-cross-version-compatibility.test.ts

@@ -894,7 +894,10 @@ describe("partial failure scenarios", () => {
     const blockerWorkspace = join(testDir, "blocker-workspace");
     mkdirSync(blockerWorkspace, { recursive: true });
     // Create "data" as a regular file — mkdirSync("data/db") will fail
-    writeFileSync(join(blockerWorkspace, "data"), "I am a file, not a directory");
+    writeFileSync(
+      join(blockerWorkspace, "data"),
+      "I am a file, not a directory",
+    );
 
     const resolver = new DefaultPathResolver(undefined, blockerWorkspace);
     const result = commitImport({

package/src/__tests__/migration-export-http.test.ts

@@ -299,7 +299,9 @@ describe("export data population", () => {
     const archiveData = new Uint8Array(await res.arrayBuffer());
     const entries = parseTarEntries(archiveData);
 
-    const dbEntry = entries.find((e) => e.name === "workspace/data/db/assistant.db");
+    const dbEntry = entries.find(
+      (e) => e.name === "workspace/data/db/assistant.db",
+    );
     expect(dbEntry).toBeDefined();
     expect(dbEntry!.data.length).toBe(SQLITE_HEADER.length);
     // Verify the exported data matches the test fixture exactly

package/src/__tests__/migration-import-commit-http.test.ts

@@ -671,7 +671,12 @@ describe("commitImport", () => {
   test("creates parent directories if they do not exist", () => {
     // Use a workspace that does not exist yet
     const nonexistentWorkspace = join(testDir, "new-workspace");
-    const expectedDbPath = join(nonexistentWorkspace, "data", "db", "assistant.db");
+    const expectedDbPath = join(
+      nonexistentWorkspace,
+      "data",
+      "db",
+      "assistant.db",
+    );
 
     const dbData = new Uint8Array([0x01, 0x02, 0x03]);
     const vbundle = createValidVBundle([
@@ -836,7 +841,11 @@ describe("commitImport — workspace clearing", () => {
       { path: "hooks/new-hook/hook.sh", data: hookData },
     ]);
 
-    const resolver = new DefaultPathResolver(undefined, testDir, externalHooksDir);
+    const resolver = new DefaultPathResolver(
+      undefined,
+      testDir,
+      externalHooksDir,
+    );
     const result = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -847,7 +856,9 @@ describe("commitImport — workspace clearing", () => {
     if (!result.ok) return;
 
     // Hook written to the external hooks dir, not workspace/hooks/
-    expect(existsSync(join(externalHooksDir, "new-hook", "hook.sh"))).toBe(true);
+    expect(existsSync(join(externalHooksDir, "new-hook", "hook.sh"))).toBe(
+      true,
+    );
     expect(
       readFileSync(join(externalHooksDir, "new-hook", "hook.sh"), "utf8"),
     ).toBe("#!/bin/sh\necho new");
@@ -864,7 +875,10 @@ describe("commitImport — workspace clearing", () => {
     );
 
     const vbundle = createValidVBundle([
-      { path: "skills/new-skill/SKILL.md", data: new TextEncoder().encode("new") },
+      {
+        path: "skills/new-skill/SKILL.md",
+        data: new TextEncoder().encode("new"),
+      },
     ]);
 
     const resolver = new DefaultPathResolver(undefined, testDir);

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -743,9 +743,7 @@ describe("DefaultPathResolver", () => {
       undefined,
       "/home/user/.vellum/workspace",
     );
-    expect(
-      resolver.resolve("skills/../../../.ssh/authorized_keys"),
-    ).toBeNull();
+    expect(resolver.resolve("skills/../../../.ssh/authorized_keys")).toBeNull();
   });
 
   test("returns null for skills paths when workspaceDir is not provided", () => {

package/src/__tests__/mime-builder.test.ts

@@ -98,7 +98,9 @@ describe("buildMultipartMime", () => {
       "base64",
     ).toString("utf-8");
 
-    expect(decoded).toContain("To: victim@example.com Bcc: attacker@example.com");
+    expect(decoded).toContain(
+      "To: victim@example.com Bcc: attacker@example.com",
+    );
     expect(decoded).toContain("Subject: Fwd: Hello Cc: attacker@example.com");
     expect(decoded).toContain("Cc: team@example.com X-Injected: yes");
     expect(decoded).toContain("Bcc: audit@example.com X-Another: value");
@@ -108,5 +110,4 @@ describe("buildMultipartMime", () => {
     expect(decoded).not.toContain("\r\nBcc: attacker@example.com");
     expect(decoded).not.toContain("\r\nCc: attacker@example.com");
   });
-
 });

package/src/__tests__/non-member-access-request.test.ts

@@ -624,6 +624,17 @@ describe("access-request-helper unit tests", () => {
   });
 
   test("notifyGuardianOfAccessRequest skips vellum fallback for same-channel-only routing (telegram)", async () => {
+    // Set up a telegram guardian binding with the anchor principal so
+    // guardianResolutionSource resolves to "source-channel-contact" and
+    // sameChannelOnly is true.
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "guardian-user-456",
+      guardianDeliveryChatId: "guardian-chat-456",
+      guardianPrincipalId: anchorPrincipalId,
+      verifiedVia: "test",
+    });
+
     mockEmitResult = {
       signalId: "sig-no-vellum",
       deduplicated: false,
@@ -657,7 +668,7 @@ describe("access-request-helper unit tests", () => {
       (d) => d.destinationChannel === "telegram",
     );
 
-    // Same-channel routing skips vellum delivery entirely — no fallback record
+    // Guardian IS verified on telegram → sameChannelOnly, no vellum fallback
     expect(vellum).toBeUndefined();
     expect(telegram).toBeDefined();
     expect(telegram!.destinationChatId).toBe("guardian-chat-456");

package/src/__tests__/notification-decision-identity.test.ts

@@ -185,6 +185,58 @@ describe("identity context in notification decision engine", () => {
     expect(capturedSystemPrompt).not.toContain("</assistant-identity>");
   });
 
+  test("large identity context is truncated in system prompt", async () => {
+    // Create an identity context that exceeds the 2000-char budget
+    mockIdentityContext = "A".repeat(3000);
+
+    configuredProvider = {
+      sendMessage: async (
+        _messages: unknown,
+        _tools: unknown,
+        systemPrompt: unknown,
+      ) => {
+        capturedSystemPrompt = systemPrompt as string;
+        return { content: [] };
+      },
+    };
+    extractedToolUse = {
+      name: "record_notification_decision",
+      input: {
+        shouldNotify: true,
+        selectedChannels: ["vellum"],
+        reasoningSummary: "LLM decision with truncated identity",
+        renderedCopy: {
+          vellum: {
+            title: "Guardian Question",
+            body: "What is the gate code?",
+          },
+        },
+        dedupeKey: "identity-truncated-test",
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal();
+    await evaluateSignal(signal, ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).toBeDefined();
+    expect(capturedSystemPrompt).toContain("<assistant-identity>");
+    // The identity block should exist but should NOT contain the full 3000-char string
+    expect(capturedSystemPrompt).not.toContain("A".repeat(3000));
+    // It should contain the truncation marker
+    expect(capturedSystemPrompt).toContain("…[truncated]");
+    // The identity content within the block should be at most 2000 chars
+    const identityMatch = capturedSystemPrompt!.match(
+      /<assistant-identity>([\s\S]*?)<\/assistant-identity>/,
+    );
+    expect(identityMatch).toBeTruthy();
+    // The identity block includes the instruction text + the truncated context.
+    // Verify the raw identity portion is bounded.
+    const identityBlock = identityMatch![1];
+    expect(identityBlock).toContain("…[truncated]");
+    expect(identityBlock).not.toContain("A".repeat(2001));
+  });
+
   test("fallback path does not include identity context", async () => {
     mockIdentityContext = "I am Jarvis, a helpful assistant";
 

package/src/__tests__/oauth-apps-routes.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, mock, test } from "bun:test";
+
+const mockGetApp = mock((_appId: string) => ({
+  id: "app-1",
+  providerKey: "google",
+  clientId: "client-1",
+}));
+
+const mockListConnections = mock(() => [
+  {
+    id: "conn-1",
+    providerKey: "google",
+    accountInfo: "{\"email\":\"alice@example.com\"}",
+    grantedScopes: '["email","profile"]',
+    status: "active",
+    hasRefreshToken: 1,
+    expiresAt: 1735689600000,
+    createdAt: 1735689500000,
+    updatedAt: 1735689550000,
+  },
+  {
+    id: "conn-2",
+    providerKey: "google",
+    accountInfo: null,
+    grantedScopes: [],
+    status: "active",
+    hasRefreshToken: 0,
+    expiresAt: null,
+    createdAt: 1735689601000,
+    updatedAt: 1735689602000,
+  },
+]);
+
+mock.module("../oauth/oauth-store.js", () => ({
+  deleteApp: mock(() => Promise.resolve()),
+  disconnectOAuthProvider: mock(() => Promise.resolve()),
+  getApp: mockGetApp,
+  getAppClientSecret: mock(() => Promise.resolve(undefined)),
+  getConnection: mock(() => undefined),
+  getProvider: mock(() => undefined),
+  listApps: mock(() => []),
+  listConnections: mockListConnections,
+  upsertApp: mock(() =>
+    Promise.resolve({
+      id: "app-1",
+      providerKey: "google",
+      clientId: "client-1",
+      createdAt: 1735689500000,
+      updatedAt: 1735689550000,
+    }),
+  ),
+}));
+
+mock.module("../oauth/connect-orchestrator.js", () => ({
+  orchestrateOAuthConnect: mock(() =>
+    Promise.resolve({
+      success: true,
+      deferred: false,
+      grantedScopes: [],
+      accountInfo: null,
+      refreshTokenPresent: false,
+    }),
+  ),
+}));
+
+import { oauthAppsRouteDefinitions } from "../runtime/routes/oauth-apps.js";
+
+const routes = oauthAppsRouteDefinitions();
+
+function getRoute(method: string, endpoint: string) {
+  const route = routes.find(
+    (r) => r.method === method && r.endpoint === endpoint,
+  );
+  if (!route) throw new Error(`Route not found: ${method} ${endpoint}`);
+  return route;
+}
+
+describe("GET /v1/oauth/apps/:appId/connections", () => {
+  test("normalizes granted_scopes and has_refresh_token", async () => {
+    const req = new Request("http://localhost/v1/oauth/apps/app-1/connections");
+    const url = new URL(req.url);
+    const res = await getRoute("GET", "oauth/apps/:appId/connections").handler({
+      req,
+      url,
+      server: null as never,
+      authContext: null as never,
+      params: { appId: "app-1" },
+    });
+
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      connections: Array<{
+        granted_scopes: unknown;
+        has_refresh_token: unknown;
+      }>;
+    };
+
+    expect(body.connections[0]?.granted_scopes).toEqual(["email", "profile"]);
+    expect(body.connections[0]?.has_refresh_token).toBe(true);
+    expect(body.connections[1]?.granted_scopes).toEqual([]);
+    expect(body.connections[1]?.has_refresh_token).toBe(false);
+  });
+});