@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/scripted-turn-metadata-persistence.test.ts

@@ -73,6 +73,7 @@ import type {
 import type { MessagingConversationContext } from "../daemon/conversation-messaging.js";
 import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
 import type { MessageQueue } from "../daemon/conversation-queue-manager.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 
 function createContext(): MessagingConversationContext {
   const channel: TurnChannelContext = {
@@ -223,3 +224,75 @@ describe("scripted-turn metadata persistence", () => {
     expect(lastUserMetadata().scripted).toBe(false);
   });
 });
+
+describe("author contact id on a persisted user message", () => {
+  const sender: TrustContext = {
+    sourceChannel: "slack",
+    trustClass: "trusted_contact",
+    requesterContactId: "contact-alice",
+  };
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  test("a message relayed from the sender names them as its author", async () => {
+    await persistQueuedMessageBody(createContext(), {
+      content: "the export endpoint needs a scoped token",
+      requestId: "req-author-typed",
+      trustContext: sender,
+      author: sender,
+    });
+
+    expect(lastUserMetadata().provenanceContactId).toBe("contact-alice");
+  });
+
+  test("a row persisted under the sender's trust but not relayed from them names no author", async () => {
+    // Machine-authored rows (ACP and subagent notifications, pointer turns)
+    // share this writer and the conversation's trust; only an explicit
+    // author names one.
+    await persistQueuedMessageBody(createContext(), {
+      content: "the delegated task finished",
+      requestId: "req-author-machine",
+      trustContext: sender,
+      metadata: { acpNotification: { acpSessionId: "acp-session-1" } },
+    });
+
+    expect(lastUserMetadata().provenanceContactId).toBeUndefined();
+  });
+
+  test.each([
+    ["scripted", { scripted: true }],
+    ["automated", { metadata: { automated: true } }],
+    ["hidden", { metadata: { hidden: true } }],
+    [
+      "ACP notification",
+      { metadata: { acpNotification: { acpSessionId: "acp-session-1" } } },
+    ],
+    [
+      "subagent notification",
+      {
+        metadata: {
+          subagentNotification: {
+            subagentId: "subagent-1",
+            label: "Research",
+            status: "completed",
+          },
+        },
+      },
+    ],
+  ] as const)(
+    "a %s row speaks in their voice without naming them",
+    async (kind, extra) => {
+      await persistQueuedMessageBody(createContext(), {
+        content: "sent on the sender's behalf",
+        requestId: `req-author-${kind}`,
+        trustContext: sender,
+        author: sender,
+        ...extra,
+      });
+
+      expect(lastUserMetadata().provenanceContactId).toBeUndefined();
+    },
+  );
+});

package/src/__tests__/secret-ingress-http.test.ts

@@ -100,6 +100,7 @@ mock.module("../runtime/guardian-reply-router.js", () => ({
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const testAuthContext: AuthContext = {
   subject: "actor:self:test-user",
@@ -176,6 +177,7 @@ function makeSendMessageDeps() {
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},
     addPreactivatedSkillId: () => {},
+    modeSessions: mockUnownedModeSessions(),
   } as unknown as import("../daemon/conversation.js").Conversation;
 
   return {

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -28,6 +28,9 @@ const MANAGED_PROVIDERS = [
 ] as const;
 
 let platformBaseUrlOverride: string | undefined;
+let platformAssistantIdOverride: string | undefined;
+let platformOrganizationIdOverride: string | undefined;
+let platformUserIdOverride: string | undefined;
 
 mock.module("@google/genai", () => ({
   GoogleGenAI: class MockGoogleGenAI {
@@ -54,9 +57,19 @@ mock.module("@google/genai", () => ({
 
 mock.module("../config/env.js", () => ({
   getPlatformBaseUrl: () => PLATFORM_BASE_URL,
+  getPlatformAssistantId: () => platformAssistantIdOverride,
   setPlatformBaseUrl: (value: string | undefined) => {
     platformBaseUrlOverride = value;
   },
+  setPlatformAssistantId: (value: string | undefined) => {
+    platformAssistantIdOverride = value;
+  },
+  setPlatformOrganizationId: (value: string | undefined) => {
+    platformOrganizationIdOverride = value;
+  },
+  setPlatformUserId: (value: string | undefined) => {
+    platformUserIdOverride = value;
+  },
 }));
 
 mock.module("../providers/provider-secret-catalog.js", () => ({
@@ -182,6 +195,9 @@ describe("secret routes managed proxy registry sync", () => {
     metadataDeletes.length = 0;
     lastGeminiConstructorOpts = null;
     platformBaseUrlOverride = undefined;
+    platformAssistantIdOverride = undefined;
+    platformOrganizationIdOverride = undefined;
+    platformUserIdOverride = undefined;
     providerRefreshCalls = 0;
     identitySyncCalls = 0;
     avatarSyncCalls = 0;
@@ -254,32 +270,38 @@ describe("secret routes managed proxy registry sync", () => {
     expect(providerRefreshCalls).toBe(2);
   });
 
-  test("deleting vellum:assistant_api_key clears managed fallback providers immediately", async () => {
+  test("deleting a vellum credential is rejected without touching the vault", async () => {
     secureKeyStore[ASSISTANT_API_KEY_PATH] = "ast-managed-key";
+    secureKeyStore[PLATFORM_BASE_URL_PATH] = "https://managed.example.com";
+    platformBaseUrlOverride = "https://managed.example.com";
+    platformAssistantIdOverride = "asst-1";
     await initializeProviders(getConfig());
 
-    for (const provider of MANAGED_PROVIDERS) {
-      expect(listProviders()).toContain(provider);
-      expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+    for (const name of [
+      "vellum:assistant_api_key",
+      "vellum:platform_base_url",
+      "vellum:webhook_secret",
+      "vellum:platform_assistant_id",
+    ]) {
+      await expect(deleteCredential(name)).rejects.toThrow(
+        "Vellum credentials cannot be deleted",
+      );
     }
 
-    await deleteCredential("vellum:assistant_api_key");
-
-    expect(secureKeyStore[ASSISTANT_API_KEY_PATH]).toBeUndefined();
-    expect(metadataDeletes).toEqual([
-      { service: "vellum", field: "assistant_api_key" },
-    ]);
-    expect(listProviders()).toEqual([]);
+    expect(secureKeyStore[ASSISTANT_API_KEY_PATH]).toBe("ast-managed-key");
+    expect(secureKeyStore[PLATFORM_BASE_URL_PATH]).toBe(
+      "https://managed.example.com",
+    );
+    expect(platformBaseUrlOverride).toBe("https://managed.example.com");
+    expect(platformAssistantIdOverride).toBe("asst-1");
+    expect(metadataDeletes).toEqual([]);
+    expect(providerRefreshCalls).toBe(0);
   });
 
   test("managed proxy credential writes notify live-conversation refresh listeners", async () => {
     await addCredential("vellum:assistant_api_key", "ast-managed-key");
 
     expect(providerRefreshCalls).toBe(1);
-
-    await deleteCredential("vellum:assistant_api_key");
-
-    expect(providerRefreshCalls).toBe(2);
   });
 
   /**
@@ -326,7 +348,6 @@ describe("secret routes managed proxy registry sync", () => {
   test("storing a platform registration credential enqueues name and avatar syncs", async () => {
     for (const name of [
       "vellum:assistant_api_key",
-      "vellum:platform_assistant_id",
       "vellum:platform_base_url",
     ]) {
       identitySyncCalls = 0;
@@ -339,7 +360,6 @@ describe("secret routes managed proxy registry sync", () => {
 
   test("unrelated credentials do not enqueue platform syncs", async () => {
     await addCredential("openrouter:api_key", "openrouter-key");
-    await addCredential("vellum:platform_user_id", "user-1");
 
     expect(identitySyncCalls).toBe(0);
     expect(avatarSyncCalls).toBe(0);
@@ -349,13 +369,61 @@ describe("secret routes managed proxy registry sync", () => {
     failSecureKeyWrites = true;
 
     await expect(
-      addCredential("vellum:platform_assistant_id", "asst-1"),
+      addCredential("vellum:platform_base_url", "https://managed.example.com"),
     ).rejects.toThrow("Failed to store credential");
 
     expect(identitySyncCalls).toBe(0);
     expect(avatarSyncCalls).toBe(0);
   });
 
+  test("unknown vellum credentials are rejected without persisting or binding identity", async () => {
+    platformAssistantIdOverride = "existing-asst";
+    platformOrganizationIdOverride = "existing-org";
+    platformUserIdOverride = "existing-user";
+
+    await expect(
+      addCredential("vellum:platform_assistant_id", "asst-1"),
+    ).rejects.toThrow("Unknown vellum credential: platform_assistant_id");
+    await expect(
+      addCredential("vellum:platform_organization_id", "org-1"),
+    ).rejects.toThrow("Unknown vellum credential: platform_organization_id");
+    await expect(
+      addCredential("vellum:platform_user_id", "user-1"),
+    ).rejects.toThrow("Unknown vellum credential: platform_user_id");
+
+    expect(
+      secureKeyStore[credentialKey("vellum", "platform_assistant_id")],
+    ).toBeUndefined();
+    expect(
+      secureKeyStore[credentialKey("vellum", "platform_organization_id")],
+    ).toBeUndefined();
+    expect(
+      secureKeyStore[credentialKey("vellum", "platform_user_id")],
+    ).toBeUndefined();
+    expect(metadataUpserts).toEqual([]);
+    expect(platformAssistantIdOverride).toBe("existing-asst");
+    expect(platformOrganizationIdOverride).toBe("existing-org");
+    expect(platformUserIdOverride).toBe("existing-user");
+    expect(identitySyncCalls).toBe(0);
+    expect(avatarSyncCalls).toBe(0);
+  });
+
+  test("an unknown vellum credential does not delete leftover vault copies", async () => {
+    const key = credentialKey("vellum", "platform_assistant_id");
+    secureKeyStore[key] = "leftover-asst";
+    platformAssistantIdOverride = "asst-1";
+
+    await expect(
+      addCredential("vellum:platform_assistant_id", "   "),
+    ).rejects.toThrow("Unknown vellum credential: platform_assistant_id");
+
+    expect(secureKeyStore[key]).toBe("leftover-asst");
+    expect(platformAssistantIdOverride).toBe("asst-1");
+    expect(metadataDeletes).toEqual([]);
+    expect(identitySyncCalls).toBe(0);
+    expect(avatarSyncCalls).toBe(0);
+  });
+
   test("storing vellum:platform_base_url sets override and triggers initializeProviders", async () => {
     await addCredential(
       "vellum:platform_base_url",
@@ -389,17 +457,4 @@ describe("secret routes managed proxy registry sync", () => {
       expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
     }
   });
-
-  test("deleting vellum:platform_base_url clears override and re-initializes providers", async () => {
-    secureKeyStore[PLATFORM_BASE_URL_PATH] = "https://managed.example.com";
-    platformBaseUrlOverride = "https://managed.example.com";
-
-    await deleteCredential("vellum:platform_base_url");
-
-    expect(secureKeyStore[PLATFORM_BASE_URL_PATH]).toBeUndefined();
-    expect(platformBaseUrlOverride).toBeUndefined();
-    expect(metadataDeletes).toEqual([
-      { service: "vellum", field: "platform_base_url" },
-    ]);
-  });
 });

package/src/__tests__/secret-routes-scrub.test.ts

@@ -222,39 +222,34 @@ describe("secrets_add credential transcript scrub", () => {
     expect(scrubbedValues).toEqual([CREDENTIAL_VALUE]);
   });
 
-  test("non-secret platform fields are stored but never scrubbed", async () => {
-    for (const field of [
-      "platform_assistant_id",
-      "platform_organization_id",
-      "platform_user_id",
-      "platform_base_url",
-    ]) {
-      const result = await addRoute.handler({
-        body: {
-          type: "credential",
-          name: `vellum:${field}`,
-          value: "0198f4c2-1111-2222-3333-444455556666",
-        },
-      });
-      expect(result).toEqual(expect.objectContaining({ success: true }));
-    }
-
-    // All four stored, none scrubbed — they are benign UUIDs/URLs that
-    // legitimately appear in transcripts.
-    expect(secureStore.size).toBe(4);
-    expect(scrubbedValues).toEqual([]);
-  });
-
-  test("an identity-field delete stores nothing and never scrubs", async () => {
+  test("non-secret platform fields are not scrubbed", async () => {
     const result = await addRoute.handler({
       body: {
         type: "credential",
-        name: "vellum:platform_assistant_id",
-        value: "   ",
+        name: "vellum:platform_base_url",
+        value: "0198f4c2-1111-2222-3333-444455556666",
       },
     });
-
     expect(result).toEqual(expect.objectContaining({ success: true }));
+
+    expect(secureStore.size).toBe(1);
+    expect(secureStore.get(credentialKey("vellum", "platform_base_url"))).toBe(
+      "0198f4c2-1111-2222-3333-444455556666",
+    );
+    expect(scrubbedValues).toEqual([]);
+  });
+
+  test("an unknown vellum credential is rejected and never triggers a scrub", async () => {
+    await expect(
+      addRoute.handler({
+        body: {
+          type: "credential",
+          name: "vellum:platform_assistant_id",
+          value: "   ",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+
     expect(secureStore.size).toBe(0);
     expect(scrubbedValues).toEqual([]);
   });

package/src/__tests__/secret-scanner.test.ts

@@ -187,6 +187,26 @@ describe("Anthropic keys", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Resend
+// ---------------------------------------------------------------------------
+describe("Resend keys", () => {
+  const key = `re_${"a".repeat(8)}_${"b".repeat(24)}`;
+
+  test("detects re_ key", () => {
+    expectMatch(key, "Resend API Key");
+  });
+
+  test("redacts a key echoed from shell output", () => {
+    const out = redactSecrets(`$ cat .env\nRESEND=${key}\n`);
+    expect(out).not.toContain(key);
+  });
+
+  test("ignores re_ identifiers that are not key-shaped", () => {
+    expectNoMatch("re_0_of_1_is_deprecated_6387");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // OpenAI
 // ---------------------------------------------------------------------------

package/src/__tests__/secure-keys-managed-failover.test.ts

@@ -63,4 +63,12 @@ describe("secure-keys managed CES failover", () => {
     expect(rpcCall).toHaveBeenCalledTimes(1);
     expect(globalThis.fetch).toHaveBeenCalledTimes(1);
   });
+
+  test("uses CES HTTP only after lazy IPC finds no socket", async () => {
+    const start = Date.now();
+    expect(await getSecureKeyAsync("openai")).toBe("http-secret");
+    expect(Date.now() - start).toBeLessThan(1_000);
+    expect(getActiveBackendName()).toBe("ces-http");
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+  });
 });

package/src/__tests__/secure-keys.test.ts

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { createServer, type Server } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -11,6 +12,8 @@ import {
   test,
 } from "bun:test";
 
+import { resolveIpcEndpoint } from "@vellumai/ipc-server-utils";
+
 // ---------------------------------------------------------------------------
 // Mock logger (no-op — compatible with other test files' identical mock)
 // ---------------------------------------------------------------------------
@@ -61,7 +64,6 @@ describe("secure-keys", () => {
     delete process.env.VELLUM_DESKTOP_APP;
     delete process.env.IS_CONTAINERIZED;
     delete process.env.CES_CREDENTIAL_URL;
-    delete process.env.CES_LOCAL_SOCKET;
   });
 
   afterAll(() => {
@@ -79,6 +81,13 @@ describe("secure-keys", () => {
       expect(await getSecureKeyAsync("openai")).toBe("sk-openai-789");
     });
 
+    test("does not poll for a CES socket when none is present", async () => {
+      const start = Date.now();
+      await getSecureKeyAsync("openai");
+      expect(Date.now() - start).toBeLessThan(1_000);
+      expect(getActiveBackendName()).toBe("encrypted-store");
+    });
+
     test("get returns undefined for nonexistent key", async () => {
       expect(await getSecureKeyAsync("nonexistent")).toBeUndefined();
     });
@@ -552,7 +561,6 @@ describe("secure-keys", () => {
     test("reads report unreachable (indeterminate), never absent", async () => {
       process.env.IS_CONTAINERIZED = "1";
       delete process.env.CES_CREDENTIAL_URL;
-      delete process.env.CES_LOCAL_SOCKET;
       _resetBackend();
 
       const result = await getSecureKeyResultAsync("openai");
@@ -564,7 +572,6 @@ describe("secure-keys", () => {
     test("does not pin the unreachable result: a ready CES client wins the next read", async () => {
       process.env.IS_CONTAINERIZED = "1";
       delete process.env.CES_CREDENTIAL_URL;
-      delete process.env.CES_LOCAL_SOCKET;
       _resetBackend();
 
       expect((await getSecureKeyResultAsync("openai")).unreachable).toBe(true);
@@ -598,4 +605,43 @@ describe("secure-keys", () => {
       expect(result.unreachable).toBe(true);
     });
   });
+
+  // -----------------------------------------------------------------------
+  // Session ownership: boot claims reconnect before identity reads
+  // -----------------------------------------------------------------------
+  describe("CES session owner skips a second open", () => {
+    test("a registered reconnect owner does not handshake a live CES socket", async () => {
+      const dir = mkdtempSync(join(tmpdir(), "ces-owner-"));
+      const socketPath = resolveIpcEndpoint("ces", { workspaceDir: dir }).path;
+      const savedDir = process.env.CES_BOOTSTRAP_SOCKET_DIR;
+      process.env.CES_BOOTSTRAP_SOCKET_DIR = dir;
+
+      const connections: Array<import("node:net").Socket> = [];
+      const server: Server = createServer((socket) => {
+        connections.push(socket);
+        socket.on("error", () => {});
+      });
+      await new Promise<void>((resolve) => server.listen(socketPath, resolve));
+
+      try {
+        setCesReconnect(async () => undefined);
+        const start = Date.now();
+        await getSecureKeyAsync("openai");
+        expect(Date.now() - start).toBeLessThan(1_000);
+        expect(getActiveBackendName()).toBe("encrypted-store");
+        expect(connections.length).toBe(0);
+      } finally {
+        for (const sock of connections) {
+          sock.destroy();
+        }
+        await new Promise<void>((resolve) => server.close(() => resolve()));
+        if (savedDir !== undefined) {
+          process.env.CES_BOOTSTRAP_SOCKET_DIR = savedDir;
+        } else {
+          delete process.env.CES_BOOTSTRAP_SOCKET_DIR;
+        }
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
 });