@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/notifications/__tests__/decision-engine.test.ts

@@ -34,38 +34,19 @@ mock.module("../../prompts/system-prompt.js", () => ({
   buildCoreIdentityContext: () => null,
 }));
 
-// Guardian binding (ACL) is resolved via the gateway pull; notes (INFO) are
-// joined locally by contactId. Tests drive both via mutable slots.
-let guardianDeliveryFixture: Array<{ contactId: string }> = [];
-let contactInfoFixture: Record<string, { notes: string | null } | null> = {};
-
-mock.module("../../contacts/guardian-delivery-reader.js", () => ({
-  getGuardianDelivery: async () => guardianDeliveryFixture,
-  anyGuardian: (list: Array<{ contactId: string }>) => list[0],
-}));
-
 mock.module("../../contacts/contact-store.js", () => ({
-  findContactInfoById: (contactId: string) =>
-    contactInfoFixture[contactId] ?? null,
+  listGuardianChannels: () => null,
 }));
 
-// Provider mock. By default `sendMessage` throws so the assistant_tool
-// pass-through path (which must skip the LLM) fails loudly if it reaches the
-// provider. LLM-path tests override `providerSendMessage` to capture inputs.
-let providerSendMessage: (
-  messages: unknown[],
-  opts: { systemPrompt?: string },
-) => Promise<unknown> = () => {
-  throw new Error(
-    "provider.sendMessage should NOT be invoked for assistant_tool pass-through",
-  );
-};
-
+// Provider mock — if `getConfiguredProvider` is ever called by the
+// assistant_tool pass-through path, this throw makes the test fail
+// loudly instead of silently exercising the LLM path.
 mock.module("../../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: async () => ({
-    sendMessage: (messages: unknown[], opts: { systemPrompt?: string }) =>
-      providerSendMessage(messages, opts),
-  }),
+  getConfiguredProvider: async () => {
+    throw new Error(
+      "getConfiguredProvider should NOT be invoked for assistant_tool pass-through",
+    );
+  },
   createTimeout: () => ({
     signal: new AbortController().signal,
     cleanup: () => {},
@@ -300,53 +281,3 @@ describe("assistant_tool pass-through in notification decision engine", () => {
     expect(decision.renderedCopy.vellum?.body).toBe("fyi");
   });
 });
-
-describe("recipient notes injection (ACL from gateway, notes joined locally)", () => {
-  function makeLlmSignal(): NotificationSignal {
-    return {
-      signalId: "sig-llm-notes-1",
-      createdAt: Date.now(),
-      sourceChannel: "scheduler",
-      sourceContextId: "schedule-1",
-      sourceEventName: "schedule.notify",
-      contextPayload: {},
-      attentionHints: {
-        requiresAction: false,
-        urgency: "low",
-        isAsyncBackground: false,
-        visibleInSourceNow: false,
-      },
-    };
-  }
-
-  test("injects the guardian's local notes, resolved via the gateway contactId", async () => {
-    guardianDeliveryFixture = [{ contactId: "contact-42" }];
-    contactInfoFixture = { "contact-42": { notes: "Prefers terse updates." } };
-
-    let capturedSystemPrompt: string | undefined;
-    providerSendMessage = async (_messages, opts) => {
-      capturedSystemPrompt = opts.systemPrompt;
-      return {};
-    };
-
-    await evaluateSignal(makeLlmSignal(), ["vellum"] as NotificationChannel[]);
-
-    expect(capturedSystemPrompt).toContain("<recipient-context>");
-    expect(capturedSystemPrompt).toContain("Prefers terse updates.");
-  });
-
-  test("omits recipient context when no guardian is bound", async () => {
-    guardianDeliveryFixture = [];
-    contactInfoFixture = {};
-
-    let capturedSystemPrompt: string | undefined;
-    providerSendMessage = async (_messages, opts) => {
-      capturedSystemPrompt = opts.systemPrompt;
-      return {};
-    };
-
-    await evaluateSignal(makeLlmSignal(), ["vellum"] as NotificationChannel[]);
-
-    expect(capturedSystemPrompt).not.toContain("<recipient-context>");
-  });
-});

package/src/notifications/broadcaster.ts

