@vellumai/assistant 0.8.5 → 0.8.6

package/src/providers/registry.ts

@@ -29,10 +29,18 @@ const log = getLogger("provider-registry");
 const providers = new Map<string, Provider>();
 const routingSources = new Map<string, "user-key" | "managed-proxy">();
 const OPENAI_COMPATIBLE_ENDPOINTS_FLAG = "openai-compatible-endpoints";
+const NATIVE_WEB_SEARCH_PROVIDER_IDS = new Set(["anthropic", "openai"]);
 
-/** Per-connection provider cache, keyed by connection name. */
+/** Per-connection provider cache, keyed by connection name and model. */
 const connectionProviders = new Map<string, Provider>();
 
+function getConnectionProviderCacheKey(
+  connection: ProviderConnection,
+  model: string,
+): string {
+  return `${connection.name}\u0000${model}`;
+}
+
 function registerProvider(name: string, provider: Provider): void {
   providers.set(name, new UsageTrackingProvider(provider));
 }
@@ -98,6 +106,30 @@ function resolveModel(config: ProvidersConfig, providerName: string): string {
   return getProviderDefaultModel(providerName);
 }
 
+export function isNativeWebSearchCapableProvider(
+  providerName: string,
+  model: string,
+): boolean {
+  if (NATIVE_WEB_SEARCH_PROVIDER_IDS.has(providerName)) {
+    return true;
+  }
+  if (providerName === "openrouter" && model.startsWith("anthropic/")) {
+    return true;
+  }
+  return false;
+}
+
+function shouldUseNativeWebSearch(
+  config: ProvidersConfig,
+  providerName: string,
+  model: string,
+): boolean {
+  return (
+    config.services["web-search"].provider === "inference-provider-native" &&
+    isNativeWebSearchCapableProvider(providerName, model)
+  );
+}
+
 /**
  * Resolve provider credentials. User key takes precedence; managed proxy is
  * used as a fallback when platform prerequisites are available.
@@ -135,8 +167,6 @@ export async function initializeProviders(
 
   const streamTimeoutMs =
     (config.timeouts?.providerStreamTimeoutSec ?? 1800) * 1000;
-  const useNativeWebSearch =
-    config.services["web-search"].provider === "inference-provider-native";
   const mainAgentProvider = resolveCallSiteConfig(
     "mainAgent",
     config.llm,
@@ -174,6 +204,11 @@ export async function initializeProviders(
     }
 
     const model = resolveModel(config, entry.id);
+    const useNativeWebSearch = shouldUseNativeWebSearch(
+      config,
+      entry.id,
+      model,
+    );
     const adapter = buildProviderAdapter(entry.id, {
       apiKey,
       model,
@@ -221,6 +256,7 @@ export async function initializeProviders(
 export async function resolveProviderFromConnection(
   connection: ProviderConnection,
   config: ProvidersConfig,
+  opts: { model?: string } = {},
 ): Promise<Provider | null> {
   if (
     connection.provider === "openai-compatible" &&
@@ -229,7 +265,9 @@ export async function resolveProviderFromConnection(
     return null;
   }
 
-  const cached = connectionProviders.get(connection.name);
+  const model = opts.model ?? resolveModel(config, connection.provider);
+  const cacheKey = getConnectionProviderCacheKey(connection, model);
+  const cached = connectionProviders.get(cacheKey);
   if (cached) return cached;
 
   const authResult = await resolveAuth(connection.auth, connection.provider, {
@@ -259,9 +297,11 @@ export async function resolveProviderFromConnection(
 
   const streamTimeoutMs =
     (config.timeouts?.providerStreamTimeoutSec ?? 1800) * 1000;
-  const useNativeWebSearch =
-    config.services["web-search"].provider === "inference-provider-native";
-  const model = resolveModel(config, connection.provider);
+  const useNativeWebSearch = shouldUseNativeWebSearch(
+    config,
+    connection.provider,
+    model,
+  );
 
   const provider = createAdapterFromConnection(
     connection,
@@ -274,7 +314,7 @@ export async function resolveProviderFromConnection(
   );
 
   if (provider) {
-    connectionProviders.set(connection.name, provider);
+    connectionProviders.set(cacheKey, provider);
   }
 
   return provider;

package/src/providers/retry.ts

@@ -34,6 +34,7 @@ const USAGE_ATTRIBUTION_HEADER_NAMES = {
   inferenceProfileSource: "X-Vellum-Inference-Profile-Source",
   resolvedProvider: "X-Vellum-Resolved-Provider",
   resolvedModel: "X-Vellum-Resolved-Model",
+  resolvedMixArm: "X-Vellum-Resolved-Mix-Arm",
 } as const;
 
 /** Providers that support the `effort` config (extended thinking / reasoning). */
