@vellumai/assistant 0.8.0 → 0.8.2

package/src/credential-execution/managed-catalog.ts

@@ -67,6 +67,43 @@ export interface FetchManagedCatalogResult {
   error?: string;
 }
 
+// ---------------------------------------------------------------------------
+// Managed connection cache — provides a synchronous view of platform-managed
+// connections for use in the system prompt (which is built synchronously).
+// Refresh is triggered at daemon startup and periodically via setInterval.
+// ---------------------------------------------------------------------------
+
+export interface CachedManagedConnection {
+  provider: string;
+  accountInfo: string | null;
+}
+
+let cachedConnections: CachedManagedConnection[] = [];
+
+/**
+ * Return the last successfully fetched managed connections.
+ * Returns an empty array before the first successful refresh.
+ */
+export function getCachedManagedConnections(): CachedManagedConnection[] {
+  return cachedConnections;
+}
+
+/**
+ * Fetch managed connections from the platform and update the in-memory cache.
+ * Best-effort: errors are logged and the cache retains its previous value.
+ */
+export async function refreshManagedConnectionCache(): Promise<void> {
+  const result = await fetchManagedCatalog();
+  if (result.ok) {
+    cachedConnections = result.descriptors
+      .filter((d) => d.status === "active" || d.status === "ACTIVE")
+      .map((d) => ({
+        provider: d.provider,
+        accountInfo: d.accountInfo,
+      }));
+  }
+}
+
 /**
  * Fetch the managed credential catalog from the platform.
  *

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

@@ -13,11 +13,14 @@
 
 import { isTokenExpired } from "@vellumai/credential-storage";
 
+import type { Services } from "../config/schemas/services.js";
 import { getConnectionAccessTokenResult } from "../oauth/credential-token-resolver.js";
 import {
   getProvider,
   listActiveConnectionsByProvider,
   listProviders,
+  type OAuthConnectionRow,
+  type OAuthProviderRow,
 } from "../oauth/oauth-store.js";
 import { getLogger } from "../util/logger.js";
 
@@ -271,6 +274,207 @@ async function checkConnection(
   };
 }
 
+// ── Managed provider checks ──────────────────────────────────────────
+
+/**
+ * Check whether a provider is configured in managed mode.
+ * Uses dynamic imports to avoid circular dependencies (same pattern as
+ * `integration-status.ts`).
+ */
+async function isManagedProvider(
+  providerRow: OAuthProviderRow,
+): Promise<boolean> {
+  const managedKey = providerRow.managedServiceConfigKey;
+  if (!managedKey) return false;
+
+  try {
+    const { ServicesSchema, getServiceMode } =
+      await import("../config/schemas/services.js");
+    if (!(managedKey in ServicesSchema.shape)) return false;
+
+    const { getConfig } = await import("../config/loader.js");
+    const services: Services = getConfig().services;
+    return getServiceMode(services, managedKey as keyof Services) === "managed";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Fetch active managed connections from the platform and ping each one.
+ * Returns health results for managed connections, or an empty array if
+ * the platform is unreachable or the provider is not managed.
+ */
+async function checkManagedProvider(
+  providerRow: OAuthProviderRow,
+): Promise<CredentialHealthResult[]> {
+  const results: CredentialHealthResult[] = [];
+
+  try {
+    const { VellumPlatformClient } = await import("../platform/client.js");
+    const client = await VellumPlatformClient.create();
+    if (!client?.platformAssistantId) return results;
+
+    const params = new URLSearchParams();
+    params.set("provider", providerRow.provider);
+    params.set("status", "ACTIVE");
+
+    const path = `/v1/assistants/${encodeURIComponent(client.platformAssistantId)}/oauth/connections/?${params.toString()}`;
+    const response = await client.fetch(path);
+
+    if (!response.ok) {
+      log.warn(
+        { status: response.status, provider: providerRow.provider },
+        "Failed to list managed connections for health check",
+      );
+      return results;
+    }
+
+    const body = (await response.json()) as unknown;
+    const connections = (
+      Array.isArray(body)
+        ? body
+        : ((body as Record<string, unknown>).results ?? [])
+    ) as Array<{ id: string; account_label?: string }>;
+
+    if (connections.length === 0) {
+      // No active managed connections — report as missing so the
+      // heartbeat can notify the user.
+      results.push({
+        connectionId: `managed:${providerRow.provider}`,
+        provider: providerRow.provider,
+        accountInfo: null,
+        status: "missing_token",
+        details: `No active managed connection for ${providerRow.provider}. Reconnect on the Vellum platform.`,
+        missingScopes: [],
+        canAutoRecover: false,
+      });
+      return results;
+    }
+
+    // Ping each managed connection via the platform proxy
+    for (const conn of connections) {
+      const base: Omit<
+        CredentialHealthResult,
+        "status" | "details" | "canAutoRecover"
+      > = {
+        connectionId: conn.id,
+        provider: providerRow.provider,
+        accountInfo: conn.account_label ?? null,
+        missingScopes: [],
+      };
+
+      if (!providerRow.pingUrl) {
+        // No ping URL configured — assume healthy if connection exists
+        results.push({
+          ...base,
+          status: "healthy",
+          details: `${providerRow.provider} managed connection is active (no ping URL configured).`,
+          canAutoRecover: true,
+        });
+        continue;
+      }
+
+      // Ping via platform proxy
+      try {
+        const { PlatformOAuthConnection } =
+          await import("../oauth/platform-connection.js");
+        const platformConn = new PlatformOAuthConnection({
+          id: conn.id,
+          provider: providerRow.provider,
+          externalId: providerRow.provider,
+          accountInfo: conn.account_label ?? null,
+          client,
+          connectionId: conn.id,
+          baseUrl: undefined,
+        });
+
+        // Decompose the absolute pingUrl into base URL + relative path.
+        // OAuthConnectionRequest.path is documented as relative, but
+        // provider definitions store full absolute URLs.
+        const parsedPingUrl = new URL(providerRow.pingUrl);
+        const pingBaseUrl = `${parsedPingUrl.protocol}//${parsedPingUrl.host}`;
+        const pingPath = parsedPingUrl.pathname + parsedPingUrl.search;
+
+        const parsedHeaders = safeJsonParse<Record<string, string>>(
+          providerRow.pingHeaders,
+          {},
+        );
+        const parsedBody = safeJsonParse<unknown>(providerRow.pingBody, null);
+
+        const pingResp = await platformConn.request({
+          method: providerRow.pingMethod ?? "GET",
+          path: pingPath,
+          baseUrl: pingBaseUrl,
+          ...(Object.keys(parsedHeaders).length > 0
+            ? { headers: parsedHeaders }
+            : {}),
+          ...(parsedBody != null ? { body: parsedBody } : {}),
+          signal: AbortSignal.timeout(PING_TIMEOUT_MS),
+        });
+
+        if (pingResp.status >= 200 && pingResp.status < 300) {
+          results.push({
+            ...base,
+            status: "healthy",
+            details: `${providerRow.provider} managed credential is healthy.`,
+            canAutoRecover: true,
+          });
+        } else if (pingResp.status === 401 || pingResp.status === 403) {
+          results.push({
+            ...base,
+            status: "revoked",
+            details: `${providerRow.provider} managed token was rejected (${pingResp.status}). Reconnect on the Vellum platform.`,
+            canAutoRecover: false,
+          });
+        } else {
+          results.push({
+            ...base,
+            status: "ping_failed",
+            details: `${providerRow.provider} managed liveness check returned ${pingResp.status}.`,
+            canAutoRecover: false,
+          });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        // CredentialRequiredError means the platform can't materialize
+        // the token — treat as revoked.
+        if (
+          err &&
+          typeof err === "object" &&
+          "name" in err &&
+          (err as { name: string }).name === "CredentialRequiredError"
+        ) {
+          results.push({
+            ...base,
+            status: "revoked",
+            details: `${providerRow.provider} managed connection is no longer valid. Reconnect on the Vellum platform.`,
+            canAutoRecover: false,
+          });
+        } else {
+          log.debug(
+            { provider: providerRow.provider, connectionId: conn.id, err: msg },
+            "Managed credential ping failed",
+          );
+          results.push({
+            ...base,
+            status: "ping_failed",
+            details: `${providerRow.provider} managed liveness check failed: ${msg}`,
+            canAutoRecover: false,
+          });
+        }
+      }
+    }
+  } catch (err) {
+    log.warn(
+      { err, provider: providerRow.provider },
+      "Failed to check managed provider health",
+    );
+  }
+
+  return results;
+}
+
 // ── Public API ────────────────────────────────────────────────────────
 
 /**
@@ -279,6 +483,9 @@ async function checkConnection(
  * Iterates every registered provider, looks up active connections, and
  * validates each one. Returns a structured report with overall results
  * and a filtered list of unhealthy credentials.
+ *
+ * Checks both BYO (local SQLite) and managed (platform-hosted)
+ * connections.
  */
 export async function checkAllCredentials(): Promise<CredentialHealthReport> {
   const checkedAt = Date.now();
@@ -292,6 +499,10 @@ export async function checkAllCredentials(): Promise<CredentialHealthReport> {
     return { checkedAt, results, unhealthy: [] };
   }
 
+  // Track which providers have BYO connections so we skip the managed
+  // check for them (they're already covered by the BYO path).
+  const byoProviders = new Set<string>();
+
   for (const providerRow of providers) {
     let connections;
     try {
@@ -304,6 +515,10 @@ export async function checkAllCredentials(): Promise<CredentialHealthReport> {
       continue;
     }
 
+    if (connections.length > 0) {
+      byoProviders.add(providerRow.provider);
+    }
+
     for (const conn of connections) {
       try {
         const result = await checkConnection({
@@ -329,6 +544,36 @@ export async function checkAllCredentials(): Promise<CredentialHealthReport> {
     }
   }
 
+  // Check managed connections. If a provider is currently in managed mode,
+  // evaluate it via the managed path even if stale BYO rows exist — the
+  // user may have switched from BYO to managed.
+  for (const providerRow of providers) {
+    if (!(await isManagedProvider(providerRow))) continue;
+
+    // If the provider is in managed mode and also has BYO connections,
+    // remove the stale BYO results — managed mode takes priority.
+    if (byoProviders.has(providerRow.provider)) {
+      const beforeLen = results.length;
+      const filtered = results.filter(
+        (r) => r.provider !== providerRow.provider,
+      );
+      if (filtered.length !== beforeLen) {
+        results.length = 0;
+        results.push(...filtered);
+      }
+    }
+
+    try {
+      const managedResults = await checkManagedProvider(providerRow);
+      results.push(...managedResults);
+    } catch (err) {
+      log.warn(
+        { err, provider: providerRow.provider },
+        "Failed to check managed provider health",
+      );
+    }
+  }
+
   const unhealthy = results.filter((r) => r.status !== "healthy");
   if (unhealthy.length > 0) {
     log.info(
@@ -351,34 +596,50 @@ export async function checkAllCredentials(): Promise<CredentialHealthReport> {
  * result for the most recent active connection, or null if no connection
  * exists.
  *
+ * Checks BYO connections first; if none exist, falls back to checking
+ * managed connections on the platform.
+ *
  * Used by the watcher engine for pre-poll gating.
  */
 export async function checkCredentialForProvider(
   provider: string,
 ): Promise<CredentialHealthResult | null> {
-  let connections;
+  const providerRow = getProvider(provider);
+  if (!providerRow) return null;
+
+  // Check managed mode first — if the provider is currently configured for
+  // managed mode, evaluate via the platform regardless of stale BYO rows.
+  if (await isManagedProvider(providerRow)) {
+    const managedResults = await checkManagedProvider(providerRow);
+    if (managedResults.length > 0) return managedResults[0]!;
+    return null;
+  }
+
+  // Fall back to BYO (local) connection check.
+  let connections: OAuthConnectionRow[];
   try {
     connections = listActiveConnectionsByProvider(provider);
   } catch {
-    return null;
+    connections = [];
   }
-  if (connections.length === 0) return null;
 
-  const conn = connections[0]!;
-  const providerRow = getProvider(conn.provider);
-  if (!providerRow) return null;
+  if (connections.length > 0) {
+    const conn = connections[0]!;
+
+    return checkConnection({
+      connectionId: conn.id,
+      provider: conn.provider,
+      accountInfo: conn.accountInfo,
+      expiresAt: conn.expiresAt,
+      hasRefreshToken: !!conn.hasRefreshToken,
+      grantedScopesRaw: conn.grantedScopes,
+      defaultScopesRaw: providerRow.defaultScopes,
+      pingUrl: providerRow.pingUrl,
+      pingMethod: providerRow.pingMethod,
+      pingHeaders: providerRow.pingHeaders,
+      pingBody: providerRow.pingBody,
+    });
+  }
 
-  return checkConnection({
-    connectionId: conn.id,
-    provider: conn.provider,
-    accountInfo: conn.accountInfo,
-    expiresAt: conn.expiresAt,
-    hasRefreshToken: !!conn.hasRefreshToken,
-    grantedScopesRaw: conn.grantedScopes,
-    defaultScopesRaw: providerRow.defaultScopes,
-    pingUrl: providerRow.pingUrl,
-    pingMethod: providerRow.pingMethod,
-    pingHeaders: providerRow.pingHeaders,
-    pingBody: providerRow.pingBody,
-  });
+  return null;
 }

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

@@ -62,8 +62,11 @@ const autoAnalysisConversations = new Set<string>();
 // flip this to true.
 let v2Enabled = false;
 
+const realLoader = await import("../../config/loader.js");
 mock.module("../../config/loader.js", () => ({
+  ...realLoader,
   getConfig: () => ({ memory: { v2: { enabled: v2Enabled } } }),
+  loadConfig: () => ({ memory: { v2: { enabled: v2Enabled } } }),
 }));
 
 mock.module("../../memory/auto-analysis-guard.js", () => ({
@@ -81,7 +84,10 @@ mock.module("../../memory/jobs-store.js", () => ({
   },
 }));
 
+const realAutoAnalysisEnqueue =
+  await import("../../memory/auto-analysis-enqueue.js");
 mock.module("../../memory/auto-analysis-enqueue.js", () => ({
+  ...realAutoAnalysisEnqueue,
   enqueueAutoAnalysisIfEnabled: (args: {
     conversationId: string;
     trigger: "batch" | "idle" | "lifecycle";
@@ -91,17 +97,46 @@ mock.module("../../memory/auto-analysis-enqueue.js", () => ({
   },
 }));
 
+let memoryRetroEnabled = false;
+const memoryRetroCalls: Array<{
+  conversationId: string;
+  trigger: string;
+}> = [];
+
+mock.module("../../memory/memory-retrospective-enqueue.js", () => ({
+  enqueueMemoryRetrospectiveIfEnabled: (args: {
+    conversationId: string;
+    trigger: string;
+  }) => {
+    if (!memoryRetroEnabled) return;
+    memoryRetroCalls.push(args);
+  },
+  // Also export sibling functions other modules import from this file, so
+  // mocking it here doesn't break transitive imports loaded during the
+  // `disposeConversation` dynamic-import chain.
+  enqueueMemoryRetrospectiveOnCompaction: () => {},
+  isMemoryRetrospectiveConversation: (_id: string) => false,
+}));
+
 // Stub all side-effecting cleanup helpers that disposeConversation chains
 // into after the enqueue block. We assert on enqueue behavior only.
+const realBrowserScreencast =
+  await import("../../tools/browser/browser-screencast.js");
 mock.module("../../tools/browser/browser-screencast.js", () => ({
+  ...realBrowserScreencast,
   unregisterConversationSender: () => {},
 }));
 
+const realConversationNotifiers = await import("../conversation-notifiers.js");
 mock.module("../conversation-notifiers.js", () => ({
+  ...realConversationNotifiers,
   unregisterCallNotifiers: () => {},
 }));
 
+const realConversationSkillTools =
+  await import("../conversation-skill-tools.js");
 mock.module("../conversation-skill-tools.js", () => ({
+  ...realConversationSkillTools,
   resetSkillToolProjection: () => {},
 }));
 
@@ -168,7 +203,9 @@ describe("disposeConversation — auto-analysis enqueue", () => {
   beforeEach(() => {
     memoryJobCalls.length = 0;
     autoAnalyzeCalls.length = 0;
+    memoryRetroCalls.length = 0;
     autoAnalyzeEnabled = true;
+    memoryRetroEnabled = false;
     autoAnalysisConversations.clear();
     v2Enabled = false;
   });
@@ -346,3 +383,79 @@ describe("disposeConversation — auto-analysis enqueue", () => {
     });
   });
 });
+
+describe("disposeConversation — memory-retrospective lifecycle safety net", () => {
+  beforeEach(() => {
+    memoryJobCalls.length = 0;
+    autoAnalyzeCalls.length = 0;
+    memoryRetroCalls.length = 0;
+    autoAnalyzeEnabled = false;
+    memoryRetroEnabled = false;
+    autoAnalysisConversations.clear();
+    v2Enabled = false;
+  });
+
+  test("guardian conversation + flag on — enqueues memory-retrospective with trigger 'lifecycle'", () => {
+    memoryRetroEnabled = true;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-retro",
+      trustClass: "guardian",
+    });
+
+    disposeConversation(ctx);
+
+    expect(memoryRetroCalls).toHaveLength(1);
+    expect(memoryRetroCalls[0]).toEqual({
+      conversationId: "conv-retro",
+      trigger: "lifecycle",
+    });
+  });
+
+  test("flag off — no memory-retrospective enqueue", () => {
+    memoryRetroEnabled = false;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-retro-off",
+      trustClass: "guardian",
+    });
+
+    disposeConversation(ctx);
+
+    expect(memoryRetroCalls).toHaveLength(0);
+  });
+
+  test("untrusted actor — no memory-retrospective enqueue even when flag is on", () => {
+    memoryRetroEnabled = true;
+    const ctx = makeDisposeContext({
+      conversationId: "conv-retro-untrusted",
+      trustClass: "unknown",
+    });
+
+    disposeConversation(ctx);
+
+    // The outer trust-class guard in disposeConversation gates ALL three
+    // enqueues (graph_extract, auto-analyze, memory-retrospective). When
+    // the actor is untrusted, none of them fire.
+    expect(memoryRetroCalls).toHaveLength(0);
+    expect(autoAnalyzeCalls).toHaveLength(0);
+  });
+
+  // Regression test: the retrospective lifecycle enqueue was previously
+  // outside the `!isAutoAnalysis` guard, so it fired even for auto-analysis
+  // conversations. Mirrors the indexer-time gate in `indexer.ts` and
+  // matches the existing graph_extract recursion-guard semantics.
+  test("auto-analysis conversation — does NOT enqueue memory-retrospective even with flag on", () => {
+    memoryRetroEnabled = true;
+    autoAnalysisConversations.add("conv-auto-retro");
+    const ctx = makeDisposeContext({
+      conversationId: "conv-auto-retro",
+      trustClass: "guardian",
+    });
+
+    disposeConversation(ctx);
+
+    expect(memoryRetroCalls).toHaveLength(0);
+    // graph_extract is also recursion-guarded by the same `!isAutoAnalysis`
+    // block, so it should be skipped here too.
+    expect(memoryJobCalls).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,138 @@
+/**
+ * Tests for the `config.tools.exclude` filter applied inside
+ * `createResolveToolsCallback`. Excluded tool names must not appear in the
+ * tool list resolved per turn, nor in the executor's `allowedToolNames`.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+
+import * as configLoader from "../../config/loader.js";
+import type { AssistantConfig } from "../../config/schema.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import {
+  __clearRegistryForTesting,
+  registerMcpTools,
+} from "../../tools/registry.js";
+import type { Tool } from "../../tools/types.js";
+import { createResolveToolsCallback } from "../conversation-tool-setup.js";
+
+type SkillProjectionContext =
+  import("../conversation-tool-setup.js").SkillProjectionContext;
+type SkillProjectionCache =
+  import("../conversation-skill-tools.js").SkillProjectionCache;
+
+function def(name: string): ToolDefinition {
+  return { name, description: name, input_schema: { type: "object" } };
+}
+
+function mcpTool(name: string): Tool {
+  return {
+    name,
+    description: name,
+    origin: "mcp",
+    getDefinition: () => def(name),
+  } as unknown as Tool;
+}
+
+function makeCtx(
+  overrides: Partial<SkillProjectionContext> = {},
+): SkillProjectionContext {
+  return {
+    skillProjectionState: new Map(),
+    skillProjectionCache: { fingerprints: new Map() } as SkillProjectionCache,
+    coreToolNames: new Set<string>(),
+    toolsDisabledDepth: 0,
+    ...overrides,
+  };
+}
+
+function withExclude(exclude: string[]) {
+  const stub: Partial<AssistantConfig> = { tools: { exclude } };
+  return spyOn(configLoader, "getConfig").mockReturnValue(
+    stub as AssistantConfig,
+  );
+}
+
+let getConfigSpy: ReturnType<typeof withExclude> | undefined;
+
+beforeEach(() => {
+  __clearRegistryForTesting();
+});
+
+afterEach(() => {
+  getConfigSpy?.mockRestore();
+  getConfigSpy = undefined;
+  __clearRegistryForTesting();
+});
+
+describe("createResolveToolsCallback — config.tools.exclude", () => {
+  test("excluded core tool is omitted from the resolved tool list", () => {
+    getConfigSpy = withExclude(["bash"]);
+    const resolver = createResolveToolsCallback(
+      [def("bash"), def("file_read")],
+      makeCtx(),
+    );
+    const result = resolver!([]);
+    expect(result.map((d) => d.name)).toEqual(["file_read"]);
+  });
+
+  test("excluded core tool is removed from ctx.allowedToolNames", () => {
+    getConfigSpy = withExclude(["bash"]);
+    const ctx = makeCtx();
+    const resolver = createResolveToolsCallback(
+      [def("bash"), def("file_read")],
+      ctx,
+    );
+    resolver!([]);
+    expect(ctx.allowedToolNames?.has("bash")).toBe(false);
+    expect(ctx.allowedToolNames?.has("file_read")).toBe(true);
+  });
+
+  test("excluded MCP tool is omitted from the resolved tool list", () => {
+    registerMcpTools([
+      mcpTool("mcp__server__navigate"),
+      mcpTool("mcp__server__click"),
+    ]);
+    getConfigSpy = withExclude(["mcp__server__navigate"]);
+    const resolver = createResolveToolsCallback(
+      [def("mcp__server__navigate"), def("mcp__server__click")],
+      makeCtx(),
+    );
+    const result = resolver!([]);
+    expect(result.map((d) => d.name)).toEqual(["mcp__server__click"]);
+  });
+
+  test("unknown name in exclude list is silently ignored", () => {
+    getConfigSpy = withExclude(["does_not_exist"]);
+    const resolver = createResolveToolsCallback([def("file_read")], makeCtx());
+    expect(() => resolver!([])).not.toThrow();
+    expect(resolver!([]).map((d) => d.name)).toEqual(["file_read"]);
+  });
+
+  test("empty exclude list leaves the tool set unchanged", () => {
+    getConfigSpy = withExclude([]);
+    const resolver = createResolveToolsCallback(
+      [def("bash"), def("file_read")],
+      makeCtx(),
+    );
+    expect(
+      resolver!([])
+        .map((d) => d.name)
+        .sort(),
+    ).toEqual(["bash", "file_read"]);
+  });
+
+  test("excluded tool stays excluded under disk-pressure cleanup mode", () => {
+    // `bash` is a cleanup-safe tool and would normally survive cleanup mode;
+    // the exclude filter must still suppress it.
+    getConfigSpy = withExclude(["bash"]);
+    const ctx = makeCtx({ diskPressureCleanupModeActive: true });
+    const resolver = createResolveToolsCallback(
+      [def("bash"), def("file_read")],
+      ctx,
+    );
+    const result = resolver!([]);
+    expect(result.map((d) => d.name)).not.toContain("bash");
+    expect(ctx.allowedToolNames?.has("bash")).toBe(false);
+  });
+});