@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/__tests__/injector-v3-suppression.test.ts

@@ -110,7 +110,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // Exactly one <memory> source across the WHOLE assembled context.
@@ -149,7 +149,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // v2's block survives — the turn still ships memory.
@@ -177,7 +177,7 @@ describe("memory-v3-live v2 suppression", () => {
     // captures the exact pre-flag assembly behavior: v2 prefix stays, v3
     // splices after it.
     const offResult = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // The tail keeps v2's block AND gains v3's (the historical double-injection
@@ -206,7 +206,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     expect(result.messages).toEqual(runMessages);

package/src/__tests__/list-messages-client-message-id.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for handleListMessages clientMessageId projection.
+ *
+ * Verifies that the persisted idempotency nonce is echoed back on the
+ * messages snapshot row so a client can correlate its optimistic row with
+ * the confirmed server row by identity instead of matching message text.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+interface MessagePayload {
+  role: string;
+  clientMessageId?: string;
+}
+
+describe("handleListMessages clientMessageId", () => {
+  beforeEach(resetTables);
+
+  test("echoes the persisted clientMessageId onto the user row", async () => {
+    // GIVEN a user message persisted with a client-generated idempotency nonce
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+      { clientMessageId: "nonce-abc", skipIndexing: true },
+    );
+
+    // WHEN the messages snapshot is built
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the snapshot row carries the nonce back for id-based correlation
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].role).toBe("user");
+    expect(body.messages[0].clientMessageId).toBe("nonce-abc");
+  });
+
+  test("omits clientMessageId when the row was persisted without one", async () => {
+    // GIVEN a user message persisted without a client nonce (e.g. a channel send)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the messages snapshot is built
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the field is absent rather than emitted as null/empty
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].clientMessageId).toBeUndefined();
+  });
+});

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -96,6 +96,44 @@ describe("handleListMessages metadata.hidden filtering", () => {
     expect(llmRows[1].metadata).toContain('"hidden":true');
   });
 
