@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/platform/client.test.ts

@@ -11,13 +11,17 @@ let mockManagedProxyCtx = {
 };
 let mockAssistantId = "";
 let mockSecureKeys: Record<string, string | null | undefined> = {};
+// Re-pointable so the probe-deadline tests can hang context resolution.
+let mockResolveManagedProxyContext: () => Promise<
+  typeof mockManagedProxyCtx
+> = async () => mockManagedProxyCtx;
 
 // ---------------------------------------------------------------------------
 // Module mocks
 // ---------------------------------------------------------------------------
 
 mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => mockManagedProxyCtx,
+  resolveManagedProxyContext: () => mockResolveManagedProxyContext(),
 }));
 
 mock.module("../config/env.js", () => ({
@@ -38,7 +42,11 @@ mock.module("../security/credential-key.js", () => ({
 // Import under test (after mocks)
 // ---------------------------------------------------------------------------
 
-import { VellumPlatformClient } from "./client.js";
+import {
+  _resetConfiguredProbeCacheForTests,
+  isPlatformClientConfigured,
+  VellumPlatformClient,
+} from "./client.js";
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -56,6 +64,8 @@ describe("VellumPlatformClient", () => {
     };
     mockAssistantId = "asst-123";
     mockSecureKeys = {};
+    mockResolveManagedProxyContext = async () => mockManagedProxyCtx;
+    _resetConfiguredProbeCacheForTests();
   });
 
   afterEach(() => {
@@ -119,6 +129,166 @@ describe("VellumPlatformClient", () => {
     });
   });
 
+  describe("isPlatformClientConfigured()", () => {
+    test("true when base url, api key, and assistant id are all present", async () => {
+      expect(await isPlatformClientConfigured()).toBe(true);
+    });
+
+    test("false when the platform assistant id is missing", async () => {
+      mockAssistantId = "";
+
+      expect(await isPlatformClientConfigured()).toBe(false);
+    });
+
+    test("false when auth prerequisites are missing", async () => {
+      mockManagedProxyCtx = {
+        enabled: false,
+        platformBaseUrl: "",
+        assistantApiKey: "",
+      };
+
+      expect(await isPlatformClientConfigured()).toBe(false);
+    });
+
+    test("hung resolution answers false at the deadline, then serves the late result from cache", async () => {
+      let releaseHang = () => {};
+      const hang = new Promise<void>((resolve) => {
+        releaseHang = resolve;
+      });
+      mockResolveManagedProxyContext = async () => {
+        await hang;
+        return mockManagedProxyCtx;
+      };
+
+      // Resolution is hung and no result has ever settled -- the deadline
+      // must answer false instead of stalling the caller.
+      expect(await isPlatformClientConfigured()).toBe(false);
+
+      // Release the abandoned resolution; it settles true in the background
+      // and refreshes the cache.
+      releaseHang();
+      await Bun.sleep(10);
+
+      // Resolution hangs forever this time, but the cache answers true.
+      mockResolveManagedProxyContext = () => new Promise(() => {});
+      expect(await isPlatformClientConfigured()).toBe(true);
+    });
+
+    test("concurrent calls share a single in-flight resolution", async () => {
+      let resolutionCount = 0;
+      mockResolveManagedProxyContext = async () => {
+        resolutionCount += 1;
+        await Bun.sleep(5);
+        return mockManagedProxyCtx;
+      };
+
+      const [first, second] = await Promise.all([
+        isPlatformClientConfigured(),
+        isPlatformClientConfigured(),
+      ]);
+
+      expect(first).toBe(true);
+      expect(second).toBe(true);
+      expect(resolutionCount).toBe(1);
+    });
+
+    test("a settled flight clears, so the next call starts a fresh resolution", async () => {
+      let resolutionCount = 0;
+      mockResolveManagedProxyContext = async () => {
+        resolutionCount += 1;
+        return mockManagedProxyCtx;
+      };
+
+      expect(await isPlatformClientConfigured()).toBe(true);
+      expect(await isPlatformClientConfigured()).toBe(true);
+      expect(resolutionCount).toBe(2);
+    });
+
+    test("a caller that finds an abandoned flight rotates in a fresh resolution", async () => {
+      let resolutionCount = 0;
+      // The first resolution hangs forever; only the rotated-in second one
+      // settles.
+      const pendingHangs = [new Promise<void>(() => {})];
+      mockResolveManagedProxyContext = async () => {
+        resolutionCount += 1;
+        const hang = pendingHangs.shift();
+        if (hang) {
+          await hang;
+        }
+        return mockManagedProxyCtx;
+      };
+
+      // The first caller abandons the hung flight at the deadline.
+      expect(await isPlatformClientConfigured()).toBe(false);
+
+      // The hung flight is marked abandoned, so the next caller rotates in a
+      // fresh resolution instead of joining it; the fresh flight settles
+      // immediately and answers live.
+      expect(await isPlatformClientConfigured()).toBe(true);
+      expect(resolutionCount).toBe(2);
+    });
+
+    test("a later caller joins a flight nobody has abandoned", async () => {
+      let resolutionCount = 0;
+      let release = () => {};
+      // Gating the resolution keeps it in flight until the second caller has
+      // joined, so the assertion does not race a settle.
+      const gate = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      mockResolveManagedProxyContext = async () => {
+        resolutionCount += 1;
+        await gate;
+        return mockManagedProxyCtx;
+      };
+
+      const first = isPlatformClientConfigured();
+      await Bun.sleep(1);
+      const second = isPlatformClientConfigured();
+      release();
+
+      expect(await first).toBe(true);
+      expect(await second).toBe(true);
+      expect(resolutionCount).toBe(1);
+    });
+
+    test("a rotated-out flight's late settle cannot overwrite the newer flight's cached result", async () => {
+      let releaseFirstHang = () => {};
+      const firstHang = new Promise<void>((resolve) => {
+        releaseFirstHang = resolve;
+      });
+      const pendingHangs = [firstHang];
+      mockResolveManagedProxyContext = async () => {
+        const hang = pendingHangs.shift();
+        if (hang) {
+          await hang;
+        }
+        return mockManagedProxyCtx;
+      };
+
+      // First caller abandons the hung flight; second caller rotates in a
+      // fresh flight that settles true and writes the cache.
+      expect(await isPlatformClientConfigured()).toBe(false);
+      expect(await isPlatformClientConfigured()).toBe(true);
+
+      // The rotated-out flight now settles resolving an unconfigured
+      // context. Generation fencing must keep it from clobbering the newer
+      // flight's cached `true`.
+      mockManagedProxyCtx = {
+        enabled: false,
+        platformBaseUrl: "",
+        assistantApiKey: "",
+      };
+      releaseFirstHang();
+      await Bun.sleep(10);
+
+      // Resolution hangs forever, so this answer can only come from the
+      // cache, which must still hold the newer flight's `true`.
+      mockResolveManagedProxyContext = () => new Promise(() => {});
+      expect(await isPlatformClientConfigured()).toBe(true);
+    });
+  });
+
   describe("fetch()", () => {
     test("prepends base URL to path", async () => {
       globalThis.fetch = mock(async (url: string | URL | Request) => {

package/src/platform/client.ts

@@ -34,6 +34,174 @@ export interface OwnerConsent {
   shareDiagnosticsAcceptedVersion: string;
 }
 
+interface PlatformClientConfig {
+  baseUrl: string;
+  apiKey: string;
+  assistantId: string;
+}
+
+/**
+ * Resolve the platform client's prerequisites.
+ *
+ * First tries the in-memory managed proxy context (available when the daemon
+ * has rehydrated env overrides). Falls back to reading platform credentials
+ * directly from the credential store so that standalone CLI invocations work
+ * without the daemon having run its rehydration step.
+ *
+ * Returns `null` when auth prerequisites are missing (not logged in, no API
+ * key). The assistant ID is resolved but not required.
+ */
+async function resolvePlatformClientConfig(): Promise<PlatformClientConfig | null> {
+  if (!arePlatformFeaturesEnabled()) {
+    log.debug("platform features disabled -- returning null");
+    return null;
+  }
+
+  const ctx = await resolveManagedProxyContext();
+
+  let baseUrl = ctx.enabled ? ctx.platformBaseUrl : "";
+  let apiKey = ctx.enabled ? ctx.assistantApiKey : "";
+  let assistantId = getPlatformAssistantId();
+
+  // Fall back to credential store for values not yet rehydrated (standalone CLI).
+  if (!baseUrl) {
+    baseUrl =
+      (await getSecureKeyAsync(credentialKey("vellum", "platform_base_url"))) ??
+      "";
+  }
+  if (!apiKey) {
+    apiKey =
+      (await getSecureKeyAsync(credentialKey("vellum", "assistant_api_key"))) ??
+      "";
+  }
+  if (!assistantId) {
+    assistantId =
+      (
+        await getSecureKeyAsync(
+          credentialKey("vellum", "platform_assistant_id"),
+        )
+      )?.trim() ?? "";
+  }
+
+  if (!baseUrl || !apiKey) {
+    const level = _missingPrereqsWarned ? "debug" : "warn";
+    _missingPrereqsWarned = true;
+    log[level](
+      {
+        hasBaseUrl: !!baseUrl,
+        hasApiKey: !!apiKey,
+        hasAssistantId: !!assistantId,
+        managedProxyEnabled: ctx.enabled,
+      },
+      "Platform client prerequisites missing -- returning null",
+    );
+    return null;
+  }
+
+  return { baseUrl, apiKey, assistantId };
+}
+
+// Bounds the configured probe: resolution can hit up to three credential-store
+// reads, and urgent-notification dispatch awaits this probe, so a slow
+// credential backend must answer from cache instead of stalling the banner.
+const CONFIGURED_PROBE_DEADLINE_MS = 500;
+
+let lastKnownConfigured: boolean | null = null;
+// Single-flight slot with rotation: concurrent probes share one resolution,
+// while a flight some caller already gave up on is replaced so a hung
+// credential backend cannot pin the slot (and the cache) stale until a 45s
+// credential timeout finally settles it. Generation fencing keeps an
+// out-of-order settle from a rotated-out flight from overwriting the result a
+// newer flight already wrote.
+interface ConfiguredProbeFlight {
+  promise: Promise<boolean>;
+  generation: number;
+  // Set once a caller's deadline elapsed on this flight. Rotation keys off
+  // this observed give-up rather than a wall-clock age, so the decision never
+  // lands on the deadline boundary, where drift between the timer's clock and
+  // Date.now() would decide whether a caller rejoins the flight it just
+  // abandoned.
+  abandoned: boolean;
+}
+let inFlightConfiguredProbe: ConfiguredProbeFlight | null = null;
+let probeGeneration = 0;
+let lastWrittenGeneration = 0;
+
+export function _resetConfiguredProbeCacheForTests(): void {
+  lastKnownConfigured = null;
+  inFlightConfiguredProbe = null;
+  // Outstanding flights all carry generations at or below the current
+  // counter; raising the written floor to it blocks their settles from
+  // resurrecting the cache after a reset.
+  lastWrittenGeneration = probeGeneration;
+}
+
+function startOrJoinConfiguredProbe(): ConfiguredProbeFlight {
+  const existing = inFlightConfiguredProbe;
+  if (existing !== null && !existing.abandoned) {
+    return existing;
+  }
+  probeGeneration += 1;
+  const generation = probeGeneration;
+  const promise = resolvePlatformClientConfig()
+    .then((config) => config !== null && config.assistantId.length > 0)
+    .catch((err: unknown) => {
+      log.debug(
+        { err },
+        "Configured probe failed -- treating as not configured",
+      );
+      return false;
+    })
+    .then((value) => {
+      if (generation > lastWrittenGeneration) {
+        lastKnownConfigured = value;
+        lastWrittenGeneration = generation;
+      }
+      if (inFlightConfiguredProbe?.generation === generation) {
+        inFlightConfiguredProbe = null;
+      }
+      return value;
+    });
+  const flight: ConfiguredProbeFlight = {
+    promise,
+    generation,
+    abandoned: false,
+  };
+  inFlightConfiguredProbe = flight;
+  return flight;
+}
+
+/**
+ * Whether the platform client can actually dispatch: auth prerequisites plus
+ * a nonempty platform assistant id (`PlatformPushAdapter.send()` fails fast
+ * without one). Constructs no client and makes no network requests.
+ *
+ * Bounded by {@link CONFIGURED_PROBE_DEADLINE_MS}: when config resolution is
+ * slower than the deadline, returns the last settled result (or `false` when
+ * none exists yet) and marks the flight abandoned. Concurrent calls share one
+ * in-flight resolution; the next call after an abandonment starts a fresh one,
+ * so a hung backend never pins the cache stale, and generation fencing keeps a
+ * rotated-out flight's late settle from overwriting a newer result.
+ */
+export async function isPlatformClientConfigured(): Promise<boolean> {
+  const flight = startOrJoinConfiguredProbe();
+
+  let deadlineTimer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<"deadline">((resolve) => {
+    deadlineTimer = setTimeout(
+      () => resolve("deadline"),
+      CONFIGURED_PROBE_DEADLINE_MS,
+    );
+  });
+  const raced = await Promise.race([flight.promise, deadline]);
+  clearTimeout(deadlineTimer);
+  if (raced === "deadline") {
+    flight.abandoned = true;
+    return lastKnownConfigured ?? false;
+  }
+  return raced;
+}
+
 export class VellumPlatformClient {
   private readonly platformBaseUrl: string;
   private readonly apiKey: string;
@@ -50,67 +218,22 @@ export class VellumPlatformClient {
   }
 
   /**
-   * Create a platform client by resolving managed proxy context.
-   *
-   * First tries the in-memory managed proxy context (available when the daemon
-   * has rehydrated env overrides). Falls back to reading platform credentials
-   * directly from the credential store so that standalone CLI invocations work
-   * without the daemon having run its rehydration step.
+   * Create a platform client from {@link resolvePlatformClientConfig}.
    *
    * Returns `null` when auth prerequisites are missing (not logged in, no API
-   * key). The assistant ID is resolved but not required — callers that need it
-   * should check `platformAssistantId` themselves.
+   * key). The assistant ID is resolved but not required -- callers that need
+   * it should check `platformAssistantId` themselves.
    */
   static async create(): Promise<VellumPlatformClient | null> {
-    if (!arePlatformFeaturesEnabled()) {
-      log.debug("platform features disabled — returning null");
-      return null;
-    }
-
-    const ctx = await resolveManagedProxyContext();
-
-    let baseUrl = ctx.enabled ? ctx.platformBaseUrl : "";
-    let apiKey = ctx.enabled ? ctx.assistantApiKey : "";
-    let assistantId = getPlatformAssistantId();
-
-    // Fall back to credential store for values not yet rehydrated (standalone CLI).
-    if (!baseUrl) {
-      baseUrl =
-        (await getSecureKeyAsync(
-          credentialKey("vellum", "platform_base_url"),
-        )) ?? "";
-    }
-    if (!apiKey) {
-      apiKey =
-        (await getSecureKeyAsync(
-          credentialKey("vellum", "assistant_api_key"),
-        )) ?? "";
-    }
-    if (!assistantId) {
-      assistantId =
-        (
-          await getSecureKeyAsync(
-            credentialKey("vellum", "platform_assistant_id"),
-          )
-        )?.trim() ?? "";
-    }
-
-    if (!baseUrl || !apiKey) {
-      const level = _missingPrereqsWarned ? "debug" : "warn";
-      _missingPrereqsWarned = true;
-      log[level](
-        {
-          hasBaseUrl: !!baseUrl,
-          hasApiKey: !!apiKey,
-          hasAssistantId: !!assistantId,
-          managedProxyEnabled: ctx.enabled,
-        },
-        "Platform client prerequisites missing — returning null",
-      );
+    const config = await resolvePlatformClientConfig();
+    if (!config) {
       return null;
     }
-
-    return new VellumPlatformClient(baseUrl, apiKey, assistantId);
+    return new VellumPlatformClient(
+      config.baseUrl,
+      config.apiKey,
+      config.assistantId,
+    );
   }
 
   /**

package/src/plugin-api/conversation-turn.ts

@@ -67,6 +67,17 @@ export interface RunConversationTurnResult {
   queued?: boolean;
 }
 
+/**
+ * Metadata stamped on the row that opens a plugin-driven turn. A plugin drives
+ * the turn on its own schedule, so the row is machine-initiated even when it
+ * lands in an ordinary standard conversation the user also types into: the
+ * `automated` marker is what keeps the reply out of the `chat.assistant_reply`
+ * push (see `isReplyPushIneligibleUserMessage`) and out of the memory
+ * extraction pass, alongside every other machine-authored prompt. It is not an
+ * echo-suppression marker, so the row still renders in the transcript.
+ */
+const PLUGIN_TURN_MESSAGE_METADATA = { automated: true } as const;
+
 // ---------------------------------------------------------------------------
 // Content conversion
 // ---------------------------------------------------------------------------
@@ -210,6 +221,7 @@ export async function runConversationTurn(
       onEvent,
       requestId,
       isInteractive: false,
+      metadata: { ...PLUGIN_TURN_MESSAGE_METADATA },
     });
     if (enqueueResult.rejected) {
       throw new Error(
@@ -229,6 +241,7 @@ export async function runConversationTurn(
     attachments,
     onEvent,
     isInteractive: false,
+    metadata: { ...PLUGIN_TURN_MESSAGE_METADATA },
     ...(options.callSite ? { callSite: options.callSite } : {}),
   });
 

package/src/plugin-api/model-profiles.test.ts

@@ -67,6 +67,7 @@ describe("getModelProfiles", () => {
       "balanced",
       "quality-optimized",
       "cost-optimized",
+      "latency-optimized",
     ]);
   });
 
@@ -85,6 +86,7 @@ describe("getModelProfiles", () => {
       "balanced",
       "cost-optimized",
       "disabled",
+      "latency-optimized",
       "quality-optimized",
     ]);
     const disabled = result.find((p) => p.key === "disabled");
@@ -122,6 +124,7 @@ describe("getModelProfiles", () => {
       "mix",
       "balanced",
       "cost-optimized",
+      "latency-optimized",
       "quality-optimized",
     ]);
   });
@@ -131,6 +134,7 @@ describe("getModelProfiles", () => {
     expect(result.map((p) => p.key).sort()).toEqual([
       "balanced",
       "cost-optimized",
+      "latency-optimized",
       "quality-optimized",
     ]);
     for (const profile of result) {
@@ -150,7 +154,7 @@ describe("getModelProfiles", () => {
       "Best results with the most capable model",
     );
     expect(result.find((p) => p.key === "cost-optimized")?.description).toBe(
-      "Fastest responses at lower cost",
+      "Cheapest responses, for high-volume work",
     );
   });
 
@@ -162,7 +166,7 @@ describe("getModelProfiles", () => {
     // Tier descriptions are intent-only (no model names - LUM-2881), so the
     // managed and BYOK columns read the same for this tier.
     expect(result.find((p) => p.key === "cost-optimized")?.description).toBe(
-      "Fastest responses at lower cost",
+      "Cheapest responses, for high-volume work",
     );
   });
 

package/src/plugins/defaults/memory/__tests__/bookmark-crud.test.ts

@@ -261,4 +261,38 @@ describe("bookmark-crud", () => {
       /Message ghost not found/,
     );
   });
+
+  test("listBookmarks drives the join from message_bookmarks even with planner stats that predate the table", () => {
+    const sqlite = new Database(":memory:");
+    sqlite.exec("PRAGMA foreign_keys = ON");
+    const captured: string[] = [];
+    const db = drizzle(sqlite, {
+      schema,
+      logger: { logQuery: (query: string) => captured.push(query) },
+    });
+    const raw = getSqliteFrom(db);
+    bootstrapMessageTables(raw);
+    migrateMessageBookmarks(db);
+    for (let i = 0; i < 30; i++) {
+      seedConversationAndMessage(raw, {
+        conversationId: `conv-${i}`,
+        messageId: `msg-${i}`,
+      });
+    }
+    // ANALYZE writes no sqlite_stat1 rows for an empty table, leaving
+    // message_bookmarks without statistics while messages gets them. This is
+    // the production state that made the planner scan messages.
+    raw.exec("ANALYZE");
+
+    listBookmarks(db);
+    const sql = captured.at(-1);
+    expect(sql).toBeDefined();
+    const plan = raw.query(`EXPLAIN QUERY PLAN ${sql}`).all() as Array<{
+      detail: string;
+    }>;
+    expect(plan[0]?.detail ?? "").toMatch(/^SCAN message_bookmarks/);
+    expect(plan.some((row) => row.detail.includes("SCAN messages"))).toBe(
+      false,
+    );
+  });
 });

package/src/plugins/defaults/memory/__tests__/conversation-queries.test.ts

@@ -169,6 +169,18 @@ describe("buildExcerpt", () => {
     expect(excerpt.startsWith("…")).toBe(true);
   });
 
+  test("keeps the match near the front of the display excerpt", () => {
+    const prefix = "p".repeat(200);
+    const excerpt = buildExcerpt(
+      JSON.stringify([{ type: "text", text: `${prefix} alpha trailing text` }]),
+      "alpha",
+    );
+
+    const alphaIndex = excerpt.indexOf("alpha");
+    expect(alphaIndex).toBeGreaterThan(0);
+    expect(alphaIndex).toBeLessThanOrEqual(32);
+  });
+
   test("whole-query matches also respect tokenizer boundaries", () => {
     const filler = "party planning notes ".repeat(10);
     const excerpt = buildExcerpt(
@@ -337,6 +349,16 @@ describe("buildRecallEvidenceExcerpt", () => {
     );
   });
 
+  test("keeps the wide leading window for recall evidence", () => {
+    const prefix = "p".repeat(200);
+    const excerpt = buildRecallEvidenceExcerpt(
+      JSON.stringify([{ type: "text", text: `${prefix} alpha trailing text` }]),
+      "alpha",
+    );
+
+    expect(excerpt.indexOf("alpha")).toBeGreaterThan(50);
+  });
+
   test("keeps the raw fallback for messages with no legible text", () => {
     const raw = JSON.stringify([
       { type: "tool_use", id: "toolu_01", name: "bash", input: {} },

package/src/plugins/defaults/memory/__tests__/jobs-store-enqueue-gate.test.ts

@@ -38,6 +38,15 @@ mock.module("../../../../persistence/conversation-crud.js", () => ({
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
+// Stub the user-activity gate probe open. Its real logic is covered by
+// memory-retrospective-accounting.test.ts and
+// memory-retrospective-enqueue.test.ts; against this file's empty stub db it
+// would report no activity and close the gate, masking the memory.enabled
+// gate under test.
+mock.module("../memory-retrospective-accounting.js", () => ({
+  hasQualifyingUserMessageAfter: () => true,
+}));
+
 // Stub the qdrant breaker so `enqueueMemoryJob` doesn't trip on it.
 mock.module(
   "../../../../persistence/embeddings/qdrant-circuit-breaker.js",
@@ -94,6 +103,8 @@ const stubDb = makeStubDb();
 mock.module("../../../../persistence/db-connection.js", () => ({
   getDb: () => stubDb,
   getMemoryDb: () => stubDb,
+  // Truthy handle: consulted only as memory-db's availability gate.
+  getMemorySqlite: () => ({}),
 }));
 
 // Now load the real modules under test.