@vellumai/assistant 0.4.49 → 0.4.51

package/src/__tests__/relay-server.test.ts

@@ -189,6 +189,7 @@ import {
   RelayConnection,
 } from "../calls/relay-server.js";
 import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
+import { upsertContact } from "../contacts/contact-store.js";
 import {
   createGuardianBinding,
   upsertContactChannel,
@@ -289,6 +290,11 @@ function resetTables() {
   ensuredConvIds = new Set();
 }
 
+/** Create a throwaway contact and return its ID, for use as the invite's contactId. */
+function createTargetContact(displayName = "Test Contact"): string {
+  return upsertContact({ displayName, role: "contact" }).id;
+}
+
 function addTrustedVoiceContact(phoneNumber: string): void {
   upsertContactChannel({
     sourceChannel: "phone",
@@ -2053,6 +2059,7 @@ describe("relay-server", () => {
     const codeHash = hashVoiceCode(code);
     createInvite({
       sourceChannel: "phone",
+      contactId: createTargetContact(),
       maxUses: 1,
       expectedExternalUserId: "+15558887777",
       voiceCodeHash: codeHash,
@@ -2126,6 +2133,7 @@ describe("relay-server", () => {
     const codeHash = hashVoiceCode(code);
     createInvite({
       sourceChannel: "phone",
+      contactId: createTargetContact(),
       maxUses: 1,
       expectedExternalUserId: "+15558886666",
       voiceCodeHash: codeHash,
@@ -4013,6 +4021,7 @@ describe("relay-server", () => {
     const codeHash = hashVoiceCode(code);
     createInvite({
       sourceChannel: "phone",
+      contactId: createTargetContact(),
       maxUses: 1,
       expectedExternalUserId: "+15557776666",
       voiceCodeHash: codeHash,
@@ -4055,7 +4064,7 @@ describe("relay-server", () => {
       .filter((m) => m.type === "text");
     expect(
       textMessages.some((m) =>
-        (m.token ?? "").includes("said I can speak with you"),
+        (m.token ?? "").includes("verified that you are Eve"),
       ),
     ).toBe(true);
 
@@ -4079,6 +4088,51 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  test("outbound invite prompt uses assistant introduction", async () => {
+    ensureConversation("conv-outbound-invite-origin");
+    ensureConversation("conv-outbound-invite");
+    const session = createCallSession({
+      conversationId: "conv-outbound-invite",
+      provider: "twilio",
+      fromNumber: "+15551111111",
+      toNumber: "+15558887777",
+      callMode: "invite",
+      inviteFriendName: "Grace",
+      inviteGuardianName: "Hank",
+      initiatedFromConversationId: "conv-outbound-invite-origin",
+    });
+
+    mockAssistantName = "Vellum";
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_outbound_invite",
+        from: "+15551111111",
+        to: "+15558887777",
+      }),
+    );
+
+    // Should be in verification-pending for invite redemption
+    expect(relay.getConnectionState()).toBe("verification_pending");
+
+    // The prompt should use the outbound assistant introduction
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    expect(
+      textMessages.some(
+        (m) =>
+          (m.token ?? "").includes("this is Vellum") &&
+          (m.token ?? "").includes("Hank's assistant"),
+      ),
+    ).toBe(true);
+
+    relay.destroy();
+  });
+
   // ── resolveGuardianLabel resolution priority ─────────────────────────
 
   test("guardian label: USER.md name takes precedence over Contact.displayName", async () => {

package/src/__tests__/schedule-tools.test.ts

@@ -61,6 +61,11 @@ const ctx: ToolContext = {
   trustClass: "guardian",
 };
 
+const trustedCtx: ToolContext = {
+  ...ctx,
+  trustClass: "trusted_contact",
+};
+
 // ── schedule_create ─────────────────────────────────────────────────
 
 describe("schedule_create tool", () => {
@@ -169,6 +174,20 @@ describe("schedule_create tool", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Invalid cron expression");
   });
+
+  test("rejects non-guardian actors", async () => {
+    const result = await executeScheduleCreate(
+      {
+        name: "Blocked schedule",
+        expression: "0 9 * * *",
+        message: "test",
+      },
+      trustedCtx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("restricted to guardian actors");
+  });
 });
 
 // ── schedule_create with fire_at (one-shot) ──────────────────────────
@@ -680,6 +699,19 @@ describe("schedule_update tool", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Invalid cron expression");
   });
+
+  test("rejects non-guardian actors", async () => {
+    const result = await executeScheduleUpdate(
+      {
+        job_id: "nonexistent-id",
+        message: "injected",
+      },
+      trustedCtx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("restricted to guardian actors");
+  });
 });
 
 // ── schedule_update with mode and routing ────────────────────────────

package/src/__tests__/script-proxy-certs.test.ts

@@ -84,7 +84,7 @@ describe("issueLeafCert", () => {
 
     expect(certA.cert).not.toBe(certB.cert);
     expect(certA.key).not.toBe(certB.key);
-  });
+  }, 15_000);
 });
 
 describe("getCAPath", () => {

package/src/__tests__/secret-onetime-send.test.ts

@@ -43,6 +43,7 @@ mock.module("../security/secure-keys.js", () => {
   };
   return {
     getSecureKey: (key: string) => storedKeys.get(key) ?? null,
+    getSecureKeyAsync: async (key: string) => storedKeys.get(key) ?? undefined,
     setSecureKey: syncSet,
     setSecureKeyAsync: async (key: string, value: string) =>
       syncSet(key, value),

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

@@ -0,0 +1,183 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { credentialKey } from "../security/credential-key.js";
+
+let lastGeminiConstructorOpts: Record<string, unknown> | null = null;
+let secureKeyStore: Record<string, string | undefined> = {};
+const metadataUpserts: Array<{ service: string; field: string }> = [];
+const metadataDeletes: Array<{ service: string; field: string }> = [];
+
+const PLATFORM_BASE_URL = "https://platform.example.com";
+const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
+const MANAGED_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "gemini",
+  "fireworks",
+  "openrouter",
+] as const;
+
+const mockConfig = {
+  apiKeys: {},
+  provider: "anthropic",
+  model: "test-model",
+};
+
+mock.module("@google/genai", () => ({
+  GoogleGenAI: class MockGoogleGenAI {
+    constructor(opts: Record<string, unknown>) {
+      lastGeminiConstructorOpts = opts;
+    }
+    models = {
+      generateContentStream: async () => ({
+        [Symbol.asyncIterator]: async function* () {
+          /* no chunks */
+        },
+      }),
+    };
+  },
+  ApiError: class FakeApiError extends Error {
+    status: number;
+    constructor(status: number, message: string) {
+      super(message);
+      this.status = status;
+      this.name = "ApiError";
+    }
+  },
+}));
+
+mock.module("../config/env.js", () => ({
+  getPlatformBaseUrl: () => PLATFORM_BASE_URL,
+}));
+
+mock.module("../config/loader.js", () => ({
+  API_KEY_PROVIDERS: [
+    "anthropic",
+    "openai",
+    "gemini",
+    "fireworks",
+    "openrouter",
+  ],
+  getConfig: () => mockConfig,
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../logfire.js", () => ({
+  wrapWithLogfire: (provider: unknown) => provider,
+}));
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKey: (key: string) => secureKeyStore[key],
+  getSecureKeyAsync: async (key: string) => secureKeyStore[key],
+  setSecureKeyAsync: async (key: string, value: string) => {
+    secureKeyStore[key] = value;
+    return true;
+  },
+  deleteSecureKeyAsync: async (key: string) => {
+    delete secureKeyStore[key];
+    return "deleted";
+  },
+}));
+
+mock.module("../tools/credentials/metadata-store.js", () => ({
+  assertMetadataWritable: () => {},
+  upsertCredentialMetadata: (service: string, field: string) => {
+    metadataUpserts.push({ service, field });
+  },
+  deleteCredentialMetadata: (service: string, field: string) => {
+    metadataDeletes.push({ service, field });
+  },
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  getProviderRoutingSource,
+  initializeProviders,
+  listProviders,
+} from "../providers/registry.js";
+import {
+  handleAddSecret,
+  handleDeleteSecret,
+} from "../runtime/routes/secret-routes.js";
+
+function makeAddCredentialRequest(name: string, value: string): Request {
+  return new Request("http://localhost/v1/secrets", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      type: "credential",
+      name,
+      value,
+    }),
+  });
+}
+
+function makeDeleteCredentialRequest(name: string): Request {
+  return new Request("http://localhost/v1/secrets", {
+    method: "DELETE",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      type: "credential",
+      name,
+    }),
+  });
+}
+
+describe("secret routes managed proxy registry sync", () => {
+  beforeEach(() => {
+    secureKeyStore = {};
+    metadataUpserts.length = 0;
+    metadataDeletes.length = 0;
+    lastGeminiConstructorOpts = null;
+    initializeProviders(mockConfig);
+  });
+
+  test("adding vellum:assistant_api_key bootstraps managed providers immediately", async () => {
+    expect(listProviders()).toEqual([]);
+
+    const res = await handleAddSecret(
+      makeAddCredentialRequest("vellum:assistant_api_key", "ast-managed-key"),
+    );
+
+    expect(res.status).toBe(201);
+    expect(secureKeyStore[ASSISTANT_API_KEY_PATH]).toBe("ast-managed-key");
+    expect(metadataUpserts).toEqual([
+      { service: "vellum", field: "assistant_api_key" },
+    ]);
+
+    const providers = listProviders();
+    expect(providers).toHaveLength(MANAGED_PROVIDERS.length);
+    for (const provider of MANAGED_PROVIDERS) {
+      expect(providers).toContain(provider);
+      expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+    }
+    expect(lastGeminiConstructorOpts).toBeDefined();
+  });
+
+  test("deleting vellum:assistant_api_key clears managed providers immediately", async () => {
+    secureKeyStore[ASSISTANT_API_KEY_PATH] = "ast-managed-key";
+    initializeProviders(mockConfig);
+
+    for (const provider of MANAGED_PROVIDERS) {
+      expect(listProviders()).toContain(provider);
+      expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+    }
+
+    const res = await handleDeleteSecret(
+      makeDeleteCredentialRequest("vellum:assistant_api_key"),
+    );
+
+    expect(res.status).toBe(200);
+    expect(secureKeyStore[ASSISTANT_API_KEY_PATH]).toBeUndefined();
+    expect(metadataDeletes).toEqual([
+      { service: "vellum", field: "assistant_api_key" },
+    ]);
+    expect(listProviders()).toEqual([]);
+  });
+});

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

@@ -33,12 +33,14 @@ let mockBrokerStore: Map<string, string> = new Map();
 let mockBrokerGetError = false;
 let mockBrokerSetError = false;
 let mockBrokerDelError = false;
+let mockBrokerGetCalled = false;
 
 mock.module("../security/keychain-broker-client.js", () => ({
   createBrokerClient: () => ({
     isAvailable: () => mockBrokerAvailable,
     ping: async () => (mockBrokerAvailable ? { pong: true } : null),
     get: async (account: string) => {
+      mockBrokerGetCalled = true;
       // null = broker error (fall back to encrypted store)
       if (mockBrokerGetError) return null;
       const value = mockBrokerStore.get(account);
@@ -46,9 +48,14 @@ mock.module("../security/keychain-broker-client.js", () => ({
       return { found: false };
     },
     set: async (account: string, value: string) => {
-      if (mockBrokerSetError) return false;
+      if (mockBrokerSetError)
+        return {
+          status: "rejected" as const,
+          code: "KEYCHAIN_ERROR",
+          message: "mock error",
+        };
       mockBrokerStore.set(account, value);
-      return true;
+      return { status: "ok" as const };
     },
     del: async (account: string) => {
       if (mockBrokerDelError) return false;
@@ -95,6 +102,7 @@ describe("secure-keys", () => {
     mockBrokerGetError = false;
     mockBrokerSetError = false;
     mockBrokerDelError = false;
+    mockBrokerGetCalled = false;
 
     if (existsSync(TEST_DIR)) {
       rmSync(TEST_DIR, { recursive: true });
@@ -202,20 +210,22 @@ describe("secure-keys", () => {
   // Async variants — broker available path
   // -----------------------------------------------------------------------
   describe("async variants with broker available", () => {
-    test("getSecureKeyAsync returns broker value when available", async () => {
+    test("getSecureKeyAsync returns encrypted store value when both stores have key", async () => {
       mockBrokerAvailable = true;
       mockBrokerStore.set("api-key", "broker-value");
       setSecureKey("api-key", "encrypted-value");
-      expect(await getSecureKeyAsync("api-key")).toBe("broker-value");
+      // Encrypted store is checked first — broker is never called
+      expect(await getSecureKeyAsync("api-key")).toBe("encrypted-value");
+      expect(mockBrokerGetCalled).toBe(false);
     });
 
-    test("getSecureKeyAsync falls back to encrypted store when broker reports not-found", async () => {
+    test("getSecureKeyAsync returns encrypted store value without calling broker", async () => {
       mockBrokerAvailable = true;
-      // Broker has nothing for this key — returns { found: false }.
-      // Keys may exist only in the encrypted store (written while broker
-      // was unavailable or via sync setSecureKey), so we must fall back.
+      // Only encrypted store has the key — broker has nothing.
+      // Encrypted store is checked first, so broker.get() is never called.
       setSecureKey("api-key", "encrypted-value");
       expect(await getSecureKeyAsync("api-key")).toBe("encrypted-value");
+      expect(mockBrokerGetCalled).toBe(false);
     });
 
     test("getSecureKeyAsync returns undefined when neither broker nor encrypted store has key", async () => {
@@ -224,11 +234,14 @@ describe("secure-keys", () => {
       expect(await getSecureKeyAsync("missing-key")).toBeUndefined();
     });
 
-    test("getSecureKeyAsync falls back to encrypted store on broker error", async () => {
+    test("getSecureKeyAsync returns encrypted store value even when broker would error", async () => {
       mockBrokerAvailable = true;
       mockBrokerGetError = true;
+      // Encrypted store hit short-circuits — broker is never called, so
+      // the broker error flag is irrelevant.
       setSecureKey("api-key", "encrypted-value");
       expect(await getSecureKeyAsync("api-key")).toBe("encrypted-value");
+      expect(mockBrokerGetCalled).toBe(false);
     });
 
     test("setSecureKeyAsync writes to broker and encrypted store", async () => {
@@ -303,10 +316,56 @@ describe("secure-keys", () => {
   });
 
   // -----------------------------------------------------------------------
-  // Stale-value prevention — broker-first reads after credential updates
+  // Encrypted-store-first read order
+  // -----------------------------------------------------------------------
+  describe("encrypted-store-first read order", () => {
+    test("returns value from encrypted store without calling broker", async () => {
+      mockBrokerAvailable = true;
+      setSecureKey("test-account", "test-secret");
+      mockBrokerStore.set("test-account", "broker-secret");
+
+      const result = await getSecureKeyAsync("test-account");
+      expect(result).toBe("test-secret");
+      // Broker should never have been called — encrypted store hit
+      // short-circuits the lookup.
+      expect(mockBrokerGetCalled).toBe(false);
+    });
+
+    test("falls back to broker when encrypted store returns undefined", async () => {
+      mockBrokerAvailable = true;
+      // Encrypted store has nothing for this key
+      mockBrokerStore.set("test-account", "broker-secret");
+
+      const result = await getSecureKeyAsync("test-account");
+      expect(result).toBe("broker-secret");
+      // Broker should have been called as fallback
+      expect(mockBrokerGetCalled).toBe(true);
+    });
+
+    test("returns undefined when neither store has the key", async () => {
+      mockBrokerAvailable = true;
+      // Neither encrypted store nor broker has the key
+
+      const result = await getSecureKeyAsync("test-account");
+      expect(result).toBeUndefined();
+    });
+
+    test("returns undefined without broker call when broker unavailable and encrypted store empty", async () => {
+      // Broker is unavailable (default state), encrypted store is empty
+      mockBrokerAvailable = false;
+
+      const result = await getSecureKeyAsync("test-account");
+      expect(result).toBeUndefined();
+      // Broker.get() should not have been called since broker is unavailable
+      expect(mockBrokerGetCalled).toBe(false);
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Stale-value prevention — encrypted-store-first reads avoid stale broker data
   // -----------------------------------------------------------------------
   describe("stale-value prevention", () => {
-    test("setSecureKeyAsync updates broker so broker-first read returns new value", async () => {
+    test("setSecureKeyAsync updates both stores so encrypted-store-first read returns new value", async () => {
       mockBrokerAvailable = true;
       // Simulate broker holding an old value
       mockBrokerStore.set("api-key", "old-broker-value");
@@ -316,7 +375,7 @@ describe("secure-keys", () => {
       const ok = await setSecureKeyAsync("api-key", "new-value");
       expect(ok).toBe(true);
 
-      // Broker-first read should return the new value, not stale old value
+      // Encrypted-store-first read returns the new value
       const value = await getSecureKeyAsync("api-key");
       expect(value).toBe("new-value");
       // Both stores should agree
@@ -324,7 +383,7 @@ describe("secure-keys", () => {
       expect(getSecureKey("api-key")).toBe("new-value");
     });
 
-    test("deleteSecureKeyAsync removes from broker so broker-first read falls through", async () => {
+    test("deleteSecureKeyAsync removes from both stores so read returns undefined", async () => {
       mockBrokerAvailable = true;
       mockBrokerStore.set("api-key", "old-broker-value");
       setSecureKey("api-key", "old-encrypted-value");
@@ -333,22 +392,23 @@ describe("secure-keys", () => {
       const result = await deleteSecureKeyAsync("api-key");
       expect(result).toBe("deleted");
 
-      // Broker-first read should not find the key in either store
+      // Neither store has the key — returns undefined
       const value = await getSecureKeyAsync("api-key");
       expect(value).toBeUndefined();
     });
 
-    test("sync setSecureKey does NOT update broker — stale read demonstrates the problem", async () => {
+    test("sync setSecureKey updates encrypted store — encrypted-store-first read returns fresh value", async () => {
       mockBrokerAvailable = true;
       mockBrokerStore.set("api-key", "old-broker-value");
 
       // Sync write only updates encrypted store, NOT broker
       setSecureKey("api-key", "new-encrypted-value");
 
-      // Broker-first read still returns the stale broker value
+      // Encrypted-store-first read returns the fresh encrypted value,
+      // bypassing the stale broker entirely.
       const value = await getSecureKeyAsync("api-key");
-      expect(value).toBe("old-broker-value");
-      // This is the exact bug that async migration fixes
+      expect(value).toBe("new-encrypted-value");
+      expect(mockBrokerGetCalled).toBe(false);
     });
 
     test("setSecureKeyAsync failure leaves both stores unchanged", async () => {

package/src/__tests__/send-endpoint-busy.test.ts

@@ -118,6 +118,7 @@ function makeCompletingSession(): Session {
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
+    addPreactivatedSkillId: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -175,6 +176,7 @@ function makeHangingSession(): Session {
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
+    addPreactivatedSkillId: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -260,6 +262,7 @@ function makePendingApprovalSession(
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
     setHostCuProxy: () => {},
+    addPreactivatedSkillId: () => {},
     hasAnyPendingConfirmation: () => pending.size > 0,
     hasPendingConfirmation: (candidateRequestId: string) =>
       pending.has(candidateRequestId),

package/src/__tests__/server-history-render.test.ts

@@ -78,7 +78,7 @@ describe("renderHistoryContent", () => {
     );
   });
 
-  test("renders image attachments in history output", () => {
+  test("skips image attachment placeholder text (images sent as separate attachments)", () => {
     const output = renderHistoryContent([
       {
         type: "image",
@@ -90,7 +90,7 @@ describe("renderHistoryContent", () => {
       },
     ]);
 
-    expect(output.text).toContain("[Image attachment] image/png, 5 B");
+    expect(output.text).toBe("");
   });
 
   test("appends attachment lines after text content", () => {

package/src/__tests__/session-abort-tool-results.test.ts

@@ -75,18 +75,6 @@ mock.module("../security/secret-allowlist.js", () => ({
   resetAllowlist: () => {},
 }));
 
-mock.module("../memory/admin.js", () => ({
-  getMemoryConflictAndCleanupStats: () => ({
-    conflicts: { pending: 0, resolved: 0, oldestPendingAgeMs: null },
-    cleanup: {
-      resolvedBacklog: 0,
-      supersededBacklog: 0,
-      resolvedCompleted24h: 0,
-      supersededCompleted24h: 0,
-    },
-  }),
-}));
-
 // Track all messages persisted to DB
 let persistedMessages: Array<{ role: string; content: string }> = [];
 
@@ -128,13 +116,12 @@ mock.module("../memory/retriever.js", () => ({
     enabled: false,
     degraded: false,
     injectedText: "",
-    lexicalHits: 0,
+
     semanticHits: 0,
     recencyHits: 0,
     injectedTokens: 0,
     latencyMs: 0,
   }),
-  injectMemoryRecallIntoUserMessage: (msg: Message) => msg,
   stripMemoryRecallMessages: (msgs: Message[]) => msgs,
 }));