@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/prompts/persona-resolver.ts

@@ -1,11 +1,14 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
+import type { GuardianDelivery } from "@vellumai/gateway-client";
+
+import { findContactByAddress } from "../contacts/contact-store.js";
 import {
-  findContactByAddress,
-  findGuardianForChannel,
-  listGuardianChannels,
-} from "../contacts/contact-store.js";
+  anyGuardian,
+  guardianForChannel,
+  peekCachedGuardianDelivery,
+} from "../contacts/guardian-delivery-reader.js";
 import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { getLogger } from "../util/logger.js";
@@ -87,8 +90,38 @@ function resolveGuardianUserFile(trustContext: TrustContext): string | null {
       return guardianContact.userFile ?? "guardian.md";
     }
   }
-  const guardian = findGuardianForChannel(trustContext.sourceChannel);
-  return guardian ? (guardian.contact.userFile ?? "guardian.md") : null;
+  const guardian = peekGuardianForChannel(trustContext.sourceChannel);
+  return guardian ? (guardianDeliveryUserFile(guardian) ?? "guardian.md") : null;
+}
+
+/**
+ * Resolve the local INFO `userFile` for a gateway guardian delivery. The
+ * gateway carries identity (channel + address) but not local INFO, so we join
+ * the local contact by the guardian's channel address. Returns `undefined` when
+ * no local contact matches.
+ */
+function guardianDeliveryUserFile(
+  guardian: GuardianDelivery,
+): string | undefined {
+  const contact = findContactByAddress(
+    guardian.channelType,
+    guardian.address,
+  );
+  return contact?.userFile ?? undefined;
+}
+
+/** Active guardian for a channel from the IO-free delivery cache. */
+function peekGuardianForChannel(
+  channelType: string,
+): GuardianDelivery | undefined {
+  const cached = peekCachedGuardianDelivery({ channelTypes: [channelType] });
+  return cached ? guardianForChannel(cached, channelType) : undefined;
+}
+
+/** First guardian across all channels from the IO-free delivery cache. */
+function peekAnyGuardian(): GuardianDelivery | undefined {
+  const cached = peekCachedGuardianDelivery();
+  return cached ? anyGuardian(cached) : undefined;
 }
 
 /**
@@ -102,12 +135,11 @@ function resolveUserFilename(
 
   try {
     if (trustContext === undefined) {
-      // Desktop / native (no gateway) — resolve via guardian contact,
-      // preferring the vellum-channel guardian when multiple exist.
-      const vellumGuardian = findGuardianForChannel("vellum");
-      const guardian = vellumGuardian ?? listGuardianChannels();
+      // Desktop / native — resolve via the gateway guardian delivery cache,
+      // preferring the vellum-channel guardian, then any guardian.
+      const guardian = peekGuardianForChannel("vellum") ?? peekAnyGuardian();
       if (guardian) {
-        filename = guardian.contact.userFile ?? "guardian.md";
+        filename = guardianDeliveryUserFile(guardian) ?? "guardian.md";
       }
     } else if (trustContext.requesterExternalUserId) {
       // Channel-routed request — look up contact by channel identity

package/src/providers/call-site-routing.ts

@@ -34,6 +34,7 @@ import {
 } from "./connection-resolution.js";
 import { listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
+import { shouldUseNativeWebSearch } from "./registry.js";
 import type {
   Message,
   Provider,
@@ -130,6 +131,46 @@ export class CallSiteRoutingProvider implements Provider {
       : doSend();
   }
 
+  /**
+   * Native web-search capability of the provider/model THIS call routes to.
+   *
+   * `selectProvider` picks the transport from the routed connection, but each
+   * leaf provider's static `supportsNativeWebSearch` was fixed to the DEFAULT
+   * (provider, model) at boot. Resolving the call-site here — same
+   * `resolveCallSiteConfig` inputs `selectProvider` uses — and recomputing
+   * `shouldUseNativeWebSearch(resolved.provider, resolved.model)` yields the
+   * capability of the routed target instead of the construction-time default.
+   *
+   * Falls back to the default provider's static flag when no `callSite` is set
+   * (the legacy short-circuit `selectProvider` also takes).
+   *
+   * Known limitation: this reports the *resolved* target's capability and does
+   * not replay `selectProvider`'s async soft-credential fallback. If the routed
+   * connection has a transient credential failure at send time, `selectProvider`
+   * falls back to the default provider while this probe still reports the routed
+   * target — so a non-native default + native routed target with a credential
+   * blip can attach `web_search` to the fallback non-native provider. The probe
+   * stays sync (the loop assembles tools synchronously) and the worst case is
+   * bounded: the advisor consult that hits it degrades benignly (the unhandled
+   * tool surfaces as a caught failure → "(advisor unavailable)"), not a crash.
+   */
+  supportsNativeWebSearchFor(options?: SendMessageOptions): boolean {
+    const callSite = options?.config?.callSite;
+    if (!callSite) {
+      return this.defaultProvider.supportsNativeWebSearch === true;
+    }
+    const resolved = resolveCallSiteConfig(callSite, getConfig().llm, {
+      overrideProfile: options?.config?.overrideProfile,
+      forceOverrideProfile: options?.config?.forceOverrideProfile,
+      selectionSeed: options?.config?.selectionSeed,
+    });
+    return shouldUseNativeWebSearch(
+      getConfig(),
+      resolved.provider,
+      resolved.model,
+    );
+  }
+
   /**
    * Pick the provider to route this call through.
    *

package/src/providers/provider-send-message.ts

@@ -58,6 +58,12 @@ export class CallSiteConfiguredProvider implements Provider {
     this.supportsNativeWebSearch = inner.supportsNativeWebSearch;
   }
 
+  supportsNativeWebSearchFor(options?: SendMessageOptions): boolean {
+    return this.inner.supportsNativeWebSearchFor
+      ? this.inner.supportsNativeWebSearchFor(options)
+      : this.inner.supportsNativeWebSearch === true;
+  }
+
   sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/providers/ratelimit.ts

@@ -27,6 +27,12 @@ export class RateLimitProvider implements Provider {
     return this.inner.supportsNativeWebSearch;
   }
 
+  supportsNativeWebSearchFor(options?: SendMessageOptions): boolean {
+    return this.inner.supportsNativeWebSearchFor
+      ? this.inner.supportsNativeWebSearchFor(options)
+      : this.inner.supportsNativeWebSearch === true;
+  }
+
   private requestTimestamps: number[];
 
   // Forward the optional token-counting endpoint so the capability survives

package/src/providers/registry.ts

@@ -118,7 +118,7 @@ export function isNativeWebSearchCapableProvider(
   return false;
 }
 
-function shouldUseNativeWebSearch(
+export function shouldUseNativeWebSearch(
   config: ProvidersConfig,
   providerName: string,
   model: string,

package/src/providers/retry.ts

@@ -622,6 +622,12 @@ export class RetryProvider implements Provider {
     return this.inner.supportsNativeWebSearch;
   }
 
+  supportsNativeWebSearchFor(options?: SendMessageOptions): boolean {
+    return this.inner.supportsNativeWebSearchFor
+      ? this.inner.supportsNativeWebSearchFor(options)
+      : this.inner.supportsNativeWebSearch === true;
+  }
+
   // Forward the optional token-counting endpoint so the capability survives
   // the wrapper chain (callers gate on its presence). Bound straight to the
   // inner provider — count_tokens is a cheap separate endpoint and its caller

package/src/providers/types.ts

@@ -274,6 +274,19 @@ export interface Provider {
    * unexecutable client tool call. Absent/false on providers without it.
    */
   supportsNativeWebSearch?: boolean;