@@ -11,7 +11,6 @@
 
 import { v4 as uuid } from "uuid";
 
-import { getGuardianDelivery } from "../contacts/guardian-delivery-reader.js";
 import { getConversation } from "../memory/conversation-crud.js";
 import type { ApprovalUIMetadata } from "../runtime/channel-approval-types.js";
 import { getLogger } from "../util/logger.js";
@@ -172,13 +171,7 @@ export class NotificationBroadcaster {
     decision: NotificationDecision,
     options?: BroadcastDecisionOptions,
   ): Promise<NotificationDeliveryResult[]> {
-    // Pull the guardian list once so the resolver stays pure. A null list
-    // (gateway unreachable) falls back to the local contacts read.
-    const guardians = await getGuardianDelivery();
-    const destinations = resolveDestinations(
-      decision.selectedChannels,
-      guardians,
-    );
+    const destinations = resolveDestinations(decision.selectedChannels);
 
     // Ensure vellum is processed first so the notification_conversation_created
     // event fires immediately, before slower channel sends (e.g. Telegram 30s

package/src/notifications/decision-engine.ts

@@ -12,11 +12,7 @@
 import { v4 as uuid } from "uuid";
 
 import { getDeliverableChannels } from "../channels/config.js";
-import { findContactInfoById } from "../contacts/contact-store.js";
-import {
-  anyGuardian,
-  getGuardianDelivery,
-} from "../contacts/guardian-delivery-reader.js";
+import { listGuardianChannels } from "../contacts/contact-store.js";
 import { buildCoreIdentityContext } from "../prompts/system-prompt.js";
 import {
   createTimeout,
@@ -967,19 +963,15 @@ async function classifyWithLLM(
     ? truncate(rawIdentityContext, MAX_IDENTITY_CONTEXT_CHARS, "\n…[truncated]")
     : undefined;
 
-  // Resolve guardian contact notes for recipient context. The guardian's
-  // identity (ACL) comes from the gateway pull, channel-agnostic so notes are
-  // available even when the only deliverable channel is "vellum". Notes (INFO)
-  // stay local and are joined by contactId.
+  // Resolve guardian contact notes for recipient context. Use the channel-
+  // agnostic guardian lookup so notes are available even when the only
+  // deliverable channel is "vellum" (which has no contact channel type).
   let recipientNotes: string | undefined;
   try {
-    const guardian = anyGuardian((await getGuardianDelivery()) ?? []);
-    const notes = guardian
-      ? findContactInfoById(guardian.contactId)?.notes
-      : undefined;
-    if (notes) {
+    const guardianResult = listGuardianChannels();
+    if (guardianResult?.contact.notes) {
       recipientNotes = truncate(
-        notes,
+        guardianResult.contact.notes,
         MAX_IDENTITY_CONTEXT_CHARS,
         "\n…[truncated]",
       );

package/src/notifications/destination-resolver.ts

@@ -1,7 +1,7 @@
 /**
  * Resolves per-channel destination endpoints for notification delivery.
  *
- * Reads guardian delivery info from the gateway-backed guardian list.
+ * Reads guardian delivery info from the contacts table.
  *
  * - Vellum: no external endpoint needed — delivery goes through the event
  *   broadcast mechanism to connected desktop/mobile clients. The
@@ -11,54 +11,14 @@
  *   sourced from the guardian contact's channel record.
  */
 
-import type { GuardianDelivery } from "@vellumai/gateway-client";
-
 import { isNotificationDeliverable } from "../channels/config.js";
 import type { ChannelId } from "../channels/types.js";
 import { findGuardianForChannel } from "../contacts/contact-store.js";
-import { guardianForChannel } from "../contacts/guardian-delivery-reader.js";
 import { getLogger } from "../util/logger.js";
 import type { ChannelDestination, NotificationChannel } from "./types.js";
 
 const log = getLogger("destination-resolver");
 
-/** Guardian delivery endpoint for a channel, flattened from either source. */
-interface ResolvedGuardian {
-  principalId?: string;
-  address: string;
-  externalChatId?: string;
-}
-
-/**
- * Resolve the guardian delivery endpoint for a channel: gateway list first,
- * else the local contacts read. The local read is the transitional
- * dual-written mirror and covers a transient gateway failure (null list) or a
- * gateway list missing this channel, so a soft-failed gateway read does not
- * drop a binding the local store still holds. Removed in Combo 11.
- */
-function resolveGuardian(
-  guardians: GuardianDelivery[] | null,
-  channelType: string,
-): ResolvedGuardian | undefined {
-  const g = guardians
-    ? guardianForChannel(guardians, channelType)
-    : undefined;
-  if (g) {
-    return {
-      principalId: g.principalId ?? undefined,
-      address: g.address,
-      externalChatId: g.externalChatId ?? undefined,
-    };
-  }
-  const local = findGuardianForChannel(channelType);
-  if (!local) return undefined;
-  return {
-    principalId: local.contact.principalId ?? undefined,
-    address: local.channel.address,
-    externalChatId: local.channel.externalChatId ?? undefined,
-  };
-}
-
 /**
  * Resolve destination information for each requested channel.
  *
@@ -66,14 +26,9 @@ function resolveGuardian(
  * the function skips non-deliverable channels via `isNotificationDeliverable`.
  * Returns a map keyed by `NotificationChannel`. Channels that cannot be
  * resolved (e.g. no Telegram binding configured) are omitted from the result.
- *
- * `guardians` is the gateway-resolved guardian list; per channel, a missing
- * match (null list or no entry for the channel) falls back to the local
- * contacts read for this release.
  */
 export function resolveDestinations(
   channels: readonly (ChannelId | NotificationChannel)[],
-  guardians: GuardianDelivery[] | null,
 ): Map<NotificationChannel, ChannelDestination> {
   const result = new Map<NotificationChannel, ChannelDestination>();
 
@@ -88,10 +43,10 @@ export function resolveDestinations(
         // Vellum delivery is local — no external endpoint required.
         // Include the guardianPrincipalId so the adapter can annotate
         // guardian-sensitive notifications for scoped delivery.
-        const guardian = resolveGuardian(guardians, "vellum");
+        const guardianResult = findGuardianForChannel("vellum");
         const metadata: Record<string, unknown> = {};
-        if (guardian?.principalId) {
-          metadata.guardianPrincipalId = guardian.principalId;
+        if (guardianResult) {
+          metadata.guardianPrincipalId = guardianResult.contact.principalId;
         }
         result.set("vellum", {
           channel: "vellum",
@@ -100,7 +55,7 @@ export function resolveDestinations(
         log.debug(
           {
             channel: "vellum",
-            source: "guardian-delivery",
+            source: "contacts",
             hasEndpoint: false,
           },
           "destination resolved",
@@ -108,52 +63,52 @@ export function resolveDestinations(
         break;
       }
       case "telegram": {
-        const guardian = resolveGuardian(guardians, channel);
-        if (guardian?.externalChatId) {
-          const externalChatId = guardian.externalChatId;
+        const guardianResult = findGuardianForChannel(channel);
+        if (guardianResult && guardianResult.channel.externalChatId) {
+          const externalChatId = guardianResult.channel.externalChatId;
           result.set(channel as NotificationChannel, {
             channel: channel as NotificationChannel,
             endpoint: externalChatId,
             metadata: {
-              externalUserId: guardian.address,
+              externalUserId: guardianResult.channel.address,
             },
             bindingContext: {
               sourceChannel: channel as NotificationChannel,
               externalChatId,
-              externalUserId: guardian.address,
+              externalUserId: guardianResult.channel.address,
             },
           });
         }
         log.debug(
           {
             channel,
-            source: "guardian-delivery",
-            hasEndpoint: !!guardian?.externalChatId,
+            source: "contacts",
+            hasEndpoint: !!guardianResult?.channel.externalChatId,
           },
           "destination resolved",
         );
         break;
       }
       case "slack": {
-        const guardian = resolveGuardian(guardians, "slack");
-        const chatId = guardian?.externalChatId;
+        const guardianResult = findGuardianForChannel("slack");
+        const chatId = guardianResult?.channel.externalChatId;
         // Slack bindings can originate from app_mention in shared channels.
         // Only route notifications to DM channels (IDs starting with "D")
         // to prevent leaking notifications into shared workspaces.
-        if (guardian && chatId && isSlackDmChannel(chatId)) {
+        if (guardianResult && chatId && isSlackDmChannel(chatId)) {
           result.set("slack", {
             channel: "slack",
             endpoint: chatId,
             metadata: {
-              externalUserId: guardian.address,
+              externalUserId: guardianResult.channel.address,
             },
             bindingContext: {
               sourceChannel: "slack",
               externalChatId: chatId,
-              externalUserId: guardian.address,
+              externalUserId: guardianResult.channel.address,
             },
           });
-        } else if (guardian && chatId) {
+        } else if (guardianResult && chatId) {
           log.warn(
             { channel: "slack", chatId },
             "skipping non-DM Slack channel for notification delivery",
@@ -162,7 +117,7 @@ export function resolveDestinations(
         log.debug(
           {
             channel: "slack",
-            source: "guardian-delivery",
+            source: "contacts",
             hasEndpoint: !!(chatId && isSlackDmChannel(chatId)),
           },
           "destination resolved",
@@ -173,10 +128,11 @@ export function resolveDestinations(
         // Platform delivery goes through the daemon's VellumPlatformClient —
         // no external binding needed. Include guardianPrincipalId so the
         // adapter can scope guardian-sensitive notifications.
-        const platformGuardian = resolveGuardian(guardians, "vellum");
+        const platformGuardian = findGuardianForChannel("vellum");
         const platformMeta: Record<string, unknown> = {};
-        if (platformGuardian?.principalId) {
-          platformMeta.guardianPrincipalId = platformGuardian.principalId;
+        if (platformGuardian) {
+          platformMeta.guardianPrincipalId =
+            platformGuardian.contact.principalId;
         }
         result.set("platform", {
           channel: "platform",
@@ -184,7 +140,7 @@ export function resolveDestinations(
             Object.keys(platformMeta).length > 0 ? platformMeta : undefined,
         });
         log.debug(
-          { channel: "platform", source: "guardian-delivery", hasEndpoint: false },
+          { channel: "platform", source: "contacts", hasEndpoint: false },
           "destination resolved",
         );
         break;

package/src/notifications/emit-signal.ts

@@ -9,15 +9,10 @@
  * propagated unless `throwOnError` is enabled.
  */
 
-import type { GuardianDelivery } from "@vellumai/gateway-client";
 import { v4 as uuid } from "uuid";
 
 import { getDeliverableChannels } from "../channels/config.js";
 import { findGuardianForChannel } from "../contacts/contact-store.js";
-import {
-  getGuardianDelivery,
-  guardianForChannel,
-} from "../contacts/guardian-delivery-reader.js";
 import type { ConversationCreateType } from "../memory/conversation-crud.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
@@ -94,33 +89,9 @@ export function getBroadcaster(): NotificationBroadcaster {
 
 // ── Connected channels resolution ──────────────────────────────────────
 
-/**
- * Resolve a binding-based channel's delivery endpoint (externalChatId) the
- * SAME way destination-resolver's `resolveGuardian` does: gateway match first,
- * falling back to the LOCAL contacts read on ANY per-channel no-match — gateway
- * list null (unreachable) OR no active gateway entry for this channel. The
- * local read is the transitional dual-written mirror, removed in Combo 11.
- * Keeping connectivity aligned with delivery prevents a channel being marked
- * connected but then skipped with no destination (or vice-versa).
- */
-function resolveChannelChatId(
-  guardians: GuardianDelivery[] | null,
-  channelType: string,
-): string | undefined {
-  const g = guardians ? guardianForChannel(guardians, channelType) : undefined;
-  if (g) {
-    return g.externalChatId ?? undefined;
-  }
-  return findGuardianForChannel(channelType)?.channel.externalChatId ?? undefined;
-}
-
-export async function getConnectedChannels(): Promise<NotificationChannel[]> {
+function getConnectedChannels(): NotificationChannel[] {
   const channels: NotificationChannel[] = [];
 
-  // Guardian bindings (ACL) come from the gateway pull; null ⇒ gateway
-  // unreachable, so binding-based connectivity falls back to the local read.
-  const guardians = await getGuardianDelivery();
-
   // getDeliverableChannels() returns ChannelId[] but every returned channel
   // has deliveryEnabled: true, making it a valid NotificationChannel at
   // runtime. We iterate over the broad type and narrow via the switch.
@@ -139,20 +110,24 @@ export async function getConnectedChannels(): Promise<NotificationChannel[]> {
         channels.push(channel);
         break;
       case "telegram": {
-        // Connected when the resolved guardian has a delivery endpoint —
-        // mirroring destination-resolver so we never mark connected what
-        // can't be delivered.
-        if (resolveChannelChatId(guardians, channel)) {
+        // A binding-based channel is connected when the guardian has an
+        // active channel entry with a valid delivery endpoint. The
+        // externalChatId check ensures we don't report a channel as
+        // connected when the contacts record exists but lacks the
+        // delivery address the destination-resolver needs.
+        const guardian = findGuardianForChannel(channel);
+        if (guardian && guardian.channel.externalChatId) {
           channels.push(channel);
         }
         break;
       }
       case "slack": {
         // Slack bindings can originate from shared channels (app_mention).
-        // Only consider Slack connected when the resolved chat ID is a DM
-        // channel (D-prefixed), matching destination-resolver's DM gate.
-        const chatId = resolveChannelChatId(guardians, "slack");
-        if (chatId && chatId.startsWith("D")) {
+        // Only consider Slack connected when the stored chat ID is a DM
+        // channel (D-prefixed) to prevent leaking notifications.
+        const slackGuardian = findGuardianForChannel("slack");
+        const chatId = slackGuardian?.channel.externalChatId;
+        if (slackGuardian && chatId && chatId.startsWith("D")) {
           channels.push(channel);
         }
         break;
@@ -315,7 +290,7 @@ export async function emitNotificationSignal<TEventName extends string>(
     }
 
     // Step 2: Evaluate the signal through the decision engine
-    const connectedChannels = await getConnectedChannels();
+    const connectedChannels = getConnectedChannels();
 
     log.debug(
       {

package/src/permissions/question-prompter.test.ts

@@ -9,7 +9,7 @@ import type {
 
 // Use a tiny timeout so the setTimeout branch fires quickly in tests
 const mockConfig = {
-  timeouts: { questionResponseTimeoutSec: 0.05 },
+  timeouts: { permissionTimeoutSec: 0.05 },
 };
 // Preserve every other export from the real config/loader so other
 // tests in the same `bun test` run (which share module-level mocks)

package/src/permissions/question-prompter.ts

@@ -156,12 +156,9 @@ export interface QuestionBatchMetadata {
  * the whole batch to `/v1/question-response` when the user is done — no
  * per-question accumulator, no partial state machine.
  *
- * The idle timeout is a backstop (`getConfig().timeouts.questionResponseTimeoutSec`,
- * default 30 min), not the primary way a prompt is dismissed. An interactive
- * user who moves on instead of answering enqueues another message, which
- * supersedes the open prompt at the enqueue handler (see conversation-routes.ts);
- * a non-interactive turn resolves immediately at the tool. The backstop only
- * fires when a prompt is left open with no response and no follow-up message.
+ * Timeout reuses `getConfig().timeouts.permissionTimeoutSec` (default 5 min) —
+ * questions are user-prompts in the same UX family as permission prompts and
+ * secret prompts, so they share the same idle-timeout knob.
  */
 export class QuestionPrompter {
   async prompt(params: QuestionPromptParams): Promise<QuestionPromptResult> {
@@ -202,7 +199,7 @@ export class QuestionPrompter {
     const requestId = uuid();
 
     return new Promise<QuestionPromptResult>((resolve, reject) => {
-      const timeoutMs = getConfig().timeouts.questionResponseTimeoutSec * 1000;
+      const timeoutMs = getConfig().timeouts.permissionTimeoutSec * 1000;
 
       // Closure-scoped idempotency guard. Every resolution path (timeout,
       // abort, route resolution via `rpcResolve`/`rpcReject`) routes through

package/src/plugin-api/index.ts

@@ -130,12 +130,12 @@ export type {
 } from "../runtime/assistant-event-hub.js";
 export { assistantEventHub } from "../runtime/assistant-event-hub.js";
 export { getModelProfiles } from "./model-profiles.js";
-// Check whether a model or profile can process image input. Accepts a concrete
-// model id, a profile key, or a `ModelProfileInfo`; a bare string is resolved
-// as a model id first and then as a profile key. Profile resolution merges over
-// the workspace default and infers the provider for model-only profiles, then
-// looks up the model catalog's `supportsVision` flag (mix profiles are
-// vision-capable if any arm is). Returns false when nothing resolves.
+// Check whether a profile's resolved model can process image input. Resolves
+// the effective (provider, model) by merging over the workspace default and
+// inferring the provider for model-only profiles, then looks up the model
+// catalog's `supportsVision` flag. Handles mix profiles (true if any arm
+// supports vision). Fail-open for unknown models. Pair with
+// `getModelProfiles()` to inspect the active or candidate profiles.
 export { doesSupportVision } from "./vision-support.js";
 // Resolve a provider for a call site (optionally overriding the profile) so a
 // plugin can run inference through the workspace's configured profiles and

package/src/plugin-api/types.ts

@@ -72,13 +72,15 @@ export type PluginHookFn<TCtx = unknown> = (
 // ─── Init context ────────────────────────────────────────────────────────────
 
 /**
- * Context passed to `Plugin.init()` during bootstrap. Carries the resolved
- * config, a pino-compatible logger scoped to the plugin, a per-plugin
- * writable data directory, and the assistant's version metadata.
+ * Context passed to `Plugin.init()` during bootstrap. Carries resolved
+ * config/credentials, a pino-compatible logger scoped to the plugin, a
+ * per-plugin writable data directory, and the assistant's version metadata.
  */
 export interface PluginInitContext {
   /** Parsed config for this plugin (may be `unknown` until the manifest validates). */
   config: unknown;
+  /** Resolved credential values keyed by the entries of `manifest.requiresCredential`. */
+  credentials: Record<string, string>;
   /** Pino-compatible child logger bound to `{ plugin: <name> }`. */
   logger: PluginLogger;
   /** Absolute path to `<workspaceDir>/plugins-data/<plugin>/` (created by bootstrap). */

package/src/plugin-api/vision-support.test.ts

@@ -84,16 +84,16 @@ describe("doesSupportVision", () => {
     expect(doesSupportVision(profile("text-profile"))).toBe(false);
   });
 
-  test("returns false for an unknown profile key not in config", () => {
+  test("fails open (true) for an unknown profile key not in config", () => {
     setMockConfig({});
-    expect(doesSupportVision(profile("nonexistent"))).toBe(false);
+    expect(doesSupportVision(profile("nonexistent"))).toBe(true);
   });
 
-  test("returns false for an unknown provider/model pair", () => {
+  test("fails open (true) for an unknown provider/model pair", () => {
     setMockConfig({
       "unknown-model": { provider: "unknown-provider", model: "unknown-model" },
     });
-    expect(doesSupportVision(profile("unknown-model"))).toBe(false);
+    expect(doesSupportVision(profile("unknown-model"))).toBe(true);
   });
 
   test("inherits provider from llm.default when profile only sets model", () => {
@@ -147,27 +147,3 @@ describe("doesSupportVision", () => {
     expect(doesSupportVision(profile("mix-profile"))).toBe(false);
   });
 });
-
-describe("doesSupportVision with a bare string", () => {
-  test("returns true for a known vision-capable model id", () => {
-    expect(doesSupportVision("claude-opus-4-6")).toBe(true);
-  });
-
-  test("returns false for a known text-only model id", () => {
-    expect(doesSupportVision("accounts/fireworks/models/glm-5p2")).toBe(false);
-  });
-
-  test("falls back to resolving the string as a profile key", () => {
-    // "vision-profile" is not a catalog model id, so it resolves as a profile
-    // key → anthropic/claude-opus-4-6 (vision-capable).
-    setMockConfig({
-      "vision-profile": { provider: "anthropic", model: "claude-opus-4-6" },
-    });
-    expect(doesSupportVision("vision-profile")).toBe(true);
-  });
-
-  test("returns false for a string that is neither a model nor a profile", () => {
-    setMockConfig({});
-    expect(doesSupportVision("some-unknown-string")).toBe(false);
-  });
-});