@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

package/src/__tests__/approval-routes-http.test.ts

@@ -689,6 +689,82 @@ describe("standalone approval endpoints — HTTP layer", () => {
       await stopServer();
     });
 
+    test("cancels a secret request when value is omitted", async () => {
+      let secretRequestId: string | undefined;
+      let secretValue: string | undefined;
+
+      const session = makeIdleSession({
+        onSecret: (reqId, val) => {
+          secretRequestId = reqId;
+          secretValue = val;
+        },
+      });
+
+      await startServer(() => session);
+
+      pendingInteractions.register("secret-cancel-1", {
+        conversationId: "conv-1",
+        kind: "secret",
+      });
+
+      const res = await fetch(url("secret"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+        body: JSON.stringify({ requestId: "secret-cancel-1" }),
+      });
+      const body = (await res.json()) as { accepted: boolean };
+
+      expect(res.status).toBe(200);
+      expect(body.accepted).toBe(true);
+      expect(secretRequestId).toBe("secret-cancel-1");
+      expect(secretValue).toBeUndefined();
+      expect(pendingInteractions.get("secret-cancel-1")).toBeUndefined();
+
+      await stopServer();
+    });
+
+    test('legacy delivery "none" cancels the request without 400', async () => {
+      let secretRequestId: string | undefined;
+      let secretValue: string | undefined;
+      let secretDelivery: string | undefined;
+
+      const session = makeIdleSession({
+        onSecret: (reqId, val, del) => {
+          secretRequestId = reqId;
+          secretValue = val;
+          secretDelivery = del;
+        },
+      });
+
+      await startServer(() => session);
+
+      pendingInteractions.register("secret-legacy-cancel-1", {
+        conversationId: "conv-1",
+        kind: "secret",
+      });
+
+      const res = await fetch(url("secret"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+        body: JSON.stringify({
+          requestId: "secret-legacy-cancel-1",
+          value: "ignored-by-cancel",
+          delivery: "none",
+        }),
+      });
+      const body = (await res.json()) as { accepted: boolean };
+
+      expect(res.status).toBe(200);
+      expect(body.accepted).toBe(true);
+      expect(secretRequestId).toBe("secret-legacy-cancel-1");
+      // delivery "none" normalizes to the cancellation path: value/delivery dropped.
+      expect(secretValue).toBeUndefined();
+      expect(secretDelivery).toBeUndefined();
+      expect(pendingInteractions.get("secret-legacy-cancel-1")).toBeUndefined();
+
+      await stopServer();
+    });
+
     test("rejects a non-secret requestId without consuming it", async () => {
       /**
        * /v1/secret only settles secret prompts. A confirmation (or any other
@@ -790,6 +866,58 @@ describe("standalone approval endpoints — HTTP layer", () => {
     });
   });
 
+  // ── GET /v1/pending-interactions ─────────────────────────────────────
+
+  describe("GET /v1/pending-interactions", () => {
+    test("returns full secret prompt metadata for a registered secret", async () => {
+      const session = makeIdleSession();
+      await startServer(() => session);
+
+      pendingInteractions.register("secret-meta-1", {
+        conversationId: "conv-meta",
+        kind: "secret",
+        secretDetails: {
+          service: "github",
+          field: "token",
+          label: "GitHub Token",
+          description: "Personal access token",
+          placeholder: "ghp_...",
+          purpose: "Push commits",
+          allowedTools: ["git_push"],
+          allowedDomains: ["github.com"],
+          allowOneTimeSend: true,
+        },
+      });
+
+      const res = await fetch(
+        url("pending-interactions?conversationId=conv-meta"),
+        {
+          method: "GET",
+          headers: { ...AUTH_HEADERS },
+        },
+      );
+      const body = (await res.json()) as {
+        pendingSecret: Record<string, unknown> | null;
+      };
+
+      expect(res.status).toBe(200);
+      expect(body.pendingSecret).toEqual({
+        requestId: "secret-meta-1",
+        service: "github",
+        field: "token",
+        label: "GitHub Token",
+        description: "Personal access token",
+        placeholder: "ghp_...",
+        purpose: "Push commits",
+        allowedTools: ["git_push"],
+        allowedDomains: ["github.com"],
+        allowOneTimeSend: true,
+      });
+
+      await stopServer();
+    });
+  });
+
   // ── getByConversation ────────────────────────────────────────────────
 
   describe("getByConversation", () => {

package/src/__tests__/assistant-feature-flag-guard.test.ts

@@ -60,10 +60,7 @@ const CANONICAL_KEY_RE = /^[a-z0-9][a-z0-9-]*$/;
  * Keep this list minimal — only files that genuinely need to reference
  * the legacy format for backward compatibility.
  */
-const LEGACY_KEY_ALLOWLIST = new Set([
-  // macOS client: fallback reads from legacy config section
-  "clients/macos/vellum-assistant/Features/Settings/SettingsAccountTab.swift",
-]);
+const LEGACY_KEY_ALLOWLIST = new Set<string>([]);
 
 function isTestFile(filePath: string): boolean {
   return (

package/src/__tests__/assistant-feature-flag-guardrails.test.ts

@@ -58,8 +58,6 @@ function loadRegistry(): Registry {
 const LEGACY_KEY_ALLOWLIST = new Set([
   // Type definitions documenting the legacy format
   "assistant/src/config/types.ts",
-  // macOS client: fallback reads from legacy config section
-  "clients/macos/vellum-assistant/Features/Settings/SettingsAccountTab.swift",
 ]);
 
 function isTestFile(filePath: string): boolean {

package/src/__tests__/auth-fallback-events-store.test.ts

@@ -7,18 +7,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-let collectUsageData = true;
+let shareAnalytics = true;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-    collectUsageData,
-  }),
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
 }));
 
 import {
@@ -53,7 +45,7 @@ const SAMPLE: AuthFallbackCount[] = [
 
 describe("auth-fallback-events-store", () => {
   beforeEach(() => {
-    collectUsageData = true;
+    shareAnalytics = true;
     resetTable();
   });
 
@@ -78,8 +70,8 @@ describe("auth-fallback-events-store", () => {
     });
   });
 
-  test("honors the collectUsageData opt-out (records nothing)", () => {
-    collectUsageData = false;
+  test("honors the share_analytics opt-out (records nothing)", () => {
+    shareAnalytics = false;
     const recorded = recordAuthFallbackCounts(1000, 2000, SAMPLE);
     expect(recorded).toBe(0);
     expect(queryUnreportedAuthFallbackEvents(0, undefined, 100).length).toBe(0);

package/src/__tests__/avatar-identity-sync.test.ts

@@ -4,10 +4,7 @@ import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as AVATAR_ROUTES } from "../runtime/routes/avatar-routes.js";
-import {
-  publishIdentityChanged,
-  publishIdentityIntroChanged,
-} from "../runtime/sync/resource-sync-events.js";
+import { publishIdentityChanged } from "../runtime/sync/resource-sync-events.js";
 
 async function waitFor(predicate: () => boolean): Promise<void> {
   const deadline = Date.now() + 500;
@@ -81,29 +78,7 @@ describe("avatar and identity sync events", () => {
       });
       expect(received[1].message).toEqual({
         type: "sync_changed",
-        tags: [SYNC_TAGS.assistantIdentity, SYNC_TAGS.assistantIdentityIntro],
-      });
-    } finally {
-      subscription.dispose();
-    }
-  });
-
-  test("identity intro changes emit only the identity intro sync tag", async () => {
-    const received: AssistantEvent[] = [];
-    const subscription = assistantEventHub.subscribe({
-      type: "process",
-      callback: (event) => {
-        received.push(event);
-      },
-    });
-
-    try {
-      publishIdentityIntroChanged();
-      await waitFor(() => received.length === 1);
-
-      expect(received[0].message).toEqual({
-        type: "sync_changed",
-        tags: [SYNC_TAGS.assistantIdentityIntro],
+        tags: [SYNC_TAGS.assistantIdentity],
       });
     } finally {
       subscription.dispose();

package/src/__tests__/btw-routes.test.ts

@@ -78,10 +78,8 @@ mock.module("../prompts/persona-resolver.js", () => ({
   resolveUserSlug: () => null,
 }));
 
-mock.module("../runtime/routes/identity-intro-cache.js", () => ({
-  getCachedIntro: () => null,
-  readWorkspaceIdentityIntro: () => null,
-  setCachedIntro: () => {},
+mock.module("../runtime/routes/workspace-greetings.js", () => ({
+  readWorkspaceGreetings: () => null,
 }));
 
 // Mock getOrCreateConversation from conversation-store so the handler
@@ -345,13 +343,13 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.callSite).toBe("emptyStateGreeting");
   });
 
-  test("identity intro requests pass callSite: 'identityIntro'", async () => {
+  test("generic requests pass the default callSite", async () => {
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);
 
     const { result } = await callHandler({
-      conversationKey: "identity-intro",
+      conversationKey: "profile-intro",
       content: "Generate an intro",
     });
     await readStream(result as ReadableStream<Uint8Array>);
@@ -361,7 +359,7 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.callSite).toBe("identityIntro");
   });
 
-  test("identity intro requests do not synthesize a static name greeting", async () => {
+  test("generic requests do not synthesize a static name greeting", async () => {
     const identityPath = join(getWorkspaceDir(), "IDENTITY.md");
     writeFileSync(
       identityPath,
@@ -375,7 +373,7 @@ describe("POST /v1/btw", () => {
       mockGetOrCreateConversation.mockImplementationOnce(async () => session);
 
       const { result } = await callHandler({
-        conversationKey: "identity-intro",
+        conversationKey: "profile-intro",
         content: "Generate an intro",
       });
       const text = await readStream(result as ReadableStream<Uint8Array>);

package/src/__tests__/call-pointer-messages.test.ts

@@ -343,6 +343,34 @@ describe("addPointerMessage", () => {
     expect(processorCalled).toBe(true);
   });
 
+  test("unverified_contact provenance round-trips through the metadata schema and is treated as trusted audience", async () => {
+    // Persisted unverified_contact metadata must survive the schema parse so
+    // downstream consumers (e.g. memory write gate, pointer audience trust)
+    // see the durable trust snapshot rather than a silently-dropped undefined.
+    const convId = "conv-ptr-uvc-provenance";
+    ensureConversation(convId);
+    await addMessage(convId, "user", "hello", {
+      metadata: { provenanceTrustClass: "unverified_contact" },
+    });
+
+    // Confirm the durable snapshot round-trips through the schema parser.
+    const { getConversationRecentProvenanceTrustClass } = await import(
+      "../memory/conversation-crud.js"
+    );
+    expect(getConversationRecentProvenanceTrustClass(convId)).toBe(
+      "unverified_contact",
+    );
+
+    // And that pointer-audience trust treats it identically to trusted_contact.
+    let processorCalled = false;
+    setPointerMessageProcessor(async () => {
+      processorCalled = true;
+    });
+
+    await addPointerMessage(convId, "completed", "+15559876543");
+    expect(processorCalled).toBe(true);
+  });
+
   test("unknown provenance trust class does not grant trusted audience", () => {
     const convId = "conv-ptr-unknown-provenance";
     ensureConversation(convId);

package/src/__tests__/cancel-clears-processing.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Cancel contract: a user cancel raises the conversation's AbortController and
+ * defers clearing the `processing` flag to the in-flight turn's `finally`.
+ *
+ * `cancelGeneration` no longer force-clears `processing` itself. Abort now
+ * propagates into the provider call and tool execution — and is backed by the
+ * agent loop's abort watchdog — so a cancelled turn always reaches its
+ * `finally` within a bounded time and tears down its own state there. The
+ * watchdog-driven path (turn reaches `finally`, processing clears) is covered
+ * by `conversation-agent-loop.test.ts`; this file pins the handler-side
+ * contract: cancel signals abort and leaves the flag to the turn.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { cancelGeneration } from "../daemon/handlers/conversations.js";
+
+interface CancelledConversation {
+  isProcessing: () => boolean;
+  setProcessingCalls: () => boolean[];
+  abortCount: () => number;
+}
+
+/**
+ * Register a conversation whose in-flight turn is processing. The fake records
+ * abort calls and any `setProcessing` writes so the test can assert that
+ * `cancelGeneration` signals abort without flipping the flag itself.
+ */
+function registerProcessingTurn(id: string): CancelledConversation {
+  let processing = true;
+  let abortCount = 0;
+  const setProcessingCalls: boolean[] = [];
+  const fake = {
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      setProcessingCalls.push(value);
+      processing = value;
+    },
+    abort: () => {
+      abortCount += 1;
+    },
+  };
+  setConversation(id, fake as unknown as Conversation);
+  return {
+    isProcessing: () => processing,
+    setProcessingCalls: () => setProcessingCalls,
+    abortCount: () => abortCount,
+  };
+}
+
+describe("cancelGeneration", () => {
+  const conversationId = "cancel-clears-processing-test-conversation";
+
+  afterEach(() => {
+    deleteConversation(conversationId);
+  });
+
+  test("raises abort and defers clearing processing to the turn's finally", () => {
+    // GIVEN a registered conversation that is processing
+    const fake = registerProcessingTurn(conversationId);
+    expect(fake.isProcessing()).toBe(true);
+
+    // WHEN the user cancels generation
+    const cancelled = cancelGeneration(conversationId);
+
+    // THEN the cancel is acknowledged
+    expect(cancelled).toBe(true);
+    // AND the abort signal is raised on the conversation
+    expect(fake.abortCount()).toBe(1);
+    // AND cancelGeneration does NOT force-clear the flag itself — the in-flight
+    // turn's `finally` owns that teardown once abort drives it there.
+    expect(fake.setProcessingCalls()).not.toContain(false);
+    expect(fake.isProcessing()).toBe(true);
+  });
+
+  test("returns false for a conversation that is not registered", () => {
+    // GIVEN no conversation registered under the id
+
+    // WHEN the user cancels generation for the unknown id
+    const cancelled = cancelGeneration("cancel-clears-processing-unknown-id");
+
+    // THEN the cancel reports that nothing was found
+    expect(cancelled).toBe(false);
+  });
+});

package/src/__tests__/channel-approval-routes.test.ts

@@ -224,14 +224,12 @@ function ensureTestContact(): void {
       {
         type: "telegram",
         address: "telegram-user-default",
-        externalUserId: "telegram-user-default",
         status: "active",
         policy: "allow",
       },
       {
         type: "slack",
         address: "slack-user-default",
-        externalUserId: "slack-user-default",
         status: "active",
         policy: "allow",
       },
@@ -2054,7 +2052,6 @@ describe("requester cancel of guardian-gated pending request", () => {
         {
           type: "telegram",
           address: "requester-cancel-user",
-          externalUserId: "requester-cancel-user",
           status: "active",
           policy: "allow",
         },
@@ -2981,7 +2978,6 @@ describe("trusted-contact self-approval blocked before guardian approval row exi
         {
           type: "telegram",
           address: "tc-selfapproval-user",
-          externalUserId: "tc-selfapproval-user",
           status: "active",
           policy: "allow",
         },

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -97,7 +97,6 @@ function seedTrustedContact(policy: "allow" | "escalate" = "allow"): void {
       {
         type: "telegram",
         address: "telegram-user-1",
-        externalUserId: "telegram-user-1",
         status: "active",
         policy,
       },
@@ -237,14 +236,13 @@ describe("channel inbound disk pressure gate", () => {
     expect(db.select().from(messages).all()).toHaveLength(0);
   });
 
-  test("blocks non-guardian Slack reactions before persistence while locked", async () => {
+  test("blocks non-guardian Slack reactions silently (no reply) before persistence while locked", async () => {
     upsertContact({
       displayName: "Example Slack User",
       channels: [
         {
           type: "slack",
           address: "slack-user-1",
-          externalUserId: "slack-user-1",
           status: "active",
           policy: "allow",
         },
@@ -276,18 +274,10 @@ describe("channel inbound disk pressure gate", () => {
       reason: "trusted-contact",
     });
     expect(processMessage).not.toHaveBeenCalled();
-    expect(deliverChannelReplyMock.mock.calls).toEqual([
-      [
-        "https://gateway.test/deliver/slack",
-        {
-          chatId: "slack-channel-1",
-          text: expectedRemoteBlockReply,
-          assistantId: "self",
-          ephemeral: true,
-          user: "slack-user-1",
-        },
-      ],
-    ]);
+    // Reactions are blocked silently during disk pressure: a passive signal
+    // has nothing to "try again", so no block reply is delivered (unlike the
+    // message path, which does reply).
+    expect(deliverChannelReplyMock).not.toHaveBeenCalled();
 
     const db = getDb();
     const event = db

package/src/__tests__/checker.test.ts

@@ -790,9 +790,6 @@ describe("Permission Checker", () => {
       const workingDir = join(homedir(), "projects", "myapp");
       expect(generateScopeOptions(workingDir, "web_fetch")).toHaveLength(0);
       expect(generateScopeOptions(workingDir, "skill_load")).toHaveLength(0);
-      expect(generateScopeOptions(workingDir, "credential_store")).toHaveLength(
-        0,
-      );
       expect(
         generateScopeOptions(workingDir, "computer_use_click"),
       ).toHaveLength(0);

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -52,7 +52,7 @@ mock.module("../memory/v2/skill-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 const { registerMemoryV2Command } =
-  await import("../cli/commands/memory-v2.js");
+  await import("../cli/commands/memory/memory-v2.js");
 const { ROUTES: memoryV2Routes, MEMORY_V2_DISABLED_CODE } =
   await import("../runtime/routes/memory-v2-routes.js");
 const { RouteError } = await import("../runtime/routes/errors.js");
@@ -68,9 +68,8 @@ function buildProgram(): Command {
     writeErr: () => {},
     writeOut: () => {},
   });
-  // The registrar creates the `memory` parent itself, so callers don't
-  // need to stub one.
-  registerMemoryV2Command(program);
+  const memory = program.command("memory");
+  registerMemoryV2Command(memory);
   return program;
 }
 

package/src/__tests__/compaction-events.test.ts

@@ -196,6 +196,12 @@ const updateConfigCalls: Array<{ maxInputTokens?: number }> = [];
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     nonPersistedPrefixCount = 0;
     constructor() {}
     updateConfig(cfg: { maxInputTokens?: number }) {

package/src/__tests__/compactor-image-manifest-trust.test.ts

@@ -41,7 +41,11 @@ function resetTables(): void {
 
 async function addImageMessage(
   conversationId: string,
-  provenanceTrustClass: "guardian" | "trusted_contact" | "unknown",
+  provenanceTrustClass:
+    | "guardian"
+    | "trusted_contact"
+    | "unverified_contact"
+    | "unknown",
   filename: string,
 ): Promise<void> {
   const inserted = await addMessage(
@@ -109,4 +113,20 @@ describe("collectImageManifest trust filtering", () => {
     expect(filenames).toContain("contact.png");
     expect(filenames).not.toContain("guardian-secret.png");
   });
+
+  test("unverified_contact actor manifest excludes guardian images but keeps unverified-provenance images", async () => {
+    // GIVEN a conversation with a guardian image and an unverified-contact image
+    const conv = createConversation();
+    await addImageMessage(conv.id, "guardian", "guardian-secret.png");
+    await addImageMessage(conv.id, "unverified_contact", "unverified.png");
+
+    // WHEN the manifest is built for an unverified_contact actor
+    const manifest = collectImageManifest(conv.id, "unverified_contact");
+
+    // THEN the unverified-provenance image is listed and the guardian image
+    // is excluded — unverified_contact is treated as untrusted downstream.
+    const filenames = manifest.map((e) => e.filename);
+    expect(filenames).toContain("unverified.png");
+    expect(filenames).not.toContain("guardian-secret.png");
+  });
 });