+  /**
+   * Per-call native web-search capability for the provider/model this specific
+   * request will route to. Unlike the static {@link supportsNativeWebSearch}
+   * flag — fixed to the DEFAULT provider/model at construction — this consults
+   * the resolved call-site (`options.config.callSite` + `overrideProfile`) so a
+   * routing wrapper reports the ROUTED target's capability. Callers that gate a
+   * `web_search` server tool on a possibly-routed call (e.g. the advisor
+   * consult, whose `advisorProfile` may point at a different provider/model)
+   * must use this rather than the construction-time snapshot. Optional: wrappers
+   * forward it to their inner provider; leaf providers may omit it, in which
+   * case callers fall back to {@link supportsNativeWebSearch}.
+   */
+  supportsNativeWebSearchFor?(options?: SendMessageOptions): boolean;
   sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/providers/usage-tracking.ts

@@ -35,6 +35,12 @@ export class UsageTrackingProvider implements Provider {
     }
   }
 
+  supportsNativeWebSearchFor(options?: SendMessageOptions): boolean {
+    return this.inner.supportsNativeWebSearchFor
+      ? this.inner.supportsNativeWebSearchFor(options)
+      : this.inner.supportsNativeWebSearch === true;
+  }
+
   async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/runtime/__tests__/guardian-vellum-migration.test.ts