+  test("UI serializer omits system rows but LLM-side getMessages includes them", async () => {
+    // GIVEN a conversation with a system row sandwiched between two
+    // renderable turns (e.g. a skill-authored context message)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "first visible" }]),
+    );
+    await addMessage(
+      conv.id,
+      "system",
+      JSON.stringify([{ type: "text", text: "system scaffolding" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "second visible" }]),
+    );
+
+    // WHEN the UI history list is serialized
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN only the user/assistant turns are returned, never the system row
+    expect(body.messages.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      body.messages.some((m) => plainText(m).includes("system scaffolding")),
+    ).toBe(false);
+
+    // AND the LLM-side loader still includes the system row for agent context
+    const llmRows = getMessages(conv.id);
+    expect(llmRows).toHaveLength(3);
+    expect(llmRows[1].role).toBe("system");
+  });
+
   test("messages without metadata or with hidden=false are returned", async () => {
     const conv = createConversation();
     await addMessage(

package/src/__tests__/llm-catalog-parity.test.ts

@@ -53,6 +53,7 @@ interface ClientCatalogModel {
   longContextPricingThresholdTokens?: number;
   longContextMode?: "native-model" | "provider-request-option" | "unsupported";
   supportsThinking?: boolean;
+  adaptiveThinkingOnly?: boolean;
   supportsCaching?: boolean;
   supportsVision?: boolean;
   supportsToolUse?: boolean;
@@ -194,6 +195,9 @@ describe("LLM catalog parity: daemon vs client", () => {
         );
         expect(clientModel.longContextMode).toBe(daemonModel.longContextMode);
         expect(clientModel.supportsThinking).toBe(daemonModel.supportsThinking);
+        expect(clientModel.adaptiveThinkingOnly).toBe(
+          daemonModel.adaptiveThinkingOnly,
+        );
         expect(clientModel.supportsCaching).toBe(daemonModel.supportsCaching);
         expect(clientModel.supportsVision).toBe(daemonModel.supportsVision);
         expect(clientModel.supportsToolUse).toBe(daemonModel.supportsToolUse);

package/src/__tests__/llm-resolver.test.ts

@@ -1249,3 +1249,76 @@ describe("resolveDefaultProfileKey", () => {
     expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
   });
 });
+
+describe("resolveCallSiteConfig logitBias provenance", () => {
+  const kimi = "accounts/fireworks/models/kimi-k2p6";
+
+  test("forwards logitBias from the active profile that opted in", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "balanced-economy": {
+          provider: "fireworks",
+          model: kimi,
+          logitBias: "suppress-cjk",
+        },
+      },
+      activeProfile: "balanced-economy",
+    });
+    expect(resolveCallSiteConfig("mainAgent", llm).logitBias).toBe(
+      "suppress-cjk",
+    );
+  });
+
+  test("a higher-precedence override profile that omits logitBias clears it", () => {
+    // Active profile opts in, but a pinned (override) Kimi profile did not —
+    // the override must not inherit suppress-cjk just because it resolves to
+    // Fireworks.
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "balanced-economy": {
+          provider: "fireworks",
+          model: kimi,
+          logitBias: "suppress-cjk",
+        },
+        "my-kimi": { provider: "fireworks", model: kimi },
+      },
+      activeProfile: "balanced-economy",
+    });
+    const resolved = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "my-kimi",
+    });
+    expect(resolved.logitBias).toBeUndefined();
+  });
+
+  test("does not leak the active profile's logitBias into a call site's own profile", () => {
+    // For non-main call sites the call-site profile wins; since it didn't opt
+    // in, the active profile's preset must not bleed through.
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "balanced-economy": {
+          provider: "fireworks",
+          model: kimi,
+          logitBias: "suppress-cjk",
+        },
+        plain: { provider: "anthropic", model: "claude-opus-4-7" },
+      },
+      activeProfile: "balanced-economy",
+      callSites: { memoryExtraction: { profile: "plain" } },
+    });
+    expect(
+      resolveCallSiteConfig("memoryExtraction", llm).logitBias,
+    ).toBeUndefined();
+  });
+
+  test("a logitBias on a non-profile layer (llm.default) does not apply when the winning profile omits it", () => {
+    const llm = LLMSchema.parse({
+      default: { ...fullDefault, logitBias: "suppress-cjk" },
+      profiles: { plain: { provider: "anthropic", model: "claude-opus-4-7" } },
+      activeProfile: "plain",
+    });
+    expect(resolveCallSiteConfig("mainAgent", llm).logitBias).toBeUndefined();
+  });
+});

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -1,12 +1,16 @@
 /**
- * Tests for the default `user-prompt-submit-temp` hook (memory retrieval).
+ * Tests for the default `user-prompt-submit` hook (memory retrieval +
+ * runtime injection).
  *
  * Covers the retrieval behavior, the side effects the hook owns (injected-block
- * metadata, recall log, `memory_recalled` event), trust gating, error
- * propagation, and abort-signal forwarding. Uses `mock.module` to stub the
- * persistence helpers so the test doesn't touch the developer's real
- * `~/.vellum` or database. The memory graph handle is a hand-rolled fake
- * passed on the hook context — the hook only needs `prepareMemory`.
+ * metadata, recall log, `memory_recalled` event), trust gating, the runtime
+ * injection the hook applies for every actor (and the assembled-block persist),
+ * error propagation, and abort-signal forwarding. Uses `mock.module` to stub
+ * the persistence helpers, `applyRuntimeInjections`, and the conversation
+ * registry / trust resolver so the test doesn't touch the developer's real
+ * `~/.vellum`, database, or live conversation state. The memory graph handle,
+ * abort signal, and trust class are self-resolved by the hook from a fake
+ * conversation installed in the registry mock.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -23,13 +27,52 @@ mock.module("../memory/memory-recall-log-store.js", () => ({
   recordMemoryRecallLog: recordMemoryRecallLogMock,
 }));
 
+// Pass-through injection stub: returns the input messages unchanged with no
+// assembled blocks, so existing array-identity assertions hold. Individual
+// tests override it via `mockImplementationOnce` to exercise injected blocks.
+const applyRuntimeInjectionsMock = mock(async (messages: unknown) => ({
+  messages,
+  blocks: {},
+}));
+mock.module("../daemon/conversation-runtime-assembly.js", () => ({
+  applyRuntimeInjections: applyRuntimeInjectionsMock,
+  resolveTurnInboundActorContext: () => null,
+  resolveTurnModelProfileLabel: () => null,
+}));
+
+// The hook self-resolves the live conversation and its trust class; both are
+// driven from these refs so each test controls what the hook sees.
+let currentConversation: Conversation | undefined;
+let currentTrustClass: "guardian" | "unknown" = "guardian";
+const findConversationOrSubagentMock = mock(
+  (_conversationId?: string) => currentConversation,
+);
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversationOrSubagent: findConversationOrSubagentMock,
+}));
+mock.module("../daemon/trust-context.js", () => ({
+  resolveTrustClass: () => currentTrustClass,
+}));
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}) as AssistantConfig,
+}));
+
+// The hook publishes `memory_recalled` (and forwards the sink into
+// `prepareMemory` for `memory_status`) through the shared `broadcastMessage`
+// hub. Stub it so tests can assert what the hook emits.
+const broadcastMessageMock = mock((_msg: unknown) => {});
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: broadcastMessageMock,
+}));
+
+import type { UserPromptSubmitContext } from "@vellumai/plugin-api";
+
 import type { AssistantConfig } from "../config/schema.js";
+import type { Conversation } from "../daemon/conversation.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
-import userPromptSubmitMemoryRetrieval, {
-  type MemoryRetrievalHookContext,
-} from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit-temp.js";
+import userPromptSubmitMemoryRetrieval from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit.js";
 import type { Message } from "../providers/types.js";
 
 /** Canonical metrics payload the graph retriever attaches to a real hit. */