@@ -195,19 +196,23 @@ function normalizeSendMessageOptions(
   delete nextConfig.usageAttributionHeaders;
   delete nextConfig.usageTracking;
 
-  // `overrideProfile` is a routing/resolution-time concern (consumed by the
-  // resolver below and `CallSiteRoutingProvider`'s provider selection); it is
-  // not a wire-format field. Strip unconditionally so it never leaks into
-  // provider request bodies even when callers set it without a `callSite`.
+  // `overrideProfile` and `selectionSeed` are routing/resolution-time concerns
+  // (consumed by the resolver below and `CallSiteRoutingProvider`'s provider
+  // selection); neither is a wire-format field. Strip unconditionally so they
+  // never leak into provider request bodies even when callers set them without
+  // a `callSite`.
   delete nextConfig.overrideProfile;
+  delete nextConfig.selectionSeed;
 
   if (config.callSite !== undefined) {
     const resolved = resolveCallSiteConfig(config.callSite, getConfig().llm, {
       overrideProfile: config.overrideProfile,
+      selectionSeed: config.selectionSeed,
     });
     const attribution = resolveUsageAttribution({
       callSite: config.callSite,
       overrideProfile: config.overrideProfile,
+      selectionSeed: config.selectionSeed,
     });
 
     const explicitModel =
@@ -225,6 +230,7 @@ function normalizeSendMessageOptions(
         profileSource: attribution.profileSource,
         resolvedProvider: attribution.resolvedProvider,
         resolvedModel: attribution.resolvedModel,
+        resolvedMixArm: attribution.resolvedMixArm,
       });
       if (Object.keys(usageAttributionHeaders).length > 0) {
         nextConfig.usageAttributionHeaders = usageAttributionHeaders;
@@ -446,6 +452,7 @@ function buildUsageAttributionHeaders(input: {
   profileSource: string;
   resolvedProvider: string;
   resolvedModel: string;
+  resolvedMixArm: string | null;
 }): Record<string, string> {
   const headers: Record<string, string> = {};
   addSanitizedHeader(
@@ -475,6 +482,11 @@ function buildUsageAttributionHeaders(input: {
     USAGE_ATTRIBUTION_HEADER_NAMES.resolvedModel,
     input.resolvedModel,
   );
+  addSanitizedHeader(
+    headers,
+    USAGE_ATTRIBUTION_HEADER_NAMES.resolvedMixArm,
+    input.resolvedMixArm,
+  );
   return headers;
 }
 

package/src/providers/search-provider-catalog.ts

@@ -42,8 +42,17 @@ export interface SearchProviderCatalogEntry {
    * privacy notices). Defaults to {@link displayName} when omitted.
    */
   readonly displayNameLong?: string;
-  /** Authentication style. `managed` providers are routed through the
-   *  inference provider; `byok` providers require a user-supplied key. */
+  /**
+   * Authentication style for the search provider choice.
+   *
+   * `managed` means the choice does not require a user-supplied search API key.
+   * For `inference-provider-native`, the daemon uses the inference API's native
+   * hosted web-search tool only when the selected inference provider/model
+   * supports it. Managed non-native inference providers keep the app-executed
+   * `web_search` tool, which can route through the platform search proxy.
+   *
+   * `byok` providers require a user-supplied key in Your Own mode.
+   */
   readonly kind: SearchProviderKind;
   /** Placeholder shown in the API-key input. BYOK providers only. */
   readonly apiKeyPrefix?: string;
@@ -99,19 +108,18 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
 ];
 
 /** Provider ids accepted by the web-search config schema. */
-export const SEARCH_PROVIDER_IDS: readonly string[] = SEARCH_PROVIDER_CATALOG.map(
-  (p) => p.id,
-);
+export const SEARCH_PROVIDER_IDS: readonly string[] =
+  SEARCH_PROVIDER_CATALOG.map((p) => p.id);
 
 /** Catalog entries that store an API key under their bare provider name. */
 export const BYOK_SEARCH_PROVIDERS: readonly SearchProviderCatalogEntry[] =
   SEARCH_PROVIDER_CATALOG.filter((p) => p.kind === "byok");
 
 /** BYOK provider ids, ordered by `fallbackOrder` (ascending). */
-export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] = BYOK_SEARCH_PROVIDERS
-  .slice()
-  .sort((a, b) => (a.fallbackOrder ?? 0) - (b.fallbackOrder ?? 0))
-  .map((p) => p.id);
+export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] =
+  BYOK_SEARCH_PROVIDERS.slice()
+    .sort((a, b) => (a.fallbackOrder ?? 0) - (b.fallbackOrder ?? 0))
+    .map((p) => p.id);
 
 /** Look up a single catalog entry by id. Returns `undefined` if unknown. */
 export function getSearchProvider(

package/src/providers/types.ts

@@ -182,6 +182,15 @@ export interface SendMessageConfig {
    * silently fall through.
    */
   overrideProfile?: string;
+  /**
+   * Per-conversation seed for deterministic `mix`-profile expansion. The agent
+   * loop sets this to the conversation id so every resolver call this send
+   * triggers — provider/transport selection, wire-param normalization, usage
+   * attribution — picks the same mix constituent, stable across the
+   * conversation's turns and retries. A resolution/routing-time concern only;
+   * stripped before any provider wire request.
+   */
+  selectionSeed?: string;
   /**
    * Internal per-request HTTP headers for managed-proxy usage attribution.
    * Provider clients may pass these through SDK request options only when the

package/src/runtime/__tests__/agent-wake.test.ts

@@ -29,6 +29,7 @@ import type { DiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
   getConversation: () => ({ archivedAt: null }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const mockGetOrCreateConversationCalls: Array<{

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -40,6 +40,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
     addMessageCalls.push({ conversationId, role, content });
     return { id: `msg-${addMessageCalls.length}` };
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 let processMessageImpl: (

package/src/runtime/access-request-helper.ts

@@ -217,6 +217,7 @@ export function notifyGuardianOfAccessRequest(
     sourceEventName: "ingress.access_request",
     sourceChannel: sourceChannel as NotificationSourceChannel,
     sourceContextId: `access-req-${sourceChannel}-${actorExternalId}`,
+    requiresConversation: true,
     ...(sameChannelOnly ? { routingIntent: "single_channel" as const } : {}),
     attentionHints: {
       requiresAction: true,

package/src/runtime/auth/route-policy.ts

@@ -209,6 +209,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "identity/intro", scopes: ["settings.read"] },
   { endpoint: "home/state", scopes: ["settings.read"] },
   { endpoint: "home/feed", scopes: ["settings.read"] },
+  { endpoint: "home/feed/query", scopes: ["settings.read"] },
   { endpoint: "home/feed:PATCH", scopes: ["settings.write"] },
   { endpoint: "home/feed/actions", scopes: ["settings.write"] },
   { endpoint: "brain-graph", scopes: ["settings.read"] },
@@ -442,6 +443,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "messages/content", scopes: ["chat.read"] },
   { endpoint: "messages/llm-context", scopes: ["chat.read"] },
   { endpoint: "conversations/llm-context", scopes: ["chat.read"] },
+  { endpoint: "conversations/compaction", scopes: ["chat.read"] },
   { endpoint: "llm-request-logs/payload", scopes: ["chat.read"] },
   { endpoint: "messages/tts", scopes: ["chat.read"] },
   { endpoint: "tts/synthesize", scopes: ["chat.read"] },
@@ -490,6 +492,8 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "memory/v3/validate:POST", scopes: ["settings.read"] },
   { endpoint: "memory/v3/tree:POST", scopes: ["settings.read"] },
   { endpoint: "memory/v3/simulate:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/shadow-diff:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/seed-edges:POST", scopes: ["settings.write"] },
 
   // Trust rule listing
   { endpoint: "trust-rules/manage:GET", scopes: ["settings.read"] },
@@ -868,6 +872,12 @@ registerPolicy("notifications/events", {
   allowedPrincipalTypes: ["local"],
 });
 
+// Edit an already-sent notification: local-only (CLI / IPC callers)
+registerPolicy("notifications/edit", {
+  requiredScopes: ["settings.write"],
+  allowedPrincipalTypes: ["local"],
+});
+
 // Defer operations: local-only (CLI / IPC callers)
 registerPolicy("defer/create", {
   requiredScopes: ["settings.write"],

package/src/runtime/channel-readiness-service.ts

@@ -282,6 +282,74 @@ const slackProbe: ChannelProbe = {
       ),
     ];
   },
+  async runRemoteChecks(): Promise<ReadinessCheckResult[]> {
+    const botToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    if (!botToken) {
+      return [
+        check(
+          "auth_test",
+          false,
+          "Slack auth.test ok",
+          "Skipped: no bot_token stored",
+        ),
+      ];
+    }
+    try {
+      const res = await fetch("https://slack.com/api/auth.test", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${botToken}` },
+      });
+      const data = (await res.json()) as {
+        ok: boolean;
+        error?: string;
+        team_id?: string;
+        team?: string;
+        user?: string;
+      };
+      if (!data.ok) {
+        return [
+          check(
+            "auth_test",
+            false,
+            "Slack auth.test ok",
+            `Slack auth.test rejected bot_token: ${data.error ?? "unknown error"}`,
+          ),
+        ];
+      }
+      const raw = loadRawConfig();
+      const storedTeamId = getNestedValue(raw, "slack.teamId");
+      const teamMatches =
+        typeof storedTeamId !== "string" ||
+        storedTeamId.length === 0 ||
+        storedTeamId === data.team_id;
+      return [
+        check(
+          "auth_test",
+          true,
+          `Slack auth.test ok (workspace ${data.team ?? data.team_id ?? "unknown"}, bot ${data.user ?? "unknown"})`,
+          "Slack auth.test ok",
+        ),
+        check(
+          "workspace_match",
+          teamMatches,
+          "Stored workspace matches bot token",
+          `Stored workspace ${storedTeamId} does not match bot token's workspace ${data.team_id ?? "unknown"} — run 'assistant channels slack reconnect' to refresh metadata`,
+        ),
+      ];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return [
+        check(
+          "auth_test",
+          false,
+          "Slack auth.test ok",
+          `Failed to reach Slack auth.test: ${message}`,
+        ),
+      ];
+    }
+  },
 };
 
 // ── Service ─────────────────────────────────────────────────────────────────

package/src/runtime/channel-reply-delivery.ts

@@ -141,6 +141,29 @@ export async function deliverRenderedReplyViaCallback(
     return;
   }
 
+  if (startFromSegment >= deliverableSegments.length) {
+    if (replyAttachments) {
+      const result: ChannelDeliveryResult = await deliverChannelReply(
+        callbackUrl,
+        {
+          chatId,
+          attachments: replyAttachments,
+          assistantId,
+          ephemeral,
+          user,
+          messageTs,
+        },
+      );
+      const deliveredTs = result.ts ?? messageTs;
+      if (deliveredTs) {
+        onMessageTs?.(deliveredTs);
+      }
+    } else if (messageTs) {
+      onMessageTs?.(messageTs);
+    }
+    return;
+  }
+
   const isSlack = isSlackCallbackUrl(callbackUrl);
 
   // Only the first segment uses messageTs for in-place update;

package/src/runtime/channel-retry-sweep.ts

@@ -11,7 +11,11 @@ import { getDiskPressureStatus } from "../daemon/disk-pressure-guard.js";
 import { classifyDiskPressureTurnPolicy } from "../daemon/disk-pressure-policy.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import { updateDeliveredSegmentCount } from "../memory/delivery-channels.js";
+import {
+  addSlackDmLiveDeliveredTextResponseIndex,
+  getSlackDmLiveDeliveredTextResponseIndexes,
+  updateDeliveredSegmentCount,
+} from "../memory/delivery-channels.js";
 import {
   clearPayload,
   linkMessage,
@@ -33,6 +37,7 @@ import {
 } from "./channel-reply-delivery.js";
 import { deliverChannelReply } from "./gateway-client.js";
 import type { MessageProcessor } from "./http-types.js";
+import { createSlackDmTextDeliveryController } from "./slack-dm-text-delivery.js";
 import { resolveRoutingStateFromRuntime } from "./trust-context-resolver.js";
 
 const log = getLogger("runtime-http");
@@ -258,6 +263,27 @@ export async function sweepFailedEvents(
       sourceMetadata.chatType.trim().length > 0
         ? sourceMetadata.chatType.trim()
         : undefined;
+    const replyCallbackUrl =
+      typeof payload.replyCallbackUrl === "string"
+        ? payload.replyCallbackUrl
+        : undefined;
+    const externalChatId =
+      typeof payload.externalChatId === "string"
+        ? payload.externalChatId
+        : undefined;
+    const slackDmTextDelivery = externalChatId
+      ? createSlackDmTextDeliveryController({
+          sourceChannel,
+          chatType: metadataChatType,
+          replyCallbackUrl,
+          chatId: externalChatId,
+          assistantId,
+          deliveredTextResponseIndexes:
+            getSlackDmLiveDeliveredTextResponseIndexes(event.id),
+          onTextResponseDelivered: (responseIndex) =>
+            addSlackDmLiveDeliveredTextResponseIndex(event.id, responseIndex),
+        })
+      : undefined;
     let replyMessageId: string | undefined;
     const observeAgentEvent = (msg: ServerMessage): void => {
       if (
@@ -267,6 +293,7 @@ export async function sweepFailedEvents(
       ) {
         replyMessageId = msg.messageId;
       }
+      slackDmTextDelivery?.observeEvent(msg);
     };
 
     let userMessageId: string | undefined;
@@ -304,26 +331,29 @@ export async function sweepFailedEvents(
       );
     } catch (err) {
       log.error({ err, eventId: event.id }, "Retry failed for channel event");
+      if (slackDmTextDelivery) {
+        await slackDmTextDelivery.waitForPendingDeliveries();
+      }
       recordProcessingFailure(event.id, err);
       continue;
     }
 
-    const replyCallbackUrl =
-      typeof payload.replyCallbackUrl === "string"
-        ? payload.replyCallbackUrl
-        : undefined;
     if (replyCallbackUrl) {
-      const externalChatId =
-        typeof payload.externalChatId === "string"
-          ? payload.externalChatId
-          : undefined;
       if (externalChatId) {
         try {
+          if (slackDmTextDelivery) {
+            await slackDmTextDelivery.waitForPendingDeliveries();
+          }
           // processMessage above generated a fresh assistant response, so any
-          // previously tracked segment progress belongs to the old response and
-          // must not carry over. Reset to 0 so we deliver all segments of the
-          // new response.
-          updateDeliveredSegmentCount(event.id, 0);
+          // previously tracked final-delivery progress belongs to the old
+          // response and must not carry over. Use live Slack DM progress as
+          // the new baseline before final delivery so delivery-only retries do
+          // not duplicate text if the callback fails before reporting progress.
+          const liveDeliveryResumeOptions =
+            slackDmTextDelivery?.getFinalDeliveryResumeOptions(replyMessageId);
+          const finalDeliveryStartFromSegment =
+            liveDeliveryResumeOptions?.startFromSegment ?? 0;
+          updateDeliveredSegmentCount(event.id, finalDeliveryStartFromSegment);
           await deliverReplyViaCallback(
             event.conversationId,
             externalChatId,
@@ -332,7 +362,10 @@ export async function sweepFailedEvents(
             {
               messageId: replyMessageId,
               sinceMessageId: userMessageId,
-              startFromSegment: 0,
+              startFromSegment: finalDeliveryStartFromSegment,
+              ...(liveDeliveryResumeOptions?.messageTs
+                ? { messageTs: liveDeliveryResumeOptions.messageTs }
+                : {}),
               onSegmentDelivered: (count) =>
                 updateDeliveredSegmentCount(event.id, count),
             },

package/src/runtime/confirmation-request-guardian-bridge.ts

@@ -12,7 +12,6 @@
  * canonical records.
  */
 
-
 import type { TrustContext } from "../daemon/trust-context.js";
 import {
   type CanonicalGuardianRequest,
@@ -150,6 +149,7 @@ export function bridgeConfirmationRequestToGuardian(
     sourceEventName: "guardian.question",
     sourceChannel: sourceChannel as NotificationSourceChannel,
     sourceContextId: conversationId,
+    requiresConversation: true,
     attentionHints: {
       requiresAction: true,
       urgency: "high",

package/src/runtime/migrations/vbundle-builder.ts

@@ -679,7 +679,8 @@ export interface BuildExportVBundleOptions {
    * Optional callback to checkpoint the WAL before reading the database file.
    * In WAL mode, committed rows may live in the -wal file and not yet be
    * flushed to the main .db file. Callers should pass a function that runs
-   * PRAGMA wal_checkpoint(TRUNCATE) on the live database connection.
+   * PRAGMA wal_checkpoint(FULL) on the live database connection. (Not
+   * TRUNCATE — see assistant/AGENTS.md "SQLite WAL checkpointing".)
    * Called before the workspace walk so the DB file is up to date.
    *
    * May return a Promise — `streamExportVBundle` awaits the result so an
@@ -1127,7 +1128,7 @@ export async function streamExportVBundle(
 
   // Flush WAL to the main database file before reading. Awaiting allows
   // the callback to dispatch the checkpoint via `runAsyncSqlite` so the
-  // daemon event loop stays responsive while SQLite truncates the WAL.
+  // daemon event loop stays responsive while SQLite flushes the WAL.
   if (checkpoint) {
     await checkpoint();
   }

package/src/runtime/routes/__tests__/bookmark-routes.test.ts

@@ -22,6 +22,7 @@ mock.module("../../assistant-event-hub.js", () => ({
     },
     subscribe: () => () => {},
   },
+  broadcastMessage: async () => {},
 }));
 
 import { getDb } from "../../../memory/db-connection.js";