@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/__tests__/conversation-title-service.test.ts

@@ -462,6 +462,103 @@ describe("conversation-title-service", () => {
     expect(result).toEqual({ title: "Existing Title", updated: false });
   });
 
+  test.each([
+    ["an image-only prompt", ""],
+    ["a whitespace-only prompt", "   \n  "],
+    ["a thinking-tags-only prompt", "<thinking>untitled</thinking>"],
+  ])(
+    "keeps a background job's deterministic title through %s",
+    async (_label, userMessage) => {
+      // A background conversation carries a deterministic bootstrap title
+      // naming its job. A follow-up with no text to title from must leave it
+      // alone rather than have the model invent an unrelated topic.
+      mockGetConversation.mockImplementation(() => ({
+        title: "Memory consolidation",
+        isAutoTitle: AUTO_TITLE_DETERMINISTIC,
+      }));
+
+      const provider = makeProvider();
+
+      const result = await generateAndPersistConversationTitle({
+        conversationId: "conv-1",
+        provider,
+        userMessage,
+      });
+
+      expect(provider.sendMessage).not.toHaveBeenCalled();
+      expect(mockUpdateConversationTitle).not.toHaveBeenCalled();
+      expect(mockPublishConversationTitleChanged).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        title: "Memory consolidation",
+        updated: false,
+      });
+    },
+  );
+
+  test("replaces the loading placeholder when a prompt has no text", async () => {
+    // Same skipped LLM call, but a conversation still on the loading
+    // placeholder has no title worth keeping, so it settles on a
+    // deterministic one the stop hook can still upgrade.
+    const provider = makeProvider();
+
+    const result = await generateAndPersistConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "",
+    });
+
+    expect(provider.sendMessage).not.toHaveBeenCalled();
+    expect(result).toEqual({ title: "Untitled Conversation", updated: true });
+    expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
+      "conv-1",
+      "Untitled Conversation",
+      AUTO_TITLE_DETERMINISTIC,
+    );
+  });
+
+  test("keeps a background job's deterministic title when the model declines", async () => {
+    // The model answered with prose the normalizer rejects, so there is no
+    // generated title. Settling for "Untitled Conversation" would name the
+    // job's work less well than the bootstrap title already does.
+    mockGetConversation.mockImplementation(() => ({
+      title: "Memory consolidation",
+      isAutoTitle: AUTO_TITLE_DETERMINISTIC,
+    }));
+
+    const provider = makeProvider(async () =>
+      textResponse("I need to generate a title for this conversation"),
+    );
+
+    const result = await generateAndPersistConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "what did you consolidate?",
+    });
+
+    expect(provider.sendMessage).toHaveBeenCalledTimes(1);
+    expect(mockUpdateConversationTitle).not.toHaveBeenCalled();
+    expect(result).toEqual({ title: "Memory consolidation", updated: false });
+  });
+
+  test("still generates when only creation metadata describes the topic", async () => {
+    // Voice call sites pass context hints and no user message. Those carry a
+    // topic, so the skip must not swallow them.
+    const provider = makeProvider(async () => toolResponse("Inbound Call"));
+
+    const result = await generateAndPersistConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      context: {
+        origin: "voice_inbound",
+        sourceChannel: "phone",
+        systemHint: "Inbound call",
+      },
+    });
+
+    expect(provider.sendMessage).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ title: "Inbound Call", updated: true });
+  });
+
   test("title prompt content does not contain generation instructions", async () => {
     const provider = makeProvider();
 

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -402,6 +402,22 @@ describe("createToolExecutor channel-permission coordinate threading", () => {
     expect(calls[0].context.channelPermissionChannelId).toBeUndefined();
     expect(bindingLookups).toEqual([]);
   });
+
+  test("copies the requester contact id from turn trust onto tool context", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    await makeToolFn(
+      executor,
+      makeCtx({
+        currentTurnTrustContext: {
+          sourceChannel: "slack",
+          trustClass: "trusted_contact",
+          requesterContactId: "contact-abc",
+        },
+      }),
+    )("file_read", { path: "/tmp/a" });
+
+    expect(calls[0].context.requesterContactId).toBe("contact-abc");
+  });
 });
 
 describe("createToolExecutor source-actor threading", () => {

package/src/__tests__/credential-broker-server-use.test.ts

@@ -44,24 +44,8 @@ import { setSecureKeyAsync } from "../security/secure-keys.js";
 import { CredentialBroker } from "../tools/credentials/broker.js";
 import {
   _setMetadataPath,
-  type CredentialMetadata,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
-import { serverUseDenialReason } from "../tools/credentials/tool-policy.js";
-
-/** The shared policy's verdict for a state the broker must also deny. */
-function sharedDenialReason(
-  metadata: CredentialMetadata,
-  toolName: string,
-  service: string,
-  field: string,
-): string {
-  const reason = serverUseDenialReason(metadata, toolName, service, field);
-  if (!reason) {
-    throw new Error("expected a denial reason from the shared policy");
-  }
-  return reason;
-}
 
 // ---------------------------------------------------------------------------
 // Tests — serverUse (publish_page / unpublish_page regression)
@@ -408,24 +392,6 @@ describe("CredentialBroker.serverUse", () => {
       expect(r2.result).toBe("triggered");
     });
 
-    test("different services with same field name are independent (serverUseById)", async () => {
-      const meta1 = upsertCredentialMetadata("github", "api_token", {
-        allowedTools: ["github_api"],
-      });
-      upsertCredentialMetadata("gitlab", "api_token", {
-        allowedTools: ["gitlab_api"],
-      });
-      await setSecureKeyAsync(credentialKey("github", "api_token"), "gh_tok");
-      await setSecureKeyAsync(credentialKey("gitlab", "api_token"), "gl_tok");
-
-      // github credential should not serve gitlab tool
-      const r1 = await broker.serverUseById({
-        credentialId: meta1.credentialId,
-        requestingTool: "gitlab_api",
-      });
-      expect(r1.success).toBe(false);
-    });
-
     test("different services with same field name are independent", async () => {
       upsertCredentialMetadata("github", "api_token", {
         allowedTools: ["github_api"],
@@ -461,187 +427,3 @@ describe("CredentialBroker.serverUse", () => {
     });
   });
 });
-
-// ---------------------------------------------------------------------------
-// Tests — serverUseById (proxy credential consumption by ID)
-// ---------------------------------------------------------------------------
-
-describe("CredentialBroker.serverUseById", () => {
-  let broker: CredentialBroker;
-
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-    setStorePathForTesting(STORE_PATH);
-    _resetBackend();
-    _setMetadataPath(join(TEST_DIR, "metadata.json"));
-    broker = new CredentialBroker();
-  });
-
-  afterEach(() => {
-    _setMetadataPath(null);
-    setStorePathForTesting(null);
-    _resetBackend();
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  test("returns metadata and injection templates for valid credential", async () => {
-    const meta = upsertCredentialMetadata("fal", "api_key", {
-      allowedTools: ["media_proxy"],
-      injectionTemplates: [
-        {
-          hostPattern: "*.fal.ai",
-          injectionType: "header",
-          headerName: "Authorization",
-          valuePrefix: "Key ",
-        },
-      ],
-    });
-    await setSecureKeyAsync(credentialKey("fal", "api_key"), "fal-secret-key");
-
-    const result = await broker.serverUseById({
-      credentialId: meta.credentialId,
-      requestingTool: "media_proxy",
-    });
-
-    expect(result.success).toBe(true);
-    if (!result.success) {
-      throw new Error("expected success");
-    }
-    expect(result.credentialId).toBe(meta.credentialId);
-    expect(result.service).toBe("fal");
-    expect(result.field).toBe("api_key");
-    expect(result.injectionTemplates).toHaveLength(1);
-    expect(result.injectionTemplates[0].hostPattern).toBe("*.fal.ai");
-    expect(result.injectionTemplates[0].headerName).toBe("Authorization");
-    expect(result.injectionTemplates[0].valuePrefix).toBe("Key ");
-    // Secret value must NEVER appear in the result
-    const serialized = JSON.stringify(result);
-    expect(serialized).not.toContain("fal-secret-key");
-  });
-
-  test("denies when requesting tool is not in allowed list", async () => {
-    const meta = upsertCredentialMetadata("fal", "api_key", {
-      allowedTools: ["media_proxy"],
-    });
-    await setSecureKeyAsync(credentialKey("fal", "api_key"), "fal-secret-key");
-
-    const result = await broker.serverUseById({
-      credentialId: meta.credentialId,
-      requestingTool: "unauthorized_tool",
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) {
-      throw new Error("expected denial");
-    }
-    // The broker passes the shared server-use policy's verdict through verbatim.
-    expect(result.reason).toBe(
-      sharedDenialReason(meta, "unauthorized_tool", "fal", "api_key"),
-    );
-  });
-
-  test("returns not found for unknown credential ID", async () => {
-    const result = await broker.serverUseById({
-      credentialId: "nonexistent-id",
-      requestingTool: "media_proxy",
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) {
-      throw new Error("expected denial");
-    }
-    expect(result.reason).toContain("No credential found");
-    expect(result.reason).toContain("nonexistent-id");
-  });
-
-  test("denies when credential has domain restrictions", async () => {
-    const meta = upsertCredentialMetadata("github", "oauth_token", {
-      allowedTools: ["media_proxy"],
-      allowedDomains: ["github.com"],
-    });
-    await setSecureKeyAsync(credentialKey("github", "oauth_token"), "gho_test");
-
-    const result = await broker.serverUseById({
-      credentialId: meta.credentialId,
-      requestingTool: "media_proxy",
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) {
-      throw new Error("expected denial");
-    }
-    // The broker passes the shared server-use policy's verdict through verbatim.
-    expect(result.reason).toBe(
-      sharedDenialReason(meta, "media_proxy", "github", "oauth_token"),
-    );
-  });
-
-  test("returns empty injection templates when credential has none", async () => {
-    const meta = upsertCredentialMetadata("vercel", "api_token", {
-      allowedTools: ["media_proxy"],
-    });
-    await setSecureKeyAsync(
-      credentialKey("vercel", "api_token"),
-      "test-vercel-token",
-    );
-
-    const result = await broker.serverUseById({
-      credentialId: meta.credentialId,
-      requestingTool: "media_proxy",
-    });
-
-    expect(result.success).toBe(true);
-    if (!result.success) {
-      throw new Error("expected success");
-    }
-    expect(result.injectionTemplates).toEqual([]);
-  });
-
-  test("denies with empty allowedTools and suggests updating credential", async () => {
-    const meta = upsertCredentialMetadata("stripe", "secret_key", {
-      allowedTools: [],
-    });
-    await setSecureKeyAsync(
-      credentialKey("stripe", "secret_key"),
-      "sk_test_xyz",
-    );
-
-    const result = await broker.serverUseById({
-      credentialId: meta.credentialId,
-      requestingTool: "media_proxy",
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) {
-      throw new Error("expected denial");
-    }
-    expect(result.reason).toContain("No tools are currently allowed");
-    expect(result.reason).toContain("assistant credentials prompt");
-  });
-
-  test("denies when metadata exists but no stored secret value", async () => {
-    const meta = upsertCredentialMetadata("fal", "api_key", {
-      allowedTools: ["media_proxy"],
-      injectionTemplates: [
-        {
-          hostPattern: "*.fal.ai",
-          injectionType: "header",
-          headerName: "Authorization",
-          valuePrefix: "Key ",
-        },
-      ],
-    });
-    // No setSecureKeyAsync — metadata exists but value doesn't
-
-    const result = await broker.serverUseById({
-      credentialId: meta.credentialId,
-      requestingTool: "media_proxy",
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) {
-      throw new Error("expected denial");
-    }
-    expect(result.reason).toContain("no stored value");
-  });
-});