@@ -3,11 +3,13 @@
  * `reResolveTrustOnResetDrift`.
  *
  * The real helper runs against mocked leaf deps: the gateway guardian read
- * (`getGuardianDelivery`/`guardianForChannel`), the local-mirror heal
- * (`findGuardianForChannel`/`updateContactPrincipalAndChannel`, which the real
- * `healGuardianBindingDrift` drives), and the local trust resolver
- * (`resolveTrustContext`). Heal invocations are observed via the contact-store
- * write mock.
+ * (`getGuardianDelivery`/`guardianForChannel`) supplies the authoritative
+ * principal, the local-mirror heal target is resolved via
+ * `findContactByAddress` (keyed on the gateway guardian's channel address) and
+ * written via `updateContactPrincipalAndChannel` (the real
+ * `healGuardianBindingDrift` drives this), and the local trust resolver
+ * (`resolveTrustContext`) closes the loop. Heal invocations are observed via
+ * the contact-store write mock.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -26,16 +28,17 @@ mock.module("../../contacts/guardian-delivery-reader.js", () => ({
   ) => list.find((g) => g.channelType === channelType && g.status === "active"),
 }));
 
-// Local mirror the real heal reads/writes. `findGuardianForChannel` returns the
-// stored guardian; `updateContactPrincipalAndChannel` records heal writes.
-let mockLocalGuardian: {
-  contact: { id: string; principalId: string };
-  channel: { id: string };
+// Local mirror the real heal repairs. `findContactByAddress` returns the local
+// contact (with its vellum channel) the heal writes to;
+// `updateContactPrincipalAndChannel` records heal writes.
+let mockLocalContact: {
+  id: string;
+  channels: Array<{ id: string; type: string }>;
 } | null = null;
 const healWrites: Array<{ principalId: string }> = [];
 
 mock.module("../../contacts/contact-store.js", () => ({
-  findGuardianForChannel: () => mockLocalGuardian,
+  findContactByAddress: () => mockLocalContact,
   updateContactPrincipalAndChannel: (
     _contactId: string,
     _channelId: string,
@@ -74,25 +77,25 @@ function gatewayGuardian(principalId: string): Record<string, unknown> {
   };
 }
 
-function localGuardian(principalId: string) {
+function localGuardian() {
   return {
-    contact: { id: "contact-1", principalId },
-    channel: { id: "channel-1" },
+    id: "contact-1",
+    channels: [{ id: "channel-1", type: "vellum" }],
   };
 }
 
 describe("reResolveTrustOnResetDrift", () => {
   beforeEach(() => {
     mockGuardianList = [];
-    mockLocalGuardian = null;
+    mockLocalContact = null;
     healWrites.length = 0;
   });
 
   test("reset drift: heals and returns the re-resolved guardian ctx", async () => {
-    // Stale local mirror still holds the pre-reset principal; the incoming JWT
-    // carries the old one. Heal repairs the mirror toward the incoming actor.
+    // Gateway principal diverges from the incoming JWT; heal repairs the local
+    // mirror toward the incoming actor.
     mockGuardianList = [gatewayGuardian("vellum-principal-new")];
-    mockLocalGuardian = localGuardian("vellum-principal-stale");
+    mockLocalContact = localGuardian();
 
     const ctx = await reResolveTrustOnResetDrift(
       "vellum-principal-old",
@@ -103,11 +106,11 @@ describe("reResolveTrustOnResetDrift", () => {
     expect(healWrites).toEqual([{ principalId: "vellum-principal-old" }]);
   });
 
-  test("repeat drift where heal no-ops still returns the guardian ctx", async () => {
-    // Local mirror already matches the incoming principal, so heal's write is
-    // skipped, but the gate still passes and the re-resolve yields guardian.
+  test("no local mirror to repair still returns the guardian ctx", async () => {
+    // The gate passes and the re-resolve yields guardian even when there is no
+    // local mirror row for heal to write.
     mockGuardianList = [gatewayGuardian("vellum-principal-new")];
-    mockLocalGuardian = localGuardian("vellum-principal-old");
+    mockLocalContact = null;
 
     const ctx = await reResolveTrustOnResetDrift(
       "vellum-principal-old",
@@ -120,7 +123,7 @@ describe("reResolveTrustOnResetDrift", () => {
 
   test("gateway unreachable (null): returns null, heal not called", async () => {
     mockGuardianList = null;
-    mockLocalGuardian = localGuardian("vellum-principal-old");
+    mockLocalContact = localGuardian();
 
     const ctx = await reResolveTrustOnResetDrift(
       "vellum-principal-old",
@@ -133,7 +136,7 @@ describe("reResolveTrustOnResetDrift", () => {
 
   test("empty/revoked gateway (no active guardian): returns null, heal not called", async () => {
     mockGuardianList = [];
-    mockLocalGuardian = localGuardian("vellum-principal-old");
+    mockLocalContact = localGuardian();
 
     const ctx = await reResolveTrustOnResetDrift(
       "vellum-principal-old",
@@ -146,7 +149,7 @@ describe("reResolveTrustOnResetDrift", () => {
 
   test("gateway guardian is a real (non vellum-principal-*) id: returns null", async () => {
     mockGuardianList = [gatewayGuardian("user@example.com")];
-    mockLocalGuardian = localGuardian("vellum-principal-old");
+    mockLocalContact = localGuardian();
 
     const ctx = await reResolveTrustOnResetDrift(
       "vellum-principal-old",
@@ -159,7 +162,7 @@ describe("reResolveTrustOnResetDrift", () => {
 
   test("incoming principal is not vellum-principal-*: returns null", async () => {
     mockGuardianList = [gatewayGuardian("vellum-principal-new")];
-    mockLocalGuardian = localGuardian("vellum-principal-old");
+    mockLocalContact = localGuardian();
 
     const ctx = await reResolveTrustOnResetDrift("user@example.com", "vellum");
 
@@ -169,7 +172,7 @@ describe("reResolveTrustOnResetDrift", () => {
 
   test("threads sourceChannel into the returned ctx", async () => {
     mockGuardianList = [gatewayGuardian("vellum-principal-new")];
-    mockLocalGuardian = localGuardian("vellum-principal-old");
+    mockLocalContact = localGuardian();
 
     const ctx = await reResolveTrustOnResetDrift(
       "vellum-principal-old",

package/src/runtime/__tests__/local-principal-trust.test.ts

@@ -6,20 +6,28 @@ import type { ChannelId } from "../../channels/types.js";
 // unreachable), [] = authoritatively no guardian, one active entry = bound.
 let mockGuardianList: Array<Record<string, unknown>> | null = [];
 
+// Both the async path (resolveLocalPrincipalTrustContext) and the sync
+// resolveActorTrust read the same gateway delivery list — async via
+// getGuardianDelivery, sync via the peek snapshot.
 mock.module("../../contacts/guardian-delivery-reader.js", () => ({
   getGuardianDelivery: (_input?: { channelTypes?: string[] }) =>
     Promise.resolve(mockGuardianList),
+  peekCachedGuardianDelivery: (input?: { channelTypes?: string[] }) => {
+    if (mockGuardianList == null) return undefined;
+    if (!input?.channelTypes) return mockGuardianList;
+    return mockGuardianList.filter((g) =>
+      input.channelTypes!.includes(g.channelType as string),
+    );
+  },
+  guardianForChannel: (
+    list: Array<Record<string, unknown>>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
 }));
 
-// Local-resolver guardian binding, used to construct the expected guardian
-// TrustContext via the existing resolver and prove equivalence.
-let mockGuardianRecord: {
-  contact: Record<string, unknown>;
-  channel: Record<string, unknown>;
-} | null = null;
-
+// Member ACL rides on memberRecord, sourced from the member-verdict cache; this
+// suite only exercises the gateway-guardian path, so no member resolves.
 mock.module("../../contacts/contact-store.js", () => ({
-  findGuardianForChannel: (_channelType: string) => mockGuardianRecord,
   findContactByAddress: (_channelType: string, _address: string) => null,
 }));
 
@@ -39,7 +47,6 @@ const GUARDIAN_CHAT_ID = "guardian-chat";
 describe("resolveLocalPrincipalTrustContext", () => {
   beforeEach(() => {
     mockGuardianList = [];
-    mockGuardianRecord = null;
   });
 
   test("principal matching the gateway guardian → guardian ctx", async () => {
@@ -83,15 +90,6 @@ describe("resolveLocalPrincipalTrustContext", () => {
         status: "active",
       },
     ];
-    mockGuardianRecord = {
-      contact: { id: "contact-1", principalId: GUARDIAN_ADDRESS },
-      channel: {
-        type: "vellum",
-        address: GUARDIAN_ADDRESS,
-        externalChatId: GUARDIAN_CHAT_ID,
-        status: "active",
-      },
-    };
 
     const expected = toTrustContext(
       resolveActorTrust({

package/src/runtime/__tests__/member-verdict-cache.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Unit tests for the in-memory member-verdict cache: set→get round-trip, TTL
+ * expiry, memberless verdicts not cached, and max-size eviction.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { TrustVerdict } from "@vellumai/gateway-client";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+import {
+  __resetMemberVerdictCacheForTest,
+  getCachedMemberAcl,
+  setMemberVerdict,
+} from "../member-verdict-cache.js";
+
+const PHONE = "+15559871234";
+
+function memberVerdict(
+  overrides: Partial<TrustVerdict> = {},
+): TrustVerdict {
+  return {
+    trustClass: "trusted_contact",
+    canonicalSenderId: PHONE,
+    contactId: "contact-1",
+    channelId: "ch-1",
+    status: "active",
+    policy: "allow",
+    ...overrides,
+  };
+}
+
+const realNow = Date.now;
+
+describe("member-verdict-cache", () => {
+  beforeEach(() => {
+    __resetMemberVerdictCacheForTest();
+  });
+
+  afterEach(() => {
+    Date.now = realNow;
+  });
+
+  test("set then get returns the derived ACL view", () => {
+    setMemberVerdict("phone", PHONE, memberVerdict());
+    expect(getCachedMemberAcl("phone", PHONE)).toEqual({
+      status: "active",
+      policy: "allow",
+      role: "contact",
+    });
+  });
+
+  test("guardian trustClass derives the guardian role", () => {
+    setMemberVerdict("phone", PHONE, memberVerdict({ trustClass: "guardian" }));
+    expect(getCachedMemberAcl("phone", PHONE)?.role).toBe("guardian");
+  });
+
+  test("read canonicalizes the actor id like the write", () => {
+    // Phone numbers normalize to E.164; a raw-format write is readable by the
+    // same raw-format read.
+    setMemberVerdict("phone", "(555) 987-1234", memberVerdict());
+    expect(getCachedMemberAcl("phone", "(555) 987-1234")).toBeDefined();
+  });
+
+  test("empty actor id is a no-op on set and get", () => {
+    setMemberVerdict("phone", undefined, memberVerdict());
+    expect(getCachedMemberAcl("phone", undefined)).toBeUndefined();
+    expect(getCachedMemberAcl("phone", "   ")).toBeUndefined();
+  });
+
+  test("memberless verdict is not cached", () => {
+    setMemberVerdict(
+      "phone",
+      PHONE,
+      memberVerdict({ contactId: undefined, channelId: undefined }),
+    );
+    expect(getCachedMemberAcl("phone", PHONE)).toBeUndefined();
+  });
+
+  test("memberless verdict clears a stale active entry for the actor", () => {
+    setMemberVerdict("phone", PHONE, memberVerdict());
+    expect(getCachedMemberAcl("phone", PHONE)).toBeDefined();
+    // A later memberless verdict (deleted contact / stranger) must invalidate
+    // the stale active ACL, not leave it readable for the rest of the TTL.
+    setMemberVerdict(
+      "phone",
+      PHONE,
+      memberVerdict({ contactId: undefined, channelId: undefined }),
+    );
+    expect(getCachedMemberAcl("phone", PHONE)).toBeUndefined();
+  });
+
+  test("expired entry returns undefined", () => {
+    const t0 = realNow();
+    Date.now = () => t0;
+    setMemberVerdict("phone", PHONE, memberVerdict());
+    Date.now = () => t0 + 300_001;
+    expect(getCachedMemberAcl("phone", PHONE)).toBeUndefined();
+  });
+
+  test("evicts the oldest-expiring entry past the bound", () => {
+    const t0 = realNow();
+    // telegram IDs pass through unchanged, so each key is distinct. Fill past
+    // capacity with monotonically increasing expiry stamps.
+    for (let i = 0; i < 2001; i++) {
+      Date.now = () => t0 + i;
+      setMemberVerdict("telegram", `tg-${i}`, memberVerdict());
+    }
+    Date.now = () => t0 + 2001;
+    // The oldest-expiring entry is evicted on the over-capacity insert; the
+    // latest survives.
+    expect(getCachedMemberAcl("telegram", "tg-0")).toBeUndefined();
+    expect(getCachedMemberAcl("telegram", "tg-2000")).toBeDefined();
+  });
+});