@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/credential-execution/executable-discovery.ts

@@ -17,6 +17,7 @@
  */
 
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
@@ -160,6 +161,21 @@ export function discoverLocalCes():
     return { mode: "local-source", sourcePath: sourceEntry };
   }
 
+  // npm-layout fallback: resolve via node_modules when installed as a package
+  try {
+    const _require = createRequire(import.meta.url);
+    const pkgPath = _require.resolve(
+      "@vellumai/credential-executor/package.json",
+    );
+    const npmSourceEntry = join(dirname(pkgPath), "src", "main.ts");
+    if (existsSync(npmSourceEntry)) {
+      log.info({ path: npmSourceEntry }, "Found CES source via npm package");
+      return { mode: "local-source", sourcePath: npmSourceEntry };
+    }
+  } catch {
+    // Package not installed — fall through to unavailable
+  }
+
   const reason = `CES executable not found. Searched: ${searchPaths.join(", ")}; also checked source at ${sourceEntry}`;
   log.warn(reason);
   return { mode: "unavailable", reason };
@@ -212,3 +228,43 @@ export function discoverCes(): DiscoveryResult {
   }
   return discoverLocalCes();
 }
+
+/** How long to poll for the managed bootstrap socket before giving up. */
+const MANAGED_DISCOVERY_TIMEOUT_MS = 3_000;
+
+/** Delay between managed bootstrap-socket discovery attempts. */
+const MANAGED_DISCOVERY_INTERVAL_MS = 100;
+
+/**
+ * Discover CES, polling for the managed bootstrap socket with a short
+ * backoff before failing.
+ *
+ * The managed CES sidecar re-binds its bootstrap socket after each assistant
+ * session ends — it outlives any single assistant and accepts the next
+ * connection (see `credential-executor/src/managed-main.ts`). A reconnecting
+ * assistant (e.g. after a container restart) can therefore probe during the
+ * brief window before the socket is re-bound. A single existence check would
+ * race that window and incorrectly report the sidecar as unavailable; polling
+ * absorbs the gap.
+ *
+ * Local discovery is returned immediately — a missing binary will not appear
+ * by waiting, so there is nothing to poll for.
+ */
+export async function discoverCesWithRetry({
+  timeoutMs = MANAGED_DISCOVERY_TIMEOUT_MS,
+  intervalMs = MANAGED_DISCOVERY_INTERVAL_MS,
+}: { timeoutMs?: number; intervalMs?: number } = {}): Promise<DiscoveryResult> {
+  // Only the managed bootstrap socket is worth polling for; a missing local
+  // binary will not appear by waiting.
+  if (!getIsContainerized()) {
+    return discoverCes();
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  let result = discoverCes();
+  while (result.mode === "unavailable" && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    result = discoverCes();
+  }
+  return result;
+}

package/src/credential-execution/process-manager.ts

@@ -29,7 +29,7 @@ import { ensureBun } from "../util/bun-runtime.js";
 import { getLogger } from "../util/logger.js";
 import type { CesTransport } from "./client.js";
 import {
-  discoverCes,
+  discoverCesWithRetry,
   discoverLocalCes,
   type DiscoveryResult,
   type LocalDiscoverySuccess,
@@ -118,7 +118,11 @@ export function createCesProcessManager(
         throw new Error("CES process manager is already running");
       }
 
-      discoveryResult = await discoverCes();
+      // Poll for the managed bootstrap socket with a short backoff. The CES
+      // sidecar re-binds its socket after each assistant session ends, so a
+      // reconnecting assistant can briefly race the re-bind; a single probe
+      // would otherwise fall back to local discovery and fail in managed mode.
+      discoveryResult = await discoverCesWithRetry();
       if (discoveryResult.mode === "unavailable") {
         // The managed sidecar bootstrap socket is not present — this happens
         // when the instance pre-dates the socket volume mount (e.g. existing

package/src/credential-health/credential-health-service.ts

@@ -7,8 +7,10 @@
  * - Scope coverage (grantedScopes vs provider defaultScopes)
  * - Liveness ping (for providers with a pingUrl)
  *
- * Designed to run during the heartbeat cycle. All checks are diagnostic —
- * no token refresh or recovery is attempted.
+ * Designed to run during the heartbeat cycle. The BYO liveness ping is
+ * routed through `withValidToken`, so a stale-but-refreshable access token
+ * is refreshed transparently before the ping fires — this prevents the
+ * heartbeat from misreporting a refreshable connection as `"revoked"`.
  */
 
 import { isTokenExpired } from "@vellumai/credential-storage";
@@ -22,6 +24,10 @@ import {
   type OAuthConnectionRow,
   type OAuthProviderRow,
 } from "../oauth/oauth-store.js";
+import {
+  TokenExpiredError,
+  withValidToken,
+} from "../security/token-manager.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("credential-health");
@@ -125,6 +131,45 @@ async function pingProvider(
   }
 }
 
+/**
+ * Map a pingProvider result onto a CredentialHealthResult, or null when the
+ * ping succeeded. `authErrorContext` distinguishes whether a 401/403 came
+ * after a refresh attempt (refreshable connection) or directly from the
+ * stored token (manual-token / no-refresh connection) — the latter is the
+ * historical message wording.
+ */
+type PingFailureContext = "after_refresh" | "no_refresh";
+
+function pingResultToHealthFailure(
+  base: Omit<CredentialHealthResult, "status" | "details" | "canAutoRecover">,
+  provider: string,
+  connectionId: string,
+  pingResult: { ok: boolean; authError: boolean },
+  authErrorContext: PingFailureContext,
+): CredentialHealthResult | null {
+  if (pingResult.ok) return null;
+  if (pingResult.authError) {
+    const suffix =
+      authErrorContext === "after_refresh" ? " after a refresh attempt" : "";
+    return {
+      ...base,
+      status: "revoked",
+      details: `${provider} token was rejected (401/403)${suffix}. The token may have been revoked. Re-authorization required.`,
+      canAutoRecover: false,
+    };
+  }
+  log.debug(
+    { provider, connectionId },
+    "Credential ping failed with non-auth error",
+  );
+  return {
+    ...base,
+    status: "ping_failed",
+    details: `${provider} liveness check failed (non-auth error). This may be transient.`,
+    canAutoRecover: false,
+  };
+}
+
 // ── Core check ────────────────────────────────────────────────────────
 
 interface CheckConnectionOpts {
@@ -192,14 +237,18 @@ async function checkConnection(
   const token = tokenResult.value;
 
   // 2. Check token expiry
-  if (isTokenExpired(expiresAt)) {
+  //
+  // When the token is expired AND there is no refresh token, we have no path
+  // to recovery — short-circuit to "expired". When there IS a refresh token,
+  // we fall through so the ping (via withValidToken) can attempt a refresh
+  // and confirm whether the refresh token still works. Without that, we'd
+  // return "expiring" speculatively even when the refresh token was revoked.
+  if (isTokenExpired(expiresAt) && !hasRefreshToken) {
     return {
       ...base,
-      status: hasRefreshToken ? "expiring" : "expired",
-      details: hasRefreshToken
-        ? `Token for ${provider} is expired but has a refresh token — auto-recovery may work.`
-        : `Token for ${provider} is expired with no refresh token. Re-authorization required.`,
-      canAutoRecover: hasRefreshToken,
+      status: "expired",
+      details: `Token for ${provider} is expired with no refresh token. Re-authorization required.`,
+      canAutoRecover: false,
     };
   }
 
@@ -234,36 +283,51 @@ async function checkConnection(
   }
 
   // 4. Liveness ping
+  //
+  // For refreshable connections we route through withValidToken so an
+  // expired-but-refreshable token gets refreshed before the ping fires.
+  // Without this wrapping, the ping would hit 401 on a stale token and the
+  // connection would be misreported as "revoked" — even though the next real
+  // API call (which goes through BYOOAuthConnection.request → withValidToken)
+  // would have refreshed and succeeded.
   if (pingUrl) {
-    const pingResult = await pingProvider(
-      token,
-      pingUrl,
-      pingMethod,
-      pingHeaders,
-      pingBody,
-    );
-    if (!pingResult.ok) {
-      if (pingResult.authError) {
-        return {
-          ...base,
-          status: "revoked",
-          details: `${provider} token was rejected (401/403). The token may have been revoked. Re-authorization required.`,
-          canAutoRecover: false,
-        };
+    const runPing = (t: string) =>
+      pingProvider(t, pingUrl, pingMethod, pingHeaders, pingBody);
+
+    let pingResult: { ok: boolean; authError: boolean };
+    let authContext: PingFailureContext;
+
+    if (hasRefreshToken) {
+      try {
+        pingResult = await withValidToken(provider, runPing, { connectionId });
+      } catch (err) {
+        if (err instanceof TokenExpiredError) {
+          // Refresh itself failed (revoked refresh token, invalid_grant, etc.)
+          return {
+            ...base,
+            status: "revoked",
+            details: `${provider} token refresh failed. The refresh token may have been revoked. Re-authorization required.`,
+            canAutoRecover: false,
+          };
+        }
+        throw err;
       }
-      // Non-auth ping failure — log but don't mark as critical.
-      // Could be a transient API issue.
-      log.debug(
-        { provider, connectionId },
-        "Credential ping failed with non-auth error",
-      );
-      return {
-        ...base,
-        status: "ping_failed",
-        details: `${provider} liveness check failed (non-auth error). This may be transient.`,
-        canAutoRecover: false,
-      };
+      authContext = "after_refresh";
+    } else {
+      // Manual-token provider or an OAuth provider whose initial flow
+      // didn't return a refresh_token — nothing to refresh, ping directly.
+      pingResult = await runPing(token);
+      authContext = "no_refresh";
     }
+
+    const failure = pingResultToHealthFailure(
+      base,
+      provider,
+      connectionId,
+      pingResult,
+      authContext,
+    );
+    if (failure) return failure;
   }
 
   return {
@@ -434,10 +498,28 @@ async function checkManagedProvider(
             canAutoRecover: true,
           });
         } else if (pingResp.status === 401 || pingResp.status === 403) {
+          // 401/403 from the upstream provider after the platform proxy
+          // forwarded the request. From the daemon side we can't tell
+          // whether the proxy attempted (and failed) a refresh-before-
+          // forward or skipped refresh entirely and forwarded a stale token.
+          // Either way it's not definitively unrecoverable — the next ping
+          // cycle may succeed if the platform re-refreshes. Demote to
+          // ping_failed so we don't fire a user-facing reconnect alert on
+          // what may be a transient platform-side miss. Only platform-
+          // attested 424 (CredentialRequiredError below) signals genuine
+          // unrecoverable failure.
+          log.debug(
+            {
+              provider: providerRow.provider,
+              connectionId: conn.id,
+              status: pingResp.status,
+            },
+            "Managed credential ping returned 401/403 — treating as potentially transient",
+          );
           results.push({
             ...base,
-            status: "revoked",
-            details: `${providerRow.provider} managed token was rejected (${pingResp.status}). Reconnect on the Vellum platform.`,
+            status: "ping_failed",
+            details: `${providerRow.provider} managed liveness check returned ${pingResp.status} from the upstream provider. The Vellum platform may not have refreshed the token before forwarding; will retry next cycle.`,
             canAutoRecover: false,
           });
         } else {
@@ -450,8 +532,11 @@ async function checkManagedProvider(
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        // CredentialRequiredError means the platform can't materialize
-        // the token — treat as revoked.
+        // CredentialRequiredError corresponds to a 424 from the platform
+        // proxy — the platform attempted (and gave up on) refresh and is
+        // telling us the credential is genuinely unrecoverable. This is
+        // the only managed-path signal we trust enough to fire a user-
+        // facing reconnect alert.
         if (
           err &&
           typeof err === "object" &&
@@ -461,7 +546,7 @@ async function checkManagedProvider(
           results.push({
             ...base,
             status: "revoked",
-            details: `${providerRow.provider} managed connection is no longer valid. Reconnect on the Vellum platform.`,
+            details: `${providerRow.provider} managed connection cannot be refreshed by the Vellum platform. Reconnect on the Vellum platform.`,
             canAutoRecover: false,
           });
         } else {

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -26,12 +26,9 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+import { createMockLoggerModule } from "../../__tests__/helpers/mock-logger.js";
+
+mock.module("../../util/logger.js", () => createMockLoggerModule());
 
 // ---------------------------------------------------------------------------
 // Mock state — reset between tests.
@@ -168,6 +165,12 @@ function makeDisposeContext(
   const ctx = {
     conversationId: overrides.conversationId ?? "conv-1",
     processing: false,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController,
     prompter,
     secretPrompter,

package/src/daemon/__tests__/conversation-surfaces-launch.test.ts

@@ -44,10 +44,10 @@ mock.module("../../runtime/assistant-event.js", () => ({
   ...realEvent,
   // Pass-through so `focus` / `conversationId` can be asserted directly
   // on the captured event's `message` payload.
-  buildAssistantEvent: (
-    message: unknown,
-    conversationId?: string,
-  ) => ({ message, conversationId }),
+  buildAssistantEvent: (message: unknown, conversationId?: string) => ({
+    message,
+    conversationId,
+  }),
 }));
 
 // Stub DB helpers so the real `launchConversation` can run without a DB.
@@ -73,6 +73,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
   ) => {
     updateTitleCalls.push({ conversationId, title });
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Stub conversation-store so the real `launchConversation` can hydrate
@@ -107,10 +108,7 @@ let processStartedPromise = new Promise<void>((resolve) => {
 const realProcessMessage = await import("../process-message.js");
 mock.module("../process-message.js", () => ({
   ...realProcessMessage,
-  processMessageInBackground: (
-    conversationId: string,
-    content: string,
-  ) => {
+  processMessageInBackground: (conversationId: string, content: string) => {
     processMessageCalls.push({ conversationId, content });
     markProcessStarted();
     return new Promise((resolve, reject) => {
@@ -177,13 +175,13 @@ function makeContext(
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,
-    enqueueMessage: (content: string) => {
-      enqueueCalls.push({ content });
+    enqueueMessage: (options) => {
+      enqueueCalls.push({ content: options.content });
       return { queued: false, requestId: "enq-req" };
     },
     getQueueDepth: () => 0,
-    processMessage: async (content: string) => {
-      processCalls.push({ content });
+    processMessage: async (options) => {
+      processCalls.push({ content: options.content });
       return "ok";
     },
     withSurface: createSurfaceMutex(),
@@ -256,7 +254,7 @@ describe("handleSurfaceAction — launch_conversation dispatch", () => {
 
   test("launches new conversation with inherited trust context and no chat message", async () => {
     nextKeyStoreResult = { conversationId: "conv-launched-1" };
-    
+
     const originTrustContext: TrustContext = {
       sourceChannel: "vellum",
       trustClass: "guardian",
@@ -351,7 +349,7 @@ describe("handleSurfaceAction — launch_conversation dispatch", () => {
 
   test("omits originTrustContext when origin conversation has none", async () => {
     nextKeyStoreResult = { conversationId: "conv-launched-3" };
-    
+
     // No `trustContext` on the origin context — simulating the
     // no-inherited-guardian path.
     const ctx = makeContext();
@@ -382,7 +380,7 @@ describe("handleSurfaceAction — launch_conversation dispatch", () => {
 
   test("handler returns before the seed turn resolves (fire-and-forget)", async () => {
     nextKeyStoreResult = { conversationId: "conv-nonblocking" };
-    
+
     const ctx = makeContext();
     registerCardSurface(ctx, "surface-4");
 
@@ -413,7 +411,7 @@ describe("handleSurfaceAction — launch_conversation dispatch", () => {
 
   test("seed turn rejection is swallowed by the helper's .catch()", async () => {
     nextKeyStoreResult = { conversationId: "conv-seed-fails" };
-    
+
     const ctx = makeContext();
     registerCardSurface(ctx, "surface-5");
 
@@ -449,7 +447,7 @@ describe("handleSurfaceAction — launch_conversation dispatch", () => {
     // message and triggering a full LLM round-trip on every click. The plan
     // claimed to eliminate that round-trip; this test enforces it.
     nextKeyStoreResult = { conversationId: "conv-pending-set" };
-    
+
     const ctx = makeContext();
     registerCardSurface(ctx, "surface-pending");
     // Simulate `ui_show` having stamped a pending entry for this surface

package/src/daemon/__tests__/conversation-tool-setup-exclude.test.ts

@@ -29,7 +29,6 @@ function mcpTool(name: string): Tool {
   return {
     name,
     description: name,
-    origin: "mcp",
     input_schema: def(name).input_schema,
   } as unknown as Tool;
 }
@@ -89,7 +88,7 @@ describe("createResolveToolsCallback — config.tools.exclude", () => {
   });
 
   test("excluded MCP tool is omitted from the resolved tool list", () => {
-    registerMcpTools([
+    registerMcpTools("test-server", [
       mcpTool("mcp__server__navigate"),
       mcpTool("mcp__server__click"),
     ]);

package/src/daemon/__tests__/daemon-skill-host.test.ts

@@ -95,6 +95,7 @@ mock.module("../../security/secure-keys.js", () => ({
 
 mock.module("../../memory/conversation-crud.js", () => ({
   addMessage: async () => ({ id: "msg-123" }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../runtime/agent-wake.js", () => ({
@@ -108,6 +109,7 @@ mock.module("../../runtime/assistant-event-hub.js", () => ({
     publish: publishSpy,
     subscribe: subscribeSpy,
   },
+  broadcastMessage: async () => {},
 }));
 
 mock.module("../../runtime/assistant-event.js", () => ({

package/src/daemon/__tests__/inference-profile-notification.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Verifies that the inference-profile-change notification is persisted only
+ * once the model has actually received the turn context carrying the
+ * `model_profile` block — signalled by the first `message_complete` event from
+ * the agent loop — rather than inline before the provider call. A turn that
+ * fails or is cancelled before delivery never emits `message_complete`, so the
+ * notice is re-sent on the next turn instead of being silently suppressed.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ────────────────────────
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: {} }),
+  loadConfig: () => ({}),
+}));
+
+const setLastNotifiedInferenceProfile = mock(
+  (_conversationId: string, _profileKey: string) => {},
+);
+
+mock.module("../../memory/conversation-crud.js", () => ({
+  deleteMessageById: () => {},
+  getConversation: () => null,
+  getMessageById: () => null,
+  messageMetadataSchema: { safeParse: () => ({ success: false }) },
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  setConversationHistoryStrippedAt: () => {},
+  setLastNotifiedInferenceProfile,
+  updateMessageContent: () => {},
+}));
+
+mock.module("../../memory/llm-request-log-store.js", () => ({
+  backfillMessageIdOnLogs: () => {},
+  buildProviderErrorResponsePayload: () => ({}),
+  recordRequestLog: () => {},
+  setAgentLoopExitReasonOnLatestLog: () => {},
+}));
+
+mock.module("../../memory/memory-recall-log-store.js", () => ({
+  backfillMemoryRecallLogMessageId: () => {},
+}));
+
+mock.module("../../memory/memory-v2-activation-log-store.js", () => ({
+  backfillMemoryV2ActivationMessageId: () => {},
+}));
+
+// ── Imports (after mocks) ────────────────────────────────────────────────────
+import type { AgentEvent } from "../../agent/loop.js";
+import type { Message } from "../../providers/types.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  dispatchAgentEvent,
+} from "../conversation-agent-loop-handlers.js";
+
+const CONVERSATION_ID = "conv-profile-notify";
+const PROFILE_KEY = "quality-optimized";
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: CONVERSATION_ID,
+      provider: { name: "mock-provider" },
+      traceEmitter: { emit: () => {} },
+      currentTurnSurfaces: [],
+      trustContext: undefined,
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "req-profile-notify",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
+  } as EventHandlerDeps;
+}
+
+function messageCompleteEvent(): Extract<
+  AgentEvent,
+  { type: "message_complete" }
+> {
+  const message: Message = {
+    role: "assistant",
+    content: [{ type: "text", text: "response" }],
+  };
+  return { type: "message_complete", message };
+}
+
+// A reserved assistant row id is the precondition `handleMessageComplete`
+// asserts before finalizing; the row reservation itself is exercised elsewhere.
+function readyState(): EventHandlerState {
+  const state = createEventHandlerState();
+  state.lastAssistantMessageId = "assistant-row-1";
+  return state;
+}
+
+describe("inference-profile-change notification persistence", () => {
+  test("persists on the first message_complete and clears the pending slot", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+    state.pendingNotifiedInferenceProfile = PROFILE_KEY;
+
+    await dispatchAgentEvent(state, makeDeps(), messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledTimes(1);
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledWith(
+      CONVERSATION_ID,
+      PROFILE_KEY,
+    );
+    expect(state.pendingNotifiedInferenceProfile).toBeNull();
+  });
+
+  test("does not persist when the turn carries no profile-change notice", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+
+    await dispatchAgentEvent(state, makeDeps(), messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).not.toHaveBeenCalled();
+  });
+
+  test("persists exactly once across a multi-call turn", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+    state.pendingNotifiedInferenceProfile = PROFILE_KEY;
+    const deps = makeDeps();
+
+    await dispatchAgentEvent(state, deps, messageCompleteEvent());
+    await dispatchAgentEvent(state, deps, messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledTimes(1);
+  });
+});