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

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -8,9 +8,9 @@
  *  4. Untargeted (no targetClientId, no header) → 200 accepted (regression)
  *
  * Resolution goes through conversation.hostCuProxy?.resolve(...). The
- * conversation store is mocked to return a controlled conversation object.
+ * conversation registry is mocked to return a controlled conversation object.
  *
- * Note: host-cu-routes.ts has a deep import chain (conversation-store →
+ * Note: host-cu-routes.ts has a deep import chain (conversation-registry →
  * conversation.ts → ces-client → service-contracts) that requires mocking
  * before the module loads. We use dynamic imports to ensure all mocks are
  * registered before the route module is evaluated.
@@ -75,7 +75,7 @@ const conversationStore = new Map<
   { hostCuProxy?: { processObservation: (...args: unknown[]) => void } }
 >();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (conversationId: string) =>
     conversationStore.get(conversationId),
 }));

package/src/__tests__/inference-profile-reaper.test.ts

@@ -7,6 +7,11 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
 import {
   createConversation,
   getConversation,
@@ -113,6 +118,63 @@ describe("inference-profile-session-reaper", () => {
     subscription.dispose();
   });
 
+  test("syncs the live in-memory Conversation instance for each cleared session", async () => {
+    // GIVEN an expired session-backed override persisted on a conversation row
+    const conv = createConversation("reaper-live-sync");
+    setConversationInferenceProfileSession(
+      conv.id,
+      "balanced",
+      "session-live",
+      Date.now() - 1,
+    );
+
+    // AND a live Conversation instance registered for that conversation,
+    // seeded with the same override state the reaper is about to expire
+    const appliedStates: Array<{
+      profile: string | null;
+      sessionId: string | null;
+      expiresAt: number | null;
+    }> = [];
+    const liveConversation = {
+      conversationId: conv.id,
+      inferenceProfile: "balanced",
+      inferenceProfileSessionId: "session-live",
+      inferenceProfileExpiresAt: Date.now() - 1,
+      applyInferenceProfileState(
+        this: {
+          inferenceProfile: string | null;
+          inferenceProfileSessionId: string | null;
+          inferenceProfileExpiresAt: number | null;
+        },
+        state: {
+          profile: string | null;
+          sessionId: string | null;
+          expiresAt: number | null;
+        },
+      ) {
+        appliedStates.push(state);
+        this.inferenceProfile = state.profile;
+        this.inferenceProfileSessionId = state.sessionId;
+        this.inferenceProfileExpiresAt = state.expiresAt;
+      },
+    } as unknown as Conversation;
+    setConversation(conv.id, liveConversation);
+
+    // WHEN the reaper sweeps the expired session
+    tickInferenceProfileReaper();
+
+    // THEN the live instance is cleared in lock-step with the DB row, so the
+    // per-turn override derivation reads the cleared state without re-fetching
+    expect(appliedStates).toEqual([
+      { profile: null, sessionId: null, expiresAt: null },
+    ]);
+    expect(liveConversation.inferenceProfile).toBeNull();
+    expect(liveConversation.inferenceProfileSessionId).toBeNull();
+    expect(liveConversation.inferenceProfileExpiresAt).toBeNull();
+
+    deleteConversation(conv.id);
+  });
+
   test("CAS protection: row with NULL expiresAt (sticky override) is not touched", async () => {
     const conv = createConversation("reaper-cas-conv");
 

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -53,6 +53,11 @@ mock.module("../config/loader.js", () => ({
 // Real DB — same pattern as conversation-crud-inference-profile.test.ts
 // ---------------------------------------------------------------------------
 
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
 import {
   createConversation,
   getConversation,
@@ -78,6 +83,37 @@ function resetDb() {
   db.run(`DELETE FROM conversations`);
 }
 
+/**
+ * Minimal live `Conversation` stub exposing just the inference-profile
+ * mirror fields and {@link Conversation.applyInferenceProfileState}, so the
+ * handler's live-instance sync can be observed without constructing a full
+ * conversation.
+ */
+function makeLiveConversationStub(conversationId: string): Conversation {
+  return {
+    conversationId,
+    inferenceProfile: null as string | null,
+    inferenceProfileSessionId: null as string | null,
+    inferenceProfileExpiresAt: null as number | null,
+    applyInferenceProfileState(
+      this: {
+        inferenceProfile: string | null;
+        inferenceProfileSessionId: string | null;
+        inferenceProfileExpiresAt: number | null;
+      },
+      state: {
+        profile: string | null;
+        sessionId: string | null;
+        expiresAt: number | null;
+      },
+    ) {
+      this.inferenceProfile = state.profile;
+      this.inferenceProfileSessionId = state.sessionId;
+      this.inferenceProfileExpiresAt = state.expiresAt;
+    },
+  } as unknown as Conversation;
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -175,6 +211,56 @@ describe("setInferenceProfileSession", () => {
     expect(second.replaced!.expiresAt).toBe(first.expiresAt);
   });
 
+  test("mirrors the session state onto the live in-memory Conversation on open", async () => {
+    // GIVEN a conversation with a live in-memory instance registered for it
+    const conv = createConversation("sess-handler-live-sync-open");
+    const liveConversation = makeLiveConversationStub(conv.id);
+    setConversation(conv.id, liveConversation);
+
+    // WHEN a session-backed override is opened
+    const opened = await setInferenceProfileSession({
+      conversationId: conv.id,
+      profile: "balanced",
+      ttlSeconds: 600,
+    });
+
+    // THEN the live instance mirrors the persisted session state, so the
+    // per-turn override derivation reads it without re-fetching the DB row
+    expect(liveConversation.inferenceProfile).toBe("balanced");
+    expect(liveConversation.inferenceProfileSessionId).toBe(opened.sessionId);
+    expect(liveConversation.inferenceProfileExpiresAt).toBe(opened.expiresAt);
+
+    deleteConversation(conv.id);
+  });
+
+  test("clears the live in-memory Conversation state on clear", async () => {
+    // GIVEN a conversation with a live in-memory instance registered for it
+    const conv = createConversation("sess-handler-live-sync-clear");
+    const liveConversation = makeLiveConversationStub(conv.id);
+    setConversation(conv.id, liveConversation);
+
+    // AND an active session-backed override mirrored onto that instance
+    await setInferenceProfileSession({
+      conversationId: conv.id,
+      profile: "balanced",
+      ttlSeconds: 600,
+    });
+    expect(liveConversation.inferenceProfile).toBe("balanced");
+
+    // WHEN the override is cleared
+    await setInferenceProfileSession({
+      conversationId: conv.id,
+      profile: null,
+    });
+
+    // THEN the live instance is cleared in lock-step with the DB row
+    expect(liveConversation.inferenceProfile).toBeNull();
+    expect(liveConversation.inferenceProfileSessionId).toBeNull();
+    expect(liveConversation.inferenceProfileExpiresAt).toBeNull();
+
+    deleteConversation(conv.id);
+  });
+
   test("open with profile=null — all three cleared; replaced set if prior existed", async () => {
     const conv = createConversation("sess-handler-clear");
 

package/src/__tests__/injector-background-turn.test.ts

@@ -23,7 +23,7 @@ mock.module("../config/loader.js", () => ({
 import {
   DEFAULT_INJECTOR_ORDER,
   defaultInjectors,
-} from "../plugins/defaults/injectors/register.js";
+} from "../plugins/defaults/memory-retrieval/injectors.js";
 import type { Injector, TurnContext } from "../plugins/types.js";
 
 function findInjector(name: string): Injector {
@@ -59,10 +59,8 @@ describe("background-turn injector", () => {
   test("returns null when isBackgroundConversation is false", async () => {
     const result = await backgroundInjector.produce(
       makeContext({
-        injectionInputs: {
-          isBackgroundConversation: false,
-          isNonInteractive: true,
-        },
+        isBackgroundConversation: false,
+        isNonInteractive: true,
       }),
     );
     expect(result).toBeNull();
@@ -70,7 +68,7 @@ describe("background-turn injector", () => {
 
   test("returns null when isBackgroundConversation is unset", async () => {
     const result = await backgroundInjector.produce(
-      makeContext({ injectionInputs: { isNonInteractive: true } }),
+      makeContext({ isNonInteractive: true }),
     );
     expect(result).toBeNull();
   });
@@ -78,10 +76,8 @@ describe("background-turn injector", () => {
   test("returns null when the guardian is actively connected (interactive turn)", async () => {
     const result = await backgroundInjector.produce(
       makeContext({
-        injectionInputs: {
-          isBackgroundConversation: true,
-          isNonInteractive: false,
-        },
+        isBackgroundConversation: true,
+        isNonInteractive: false,
       }),
     );
     expect(result).toBeNull();
@@ -89,7 +85,7 @@ describe("background-turn injector", () => {
 
   test("returns null when isNonInteractive is unset", async () => {
     const result = await backgroundInjector.produce(
-      makeContext({ injectionInputs: { isBackgroundConversation: true } }),
+      makeContext({ isBackgroundConversation: true }),
     );
     expect(result).toBeNull();
   });
@@ -97,10 +93,8 @@ describe("background-turn injector", () => {
   test("wraps configured text in <background_turn> tags when active and non-interactive", async () => {
     const block = await backgroundInjector.produce(
       makeContext({
-        injectionInputs: {
-          isBackgroundConversation: true,
-          isNonInteractive: true,
-        },
+        isBackgroundConversation: true,
+        isNonInteractive: true,
       }),
     );
 
@@ -119,10 +113,8 @@ describe("background-turn injector", () => {
 
     const result = await backgroundInjector.produce(
       makeContext({
-        injectionInputs: {
-          isBackgroundConversation: true,
-          isNonInteractive: true,
-        },
+        isBackgroundConversation: true,
+        isNonInteractive: true,
       }),
     );
     expect(result).toBeNull();
@@ -133,10 +125,8 @@ describe("background-turn injector", () => {
 
     const block = await backgroundInjector.produce(
       makeContext({
-        injectionInputs: {
-          isBackgroundConversation: true,
-          isNonInteractive: true,
-        },
+        isBackgroundConversation: true,
+        isNonInteractive: true,
       }),
     );