@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

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

@@ -43,6 +43,9 @@ import type {
 
 export class CallSiteRoutingProvider implements Provider {
   public readonly tokenEstimationProvider?: string;
+  // Forward native web-search capability so it survives the wrapper chain
+  // (callers like the advisor consult gate on it). Fixed at construction.
+  public readonly supportsNativeWebSearch?: boolean;
 
   // Per-call async context that tracks which provider is currently executing.
   // Using AsyncLocalStorage instead of a plain instance field means concurrent
@@ -94,6 +97,7 @@ export class CallSiteRoutingProvider implements Provider {
     ) => Promise<Provider | null>,
   ) {
     this.tokenEstimationProvider = defaultProvider.tokenEstimationProvider;
+    this.supportsNativeWebSearch = defaultProvider.supportsNativeWebSearch;
     if (defaultProvider.countInputTokens) {
       this.countInputTokens =
         defaultProvider.countInputTokens.bind(defaultProvider);

package/src/providers/model-catalog.ts

@@ -760,6 +760,22 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         maxEffort: "max",
         pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
       },
+      {
+        id: "accounts/fireworks/models/deepseek-v4-flash",
+        displayName: "DeepSeek V4 Flash",
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        maxEffort: "max",
+        pricing: {
+          inputPer1mTokens: 0.14,
+          outputPer1mTokens: 0.28,
+          cacheReadPer1mTokens: 0.03,
+        },
+      },
     ],
     defaultModel: "accounts/fireworks/models/kimi-k2p5",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",

package/src/providers/openai/responses-provider.ts

@@ -194,6 +194,11 @@ export class OpenAIResponsesProvider implements Provider {
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
+  /** See {@link Provider.supportsNativeWebSearch}. */
+  get supportsNativeWebSearch(): boolean {
+    return this.useNativeWebSearch;
+  }
+
   async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/providers/openrouter/client.ts

@@ -140,6 +140,11 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
     return isAnthropicModel(this.defaultModel) ? "anthropic" : this.name;
   }
 
+  /** See {@link Provider.supportsNativeWebSearch}. Set per model at construction. */
+  get supportsNativeWebSearch(): boolean {
+    return this.useNativeWebSearch;
+  }
+
   override async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

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

@@ -43,6 +43,9 @@ let lazyInitPromise: Promise<void> | null = null;
 export class CallSiteConfiguredProvider implements Provider {
   public readonly name: string;
   public readonly tokenEstimationProvider?: string;
+  // Forward native web-search capability so it survives the wrapper chain
+  // (callers like the advisor consult gate on it). Fixed at construction.
+  public readonly supportsNativeWebSearch?: boolean;
 
   constructor(
     private readonly inner: Provider,
@@ -52,6 +55,7 @@ export class CallSiteConfiguredProvider implements Provider {
   ) {
     this.name = inner.name;
     this.tokenEstimationProvider = inner.tokenEstimationProvider;
+    this.supportsNativeWebSearch = inner.supportsNativeWebSearch;
   }
 
   sendMessage(

package/src/providers/ratelimit.ts

@@ -23,6 +23,10 @@ export class RateLimitProvider implements Provider {
     return this.inner.tokenEstimationProvider;
   }
 
+  get supportsNativeWebSearch(): boolean | undefined {
+    return this.inner.supportsNativeWebSearch;
+  }
+
   private requestTimestamps: number[];
 
   // Forward the optional token-counting endpoint so the capability survives

package/src/providers/retry.ts

@@ -618,6 +618,10 @@ export class RetryProvider implements Provider {
     return this.inner.tokenEstimationProvider;
   }
 
+  get supportsNativeWebSearch(): boolean | undefined {
+    return this.inner.supportsNativeWebSearch;
+  }
+
   // 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

@@ -265,6 +265,15 @@ export interface Provider {
    * Falls back to `name` when unset.
    */
   tokenEstimationProvider?: string;
+  /**
+   * True when this provider instance was constructed to run web search
+   * server-side (provider-native). The native search only activates when a
+   * `web_search`-named tool is passed in the request, so callers that want to
+   * enable web search on a one-shot completion (e.g. the advisor consult) check
+   * this first — passing the tool to a non-native instance would surface an
+   * unexecutable client tool call. Absent/false on providers without it.
+   */
+  supportsNativeWebSearch?: boolean;
   sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/providers/usage-tracking.ts

@@ -18,6 +18,9 @@ const log = getLogger("provider-usage-tracking");
 export class UsageTrackingProvider implements Provider {
   public readonly name: string;
   public readonly tokenEstimationProvider?: string;
+  // Forward native web-search capability so it survives the wrapper chain
+  // (callers like the advisor consult gate on it). Fixed at construction.
+  public readonly supportsNativeWebSearch?: boolean;
   // Forward the optional token-counting endpoint so the capability survives
   // the wrapper chain. Bound straight to the inner provider — count_tokens is
   // not billed, so there's no usage to track.
@@ -26,6 +29,7 @@ export class UsageTrackingProvider implements Provider {
   constructor(private readonly inner: Provider) {
     this.name = inner.name;
     this.tokenEstimationProvider = inner.tokenEstimationProvider;
+    this.supportsNativeWebSearch = inner.supportsNativeWebSearch;
     if (inner.countInputTokens) {
       this.countInputTokens = inner.countInputTokens.bind(inner);
     }

package/src/runtime/__tests__/channel-verification-service.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Gateway guardian-delivery list drives both getGuardianBinding and isGuardian:
+// null = couldn't determine, [] = authoritative unbound, one active entry =
+// bound. Tests set this to mirror the gateway-owned ACL state.
+let mockGuardianList: Array<Record<string, unknown>> | null = [];
+const cachedCalls: Array<{ channelTypes?: string[] } | undefined> = [];
+
+const resolveList = (input?: { channelTypes?: string[] }) => {
+  cachedCalls.push(input);
+  return Promise.resolve(mockGuardianList);
+};
+
+mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: resolveList,
+  getGuardianDeliveryFresh: resolveList,
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
+const { getGuardianBinding, isGuardian } = await import(
+  "../channel-verification-service.js"
+);
+
+const TELEGRAM_DELIVERY = {
+  channelType: "telegram",
+  contactId: "contact-1",
+  principalId: "principal-1",
+  displayName: "Guardian",
+  address: "guardian-handle",
+  externalChatId: "chat-1",
+  status: "active",
+  verifiedAt: 1700,
+};
+
+describe("getGuardianBinding", () => {
+  beforeEach(() => {
+    mockGuardianList = [];
+    cachedCalls.length = 0;
+  });
+
+  test("filters delivery by the requested channel type", async () => {
+    await getGuardianBinding("asst-1", "telegram");
+    expect(cachedCalls).toEqual([{ channelTypes: ["telegram"] }]);
+  });
+
+  test("returns null when no guardian is bound", async () => {
+    mockGuardianList = [];
+    expect(await getGuardianBinding("asst-1", "telegram")).toBeNull();
+  });
+
+  test("returns null when the gateway is unreachable", async () => {
+    mockGuardianList = null;
+    expect(await getGuardianBinding("asst-1", "telegram")).toBeNull();
+  });
+
+  test("synthesizes the binding from the gateway delivery", async () => {
+    mockGuardianList = [TELEGRAM_DELIVERY];
+
+    const binding = await getGuardianBinding("asst-1", "telegram");
+
+    expect(binding).not.toBeNull();
+    expect(binding?.assistantId).toBe("asst-1");
+    expect(binding?.channel).toBe("telegram");
+    expect(binding?.id).toBe("contact-1");
+    expect(binding?.guardianPrincipalId).toBe("principal-1");
+    expect(binding?.guardianExternalUserId).toBe("guardian-handle");
+    expect(binding?.guardianDeliveryChatId).toBe("chat-1");
+    expect(binding?.verifiedAt).toBe(1700);
+    expect(binding?.status).toBe("active");
+    expect(binding?.verifiedVia).toBe("verified");
+  });
+
+  test("falls back to empty strings for absent optional delivery fields", async () => {
+    mockGuardianList = [
+      {
+        channelType: "telegram",
+        contactId: "contact-2",
+        address: "addr",
+        status: "active",
+      },
+    ];
+
+    const binding = await getGuardianBinding("asst-1", "telegram");
+
+    expect(binding?.guardianPrincipalId).toBe("");
+    expect(binding?.guardianDeliveryChatId).toBe("");
+    expect(binding?.verifiedAt).toBe(0);
+  });
+
+  test("ignores deliveries for a different channel", async () => {
+    mockGuardianList = [TELEGRAM_DELIVERY];
+    expect(await getGuardianBinding("asst-1", "phone")).toBeNull();
+  });
+});
+
+describe("isGuardian", () => {
+  beforeEach(() => {
+    mockGuardianList = [];
+    cachedCalls.length = 0;
+  });
+
+  test("returns true when the address matches the gateway guardian", async () => {
+    mockGuardianList = [TELEGRAM_DELIVERY];
+    expect(await isGuardian("asst-1", "telegram", "guardian-handle")).toBe(true);
+  });
+
+  test("compares case-insensitively", async () => {
+    mockGuardianList = [TELEGRAM_DELIVERY];
+    expect(await isGuardian("asst-1", "telegram", "GUARDIAN-HANDLE")).toBe(true);
+  });
+
+  test("returns false for a non-matching address", async () => {
+    mockGuardianList = [TELEGRAM_DELIVERY];
+    expect(await isGuardian("asst-1", "telegram", "someone-else")).toBe(false);
+  });
+
+  test("returns false when no guardian is bound", async () => {
+    mockGuardianList = [];
+    expect(await isGuardian("asst-1", "telegram", "guardian-handle")).toBe(
+      false,
+    );
+  });
+
+  test("returns false when the gateway is unreachable", async () => {
+    mockGuardianList = null;
+    expect(await isGuardian("asst-1", "telegram", "guardian-handle")).toBe(
+      false,
+    );
+  });
+});

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

@@ -0,0 +1,181 @@
+/**
+ * Unit tests for the narrow reset-drift trust-recovery helper
+ * `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.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+let mockGuardianList: Array<Record<string, unknown>> | null = [];
+
+mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => mockGuardianList,
+  guardianForChannel: (
+    list: Array<Record<string, unknown>>,
+    channelType: string,
+  ) => 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 };
+} | null = null;
+const healWrites: Array<{ principalId: string }> = [];
+
+mock.module("../../contacts/contact-store.js", () => ({
+  findGuardianForChannel: () => mockLocalGuardian,
+  updateContactPrincipalAndChannel: (
+    _contactId: string,
+    _channelId: string,
+    principalId: string,
+  ) => {
+    healWrites.push({ principalId });
+    return true;
+  },
+}));
+
+// The local trust resolver returns guardian for the actor; the gate threads
+// sourceChannel via the real withSourceChannel wrapper.
+mock.module("../../runtime/trust-context-resolver.js", () => ({
+  resolveTrustContext: (input: { actorExternalId?: string }) => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+    resolvedActor: input.actorExternalId,
+  }),
+  withSourceChannel: (sourceChannel: unknown, ctx: Record<string, unknown>) => ({
+    ...ctx,
+    sourceChannel,
+  }),
+}));
+
+const { reResolveTrustOnResetDrift } = await import(
+  "../guardian-vellum-migration.js"
+);
+
+function gatewayGuardian(principalId: string): Record<string, unknown> {
+  return {
+    channelType: "vellum",
+    contactId: "guardian-contact",
+    principalId,
+    address: principalId,
+    status: "active",
+  };
+}
+
+function localGuardian(principalId: string) {
+  return {
+    contact: { id: "contact-1", principalId },
+    channel: { id: "channel-1" },
+  };
+}
+
+describe("reResolveTrustOnResetDrift", () => {
+  beforeEach(() => {
+    mockGuardianList = [];
+    mockLocalGuardian = 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.
+    mockGuardianList = [gatewayGuardian("vellum-principal-new")];
+    mockLocalGuardian = localGuardian("vellum-principal-stale");
+
+    const ctx = await reResolveTrustOnResetDrift(
+      "vellum-principal-old",
+      "vellum",
+    );
+
+    expect(ctx?.trustClass).toBe("guardian");
+    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.
+    mockGuardianList = [gatewayGuardian("vellum-principal-new")];
+    mockLocalGuardian = localGuardian("vellum-principal-old");
+
+    const ctx = await reResolveTrustOnResetDrift(
+      "vellum-principal-old",
+      "vellum",
+    );
+
+    expect(ctx?.trustClass).toBe("guardian");
+    expect(healWrites).toEqual([]);
+  });
+
+  test("gateway unreachable (null): returns null, heal not called", async () => {
+    mockGuardianList = null;
+    mockLocalGuardian = localGuardian("vellum-principal-old");
+
+    const ctx = await reResolveTrustOnResetDrift(
+      "vellum-principal-old",
+      "vellum",
+    );
+
+    expect(ctx).toBeNull();
+    expect(healWrites).toEqual([]);
+  });
+
+  test("empty/revoked gateway (no active guardian): returns null, heal not called", async () => {
+    mockGuardianList = [];
+    mockLocalGuardian = localGuardian("vellum-principal-old");
+
+    const ctx = await reResolveTrustOnResetDrift(
+      "vellum-principal-old",
+      "vellum",
+    );
+
+    expect(ctx).toBeNull();
+    expect(healWrites).toEqual([]);
+  });
+
+  test("gateway guardian is a real (non vellum-principal-*) id: returns null", async () => {
+    mockGuardianList = [gatewayGuardian("user@example.com")];
+    mockLocalGuardian = localGuardian("vellum-principal-old");
+
+    const ctx = await reResolveTrustOnResetDrift(
+      "vellum-principal-old",
+      "vellum",
+    );
+
+    expect(ctx).toBeNull();
+    expect(healWrites).toEqual([]);
+  });
+
+  test("incoming principal is not vellum-principal-*: returns null", async () => {
+    mockGuardianList = [gatewayGuardian("vellum-principal-new")];
+    mockLocalGuardian = localGuardian("vellum-principal-old");
+
+    const ctx = await reResolveTrustOnResetDrift("user@example.com", "vellum");
+
+    expect(ctx).toBeNull();
+    expect(healWrites).toEqual([]);
+  });
+
+  test("threads sourceChannel into the returned ctx", async () => {
+    mockGuardianList = [gatewayGuardian("vellum-principal-new")];
+    mockLocalGuardian = localGuardian("vellum-principal-old");
+
+    const ctx = await reResolveTrustOnResetDrift(
+      "vellum-principal-old",
+      "telegram",
+    );
+
+    expect(ctx?.sourceChannel).toBe("telegram");
+  });
+});

package/src/runtime/__tests__/is-guardian-bound-for-channel.test.ts

@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Gateway guardian-delivery list: null = couldn't determine (transport failure
+// OR gateway-side resolver/DB error), [] = authoritative unbound, one active
+// entry = bound.
+let mockGuardianList: Array<Record<string, unknown>> | null = [];
+const freshCalls: Array<{ channelTypes?: string[] } | undefined> = [];
+
+mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+  // Existence guard reads fresh (uncached); the binding/identity reads use the
+  // cached variant. The service imports both, so both must be stubbed.
+  getGuardianDeliveryFresh: (input?: { channelTypes?: string[] }) => {
+    freshCalls.push(input);
+    return Promise.resolve(mockGuardianList);
+  },
+  getGuardianDelivery: () => Promise.resolve(mockGuardianList),
+  guardianForChannel: (
+    list: Array<{ channelType: string; status: string }>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
+const { isGuardianBoundForChannel } = await import(
+  "../channel-verification-service.js"
+);
+
+describe("isGuardianBoundForChannel", () => {
+  beforeEach(() => {
+    mockGuardianList = [];
+    freshCalls.length = 0;
+  });
+
+  test("reads fresh so a stale cached empty list can't mask a present guardian", async () => {
+    await isGuardianBoundForChannel("telegram");
+    expect(freshCalls).toEqual([{ channelTypes: ["telegram"] }]);
+  });
+
+  test("returns false when no guardian is bound", async () => {
+    mockGuardianList = [];
+    expect(await isGuardianBoundForChannel("telegram")).toBe(false);
+  });
+
+  test("returns true when a guardian is bound", async () => {
+    mockGuardianList = [{ channelType: "telegram", status: "active" }];
+    expect(await isGuardianBoundForChannel("telegram")).toBe(true);
+  });
+
+  test("null list (gateway unreachable) is treated as bound", async () => {
+    mockGuardianList = null;
+    expect(await isGuardianBoundForChannel("telegram")).toBe(true);
+  });
+
+  test("gateway resolver error (null, not []) is treated as bound — no duplicate", async () => {
+    // A gateway-side DB/resolver error now reaches the reader as null (the
+    // handler no longer swallows it into an empty list), so the guard's
+    // null fail-safe applies and reports bound instead of mis-reading the
+    // error as "no guardian" and allowing a duplicate binding.
+    mockGuardianList = null;
+    expect(await isGuardianBoundForChannel("telegram")).toBe(true);
+  });
+
+  test("genuine empty ([], not null) reports unbound so first-bind is allowed", async () => {
+    mockGuardianList = [];
+    expect(await isGuardianBoundForChannel("telegram")).toBe(false);
+  });
+});