@@ -102,31 +145,55 @@ function makeFakeGraphMemory(overrides?: {
 }
 
 function makeHookCtx(
-  overrides: Partial<MemoryRetrievalHookContext> = {},
-): MemoryRetrievalHookContext {
-  const { memory } = makeFakeGraphMemory();
+  overrides: Partial<UserPromptSubmitContext> = {},
+): UserPromptSubmitContext {
   return {
-    graphMemory: memory,
-    config: {} as AssistantConfig,
-    onEvent: () => {},
-    isTrustedActor: true,
     conversationId: "conv-test",
     userMessageId: "msg-test",
     logger: {
       warn: () => {},
-    } as unknown as MemoryRetrievalHookContext["logger"],
-    signal: new AbortController().signal,
+    } as unknown as UserPromptSubmitContext["logger"],
     latestMessages: [],
+    requestId: "req-test",
+    isNonInteractive: false,
+    modelProfileKey: null,
+    prompt: "",
+    originalMessages: [],
     ...overrides,
   };
 }
 
+/**
+ * Install a fake live conversation for the hook to self-resolve by id: the
+ * graph handle, abort signal, and trust class all come from here rather than
+ * the hook context.
+ */
+function installConversation(
+  graphMemory: ConversationGraphMemory,
+  opts?: {
+    trusted?: boolean;
+    signal?: AbortSignal;
+  },
+): void {
+  currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
+  currentConversation = {
+    graphMemory,
+    trustContext: undefined,
+    abortController: { signal: opts?.signal ?? new AbortController().signal },
+  } as unknown as Conversation;
+}
+
 beforeEach(() => {
   updateMessageMetadataMock.mockReset();
   recordMemoryRecallLogMock.mockReset();
+  applyRuntimeInjectionsMock.mockClear();
+  findConversationOrSubagentMock.mockClear();
+  broadcastMessageMock.mockReset();
+  currentConversation = undefined;
+  currentTrustClass = "guardian";
 });
 
-describe("user-prompt-submit-temp hook (memory retrieval)", () => {
+describe("user-prompt-submit hook (memory retrieval)", () => {
   test("adopts the injected run messages when the actor is trusted", async () => {
     const injected: Message[] = [
       { role: "user", content: [{ type: "text", text: "injected" }] },
@@ -134,7 +201,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const { memory, prepareMemoryMock } = makeFakeGraphMemory({
       messages: injected,
     });
-    const ctx = makeHookCtx({ graphMemory: memory, isTrustedActor: true });
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -156,7 +224,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       userQueryVector: userDense,
       userQuerySparseVector: userSparse,
     });
-    const userCtx = makeHookCtx({ graphMemory: withUserQuery.memory });
+    installConversation(withUserQuery.memory, { trusted: true });
+    const userCtx = makeHookCtx();
     await userPromptSubmitMemoryRetrieval(userCtx);
     // User-query pair wins — never crossed with the summary signal — and is
     // recorded back onto the graph handle for the PKB-reminder injector.
@@ -169,7 +238,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       queryVector: summaryDense,
       sparseVector: summarySparse,
     });
-    const summaryCtx = makeHookCtx({ graphMemory: summaryOnly.memory });
+    installConversation(summaryOnly.memory, { trusted: true });
+    const summaryCtx = makeHookCtx();
     await userPromptSubmitMemoryRetrieval(summaryCtx);
     expect(summaryOnly.recordPkbQueryVectorsMock).toHaveBeenCalledWith(
       summaryDense,
@@ -177,17 +247,59 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     );
   });
 
+  test("applies runtime injection on the retrieved history and persists the assembled blocks", async () => {
+    const retrieved: Message[] = [
+      { role: "user", content: [{ type: "text", text: "retrieved" }] },
+    ];
+    const injected: Message[] = [
+      { role: "user", content: [{ type: "text", text: "injected" }] },
+    ];
+    const { memory } = makeFakeGraphMemory({ messages: retrieved });
+    applyRuntimeInjectionsMock.mockImplementationOnce(async () => ({
+      messages: injected,
+      blocks: { unifiedTurnContext: "tc-block" },
+    }));
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx({ userMessageId: "msg-77" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    // Injection runs on the retrieved history; its result becomes the working
+    // list the loop reads back.
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+    expect(applyRuntimeInjectionsMock.mock.calls[0]?.[0]).toBe(retrieved);
+    expect(ctx.latestMessages).toBe(injected);
+    // The assembled blocks are persisted onto the user message metadata.
+    expect(updateMessageMetadataMock).toHaveBeenCalledWith("msg-77", {
+      turnContextBlock: "tc-block",
+    });
+  });
+
+  test("applies runtime injection for untrusted actors despite skipping retrieval", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    const seeded: Message[] = [
+      { role: "user", content: [{ type: "text", text: "seeded" }] },
+    ];
+    installConversation(memory, { trusted: false });
+    const ctx = makeHookCtx({ latestMessages: seeded });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    // The memory-graph step is gated on trust, but injection runs for everyone
+    // — on the seeded history, since no retrieval replaced it.
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+    expect(applyRuntimeInjectionsMock.mock.calls[0]?.[0]).toBe(seeded);
+  });
+
   test("skips graph retrieval and side effects for untrusted actors", async () => {
     const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
       makeFakeGraphMemory();
     const seeded: Message[] = [
       { role: "user", content: [{ type: "text", text: "seeded" }] },
     ];
-    const ctx = makeHookCtx({
-      graphMemory: memory,
-      isTrustedActor: false,
-      latestMessages: seeded,
-    });
+    installConversation(memory, { trusted: false });
+    const ctx = makeHookCtx({ latestMessages: seeded });
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -201,14 +313,12 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
   });
 
   test("persists injected block, recall log, and emits memory_recalled", async () => {
-    const received: ServerMessage[] = [];
     const { memory } = makeFakeGraphMemory({
       injectedBlockText: "injected-block",
       metrics: makeMetrics(),
     });
+    installConversation(memory, { trusted: true });
     const ctx = makeHookCtx({
-      graphMemory: memory,
-      onEvent: (msg) => received.push(msg),
       userMessageId: "msg-42",
       conversationId: "conv-42",
     });
@@ -225,13 +335,16 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     };
     expect(logEntry.conversationId).toBe("conv-42");
     expect(logEntry.reason).toBe("graph:none");
-    expect(received).toHaveLength(1);
-    expect(received[0]?.type).toBe("memory_recalled");
+    // The `memory_recalled` summary publishes through the shared broadcast hub.
+    expect(broadcastMessageMock).toHaveBeenCalledTimes(1);
+    const emitted = broadcastMessageMock.mock.calls[0]?.[0] as ServerMessage;
+    expect(emitted.type).toBe("memory_recalled");
   });
 
   test("skips metadata persist when no block text is injected", async () => {
     const { memory } = makeFakeGraphMemory({ injectedBlockText: null });
-    const ctx = makeHookCtx({ graphMemory: memory });
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -254,16 +367,17 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const graphMemory = {
       prepareMemory: failingPrepare,
     } as unknown as ConversationGraphMemory;
-    const ctx = makeHookCtx({ graphMemory, isTrustedActor: true });
+    installConversation(graphMemory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await expect(userPromptSubmitMemoryRetrieval(ctx)).rejects.toThrow(
       "retrieval failed",
     );
   });
 
-  test("forwards the context abort signal into prepareMemory", async () => {
-    // The hook hands its `ctx.signal` straight to `prepareMemory` so an
-    // external cancel aborts the underlying retrieval.
+  test("forwards the conversation abort signal into prepareMemory", async () => {
+    // The hook hands the live conversation's abort signal straight to
+    // `prepareMemory` so an external cancel aborts the underlying retrieval.
     let capturedSignal: AbortSignal | undefined;
     const prepareMemoryMock = mock(
       async (
@@ -288,7 +402,11 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       recordPkbQueryVectors: mock(() => {}),
     } as unknown as ConversationGraphMemory;
     const controller = new AbortController();
-    const ctx = makeHookCtx({ graphMemory, signal: controller.signal });
+    installConversation(graphMemory, {
+      trusted: true,
+      signal: controller.signal,
+    });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);