@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/security/__tests__/oauth2-device-code.test.ts

@@ -1,27 +1,11 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mock logger before importing any code that uses it.
 // ---------------------------------------------------------------------------
-
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // ---------------------------------------------------------------------------
 // Imports under test
 // ---------------------------------------------------------------------------
-
 import type { DeviceCodeConfig } from "../oauth2-device-code.js";
 import {
   DeviceCodeError,
@@ -121,9 +105,7 @@ describe("oauth2-device-code", () => {
 
       expect(result.deviceCode).toBe("dev-code-123");
       expect(result.userCode).toBe("ABCD-1234");
-      expect(result.verificationUri).toBe(
-        "https://auth.example.com/activate",
-      );
+      expect(result.verificationUri).toBe("https://auth.example.com/activate");
       expect(result.verificationUriComplete).toBe(
         "https://auth.example.com/activate?user_code=ABCD-1234",
       );
@@ -169,9 +151,7 @@ describe("oauth2-device-code", () => {
     });
 
     test("throws DeviceCodeError on non-OK response", async () => {
-      mockFetch(async () =>
-        jsonResponse({ error: "invalid_client" }, 400),
-      );
+      mockFetch(async () => jsonResponse({ error: "invalid_client" }, 400));
 
       await expect(requestDeviceCode(TEST_CONFIG)).rejects.toThrow(
         DeviceCodeError,
@@ -217,10 +197,7 @@ describe("oauth2-device-code", () => {
       mockFetch(async () => {
         callCount++;
         if (callCount < 3) {
-          return jsonResponse(
-            { error: "authorization_pending" },
-            403,
-          );
+          return jsonResponse({ error: "authorization_pending" }, 403);
         }
         return jsonResponse({
           access_token: "at-after-pending",
@@ -229,12 +206,7 @@ describe("oauth2-device-code", () => {
         });
       });
 
-      const result = await pollForToken(
-        TEST_CONFIG,
-        "dev-code-123",
-        0.01,
-        30,
-      );
+      const result = await pollForToken(TEST_CONFIG, "dev-code-123", 0.01, 30);
 
       expect(result.accessToken).toBe("at-after-pending");
       expect(callCount).toBe(3);
@@ -277,9 +249,7 @@ describe("oauth2-device-code", () => {
     });
 
     test("throws on expired_token", async () => {
-      mockFetch(async () =>
-        jsonResponse({ error: "expired_token" }, 403),
-      );
+      mockFetch(async () => jsonResponse({ error: "expired_token" }, 403));
 
       try {
         await pollForToken(TEST_CONFIG, "dev-code-123", 0.01, 30);
@@ -292,9 +262,7 @@ describe("oauth2-device-code", () => {
     });
 
     test("throws on access_denied", async () => {
-      mockFetch(async () =>
-        jsonResponse({ error: "access_denied" }, 403),
-      );
+      mockFetch(async () => jsonResponse({ error: "access_denied" }, 403));
 
       try {
         await pollForToken(TEST_CONFIG, "dev-code-123", 0.01, 30);
@@ -330,10 +298,7 @@ describe("oauth2-device-code", () => {
         if (callCount === 1) {
           ac.abort();
         }
-        return jsonResponse(
-          { error: "authorization_pending" },
-          403,
-        );
+        return jsonResponse({ error: "authorization_pending" }, 403);
       });
 
       try {
@@ -367,9 +332,7 @@ describe("oauth2-device-code", () => {
     });
 
     test("throws on unexpected error code", async () => {
-      mockFetch(async () =>
-        jsonResponse({ error: "server_error" }, 500),
-      );
+      mockFetch(async () => jsonResponse({ error: "server_error" }, 500));
 
       try {
         await pollForToken(TEST_CONFIG, "dev-code-123", 0.01, 30);
@@ -394,12 +357,7 @@ describe("oauth2-device-code", () => {
         });
       });
 
-      const result = await pollForToken(
-        TEST_CONFIG,
-        "dev-code-123",
-        0.01,
-        30,
-      );
+      const result = await pollForToken(TEST_CONFIG, "dev-code-123", 0.01, 30);
 
       expect(result.accessToken).toBe("at-retry");
       expect(callCount).toBe(2);
@@ -423,10 +381,7 @@ describe("oauth2-device-code", () => {
         }
         // Token endpoint — succeed on second poll
         if (callCount === 2) {
-          return jsonResponse(
-            { error: "authorization_pending" },
-            403,
-          );
+          return jsonResponse({ error: "authorization_pending" }, 403);
         }
         return jsonResponse({
           access_token: "at-full-flow",
@@ -461,10 +416,7 @@ describe("oauth2-device-code", () => {
         }
         // Abort before returning token
         ac.abort();
-        return jsonResponse(
-          { error: "authorization_pending" },
-          403,
-        );
+        return jsonResponse({ error: "authorization_pending" }, 403);
       });
 
       try {

package/src/security/__tests__/provider-key-env-fallback.test.ts

@@ -8,25 +8,15 @@ import {
   beforeEach,
   describe,
   expect,
-  mock,
   test,
 } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mock logger before importing any code that uses it.
 // ---------------------------------------------------------------------------
-
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // ---------------------------------------------------------------------------
 // Imports under test
 // ---------------------------------------------------------------------------
-
 import { setStorePathForTesting } from "../../__tests__/encrypted-store-test-helpers.js";
 import { _resetBackend, getProviderKeyAsync } from "../secure-keys.js";
 

package/src/security/auth-fallback-events-store.ts

@@ -1,9 +1,9 @@
-import { and, asc, eq, gt, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb } from "../persistence/db-connection.js";
-import { authFallbackEvents } from "../persistence/schema/index.js";
 import { getCachedShareAnalytics } from "../platform/consent-cache.js";
+import { insertTelemetryOutboxEvents } from "../telemetry/telemetry-events-outbox.js";
+import type { AuthFallbackTelemetryEvent } from "../telemetry/types.js";
+import { APP_VERSION } from "../version.js";
 
 /** A single aggregated auth-fallback count for one (guard, path, failure_kind). */
 export interface AuthFallbackCount {
@@ -13,82 +13,44 @@ export interface AuthFallbackCount {
   count: number;
 }
 
-/** A persisted auth-fallback event row. */
-export interface AuthFallbackEvent {
-  id: string;
-  createdAt: number;
-  guard: string;
-  path: string;
-  failureKind: string;
-  count: number;
-  windowStart: number;
-  windowEnd: number;
-}
-
 /**
  * Record a batch of aggregated auth-fallback counts forwarded by the gateway —
- * one row per count entry, all sharing the same flush window. Returns the
- * number of rows recorded, or 0 when usage data collection is disabled (the
- * counts are dropped to honor the opt-out, matching the rest of telemetry).
+ * one `telemetry_events` outbox row per count entry, all sharing the same
+ * flush window, each carrying its full wire event built at record time. The
+ * whole batch inserts atomically, so a failure never leaves a partial batch
+ * committed (the gateway retries the full batch on `recorded === 0`). Returns
+ * the number of rows recorded, or 0 when usage data collection is disabled
+ * (the counts are dropped to honor the opt-out, matching the rest of
+ * telemetry) or the telemetry database is unavailable (degraded mode). Callers
+ * that must tell those apart check `getCachedShareAnalytics()` themselves.
  */
 export function recordAuthFallbackCounts(
   windowStart: number,
   windowEnd: number,
   counts: AuthFallbackCount[],
 ): number {
-  if (!getCachedShareAnalytics()) return 0;
-  if (counts.length === 0) return 0;
-  const db = getDb();
+  if (!getCachedShareAnalytics()) {
+    return 0;
+  }
+  if (counts.length === 0) {
+    return 0;
+  }
   const createdAt = Date.now();
-  const rows = counts.map((c) => ({
-    id: uuid(),
-    createdAt,
-    guard: c.guard,
-    path: c.path,
-    failureKind: c.failureKind,
-    count: c.count,
-    windowStart,
-    windowEnd,
-  }));
-  db.insert(authFallbackEvents).values(rows).run();
-  return rows.length;
-}
-
-/**
- * Query auth-fallback events that haven't been reported to telemetry yet.
- * Uses a compound cursor (createdAt + id) for reliable watermarking.
- */
-export function queryUnreportedAuthFallbackEvents(
-  afterCreatedAt: number,
-  afterId: string | undefined,
-  limit: number,
-): AuthFallbackEvent[] {
-  const db = getDb();
-  const rows = db
-    .select({
-      id: authFallbackEvents.id,
-      createdAt: authFallbackEvents.createdAt,
-      guard: authFallbackEvents.guard,
-      path: authFallbackEvents.path,
-      failureKind: authFallbackEvents.failureKind,
-      count: authFallbackEvents.count,
-      windowStart: authFallbackEvents.windowStart,
-      windowEnd: authFallbackEvents.windowEnd,
-    })
-    .from(authFallbackEvents)
-    .where(
-      afterId
-        ? or(
-            gt(authFallbackEvents.createdAt, afterCreatedAt),
-            and(
-              eq(authFallbackEvents.createdAt, afterCreatedAt),
-              gt(authFallbackEvents.id, afterId),
-            ),
-          )
-        : gt(authFallbackEvents.createdAt, afterCreatedAt),
-    )
-    .orderBy(asc(authFallbackEvents.createdAt), asc(authFallbackEvents.id))
-    .limit(limit)
-    .all();
-  return rows;
+  const rows = counts.map((c) => {
+    const id = uuid();
+    const event: AuthFallbackTelemetryEvent = {
+      type: "auth_fallback",
+      daemon_event_id: id,
+      recorded_at: createdAt,
+      guard: c.guard,
+      path: c.path,
+      failure_kind: c.failureKind,
+      count: c.count,
+      window_start: windowStart,
+      window_end: windowEnd,
+      assistant_version: APP_VERSION,
+    };
+    return { id, name: "auth_fallback", createdAt, event };
+  });
+  return insertTelemetryOutboxEvents(rows) ? rows.length : 0;
 }

package/src/security/secret-scanner.ts

@@ -274,6 +274,31 @@ export function scanText(text: string): SecretMatch[] {
  * Returns the modified text.
  */
 export function redactSecrets(text: string): string {
+  return redactSecretsWith(
+    text,
+    (match) => `<redacted type="${match.type}" />`,
+  );
+}
+
+/**
+ * Core redaction walk with a caller-supplied marker builder.
+ *
+ * `markerFor` receives the {@link SecretMatch} plus the raw matched value so
+ * a caller can vary the marker per match (e.g. the chat-persist path emits a
+ * revealable sentinel when the value byte-matches a known vault credential).
+ * The default `<redacted type="…" />` marker produced via
+ * {@link redactSecrets} is consumed by ingress blocking, tool-output
+ * scanning, and log redaction — its shape must not change (see
+ * `security/AGENTS.md`), which is why this variant exists as a separate
+ * additive entry point instead of an option on `redactSecrets`.
+ *
+ * This module stays pure: `markerFor` is a plain callback, and no credential
+ * store types leak in here.
+ */
+export function redactSecretsWith(
+  text: string,
+  markerFor: (match: SecretMatch, rawValue: string) => string,
+): string {
   const matches = scanText(text);
   if (matches.length === 0) return text;
 
@@ -289,7 +314,7 @@ export function redactSecrets(text: string): string {
       continue;
     }
     result += text.slice(lastIndex, match.startIndex);
-    result += `<redacted type="${match.type}" />`;
+    result += markerFor(match, text.slice(match.startIndex, match.endIndex));
     lastIndex = match.endIndex;
   }
   result += text.slice(lastIndex);

package/src/sequence/engine.ts

@@ -35,7 +35,9 @@ const STEP_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes per step
 export async function runSequencesOnce(): Promise<number> {
   const now = Date.now();
   const claimed = claimDueEnrollments(now, BATCH_SIZE);
-  if (claimed.length === 0) return 0;
+  if (claimed.length === 0) {
+    return 0;
+  }
 
   let processed = 0;
   for (const enrollment of claimed) {
@@ -202,8 +204,9 @@ async function processEnrollment(
   // null so it won't be re-claimed. The approval/send flow is responsible
   // for advancing the enrollment once the draft is approved.
   if (step.requireApproval) {
-    if (extractedConversationId)
+    if (extractedConversationId) {
       updateEnrollmentConversationId(enrollment.id, extractedConversationId);
+    }
     log.info(
       {
         enrollmentId: enrollment.id,
@@ -322,8 +325,10 @@ function extractThreadIdFromConversation(
     // is the one we want.
     for (let i = msgs.length - 1; i >= 0; i--) {
       const msg = msgs[i];
-      const threadId = extractThreadIdFromContent(msg.content);
-      if (threadId) return threadId;
+      const threadId = extractThreadIdFromContent(JSON.stringify(msg.content));
+      if (threadId) {
+        return threadId;
+      }
     }
   } catch (err) {
     log.warn(
@@ -338,11 +343,15 @@ function extractThreadIdFromConversation(
 function extractThreadIdFromContent(content: string): string | null {
   // Pattern 1: JSON field like "threadId": "..." or "thread_id": "..."
   const jsonMatch = content.match(/"(?:threadId|thread_id)"\s*:\s*"([^"]+)"/);
-  if (jsonMatch) return jsonMatch[1];
+  if (jsonMatch) {
+    return jsonMatch[1];
+  }
 
   // Pattern 2: Prose like "Thread ID: <id>" (from tool result text)
   const proseMatch = content.match(/[Tt]hread\s+(?:ID|id):\s*(\S+)/);
-  if (proseMatch) return proseMatch[1];
+  if (proseMatch) {
+    return proseMatch[1];
+  }
 
   return null;
 }

package/src/services/published-app-updater.ts

@@ -9,7 +9,6 @@ import { join } from "node:path";
 import {
   getApp,
   getAppDirPath,
-  isMultifileApp,
   resolveEffectiveAppHtml,
 } from "../apps/app-store.js";
 import {
@@ -30,23 +29,19 @@ export async function updatePublishedAppDeployment(
     const publishedPage = getActivePublishedPageByAppId(appId);
     if (!publishedPage) return;
 
-    // 2. Load the app and resolve its deployable HTML. For multifile apps the
-    // real content lives in dist/index.html (compiled from src/), not in
-    // htmlDefinition (which is "" for them) — using htmlDefinition directly
-    // would deploy a blank page.
+    // 2. Load the app and resolve its deployable HTML: the real content
+    // lives in dist/index.html (compiled from src/), inlined into a
+    // self-contained page.
     const app = getApp(appId);
     if (!app) {
       log.warn({ appId }, "Published app not found");
       return;
     }
 
-    // Skip rather than deploy the compile-failure fallback when a multifile
-    // app has no compiled output (e.g. a concurrent compile failed); a later
+    // Skip rather than deploy the compile-failure fallback when the app has
+    // no compiled output (e.g. a concurrent compile failed); a later
     // successful compile re-triggers this path.
-    if (
-      isMultifileApp(app) &&
-      !existsSync(join(getAppDirPath(app.id), "dist", "index.html"))
-    ) {
+    if (!existsSync(join(getAppDirPath(app.id), "dist", "index.html"))) {
       log.warn({ appId }, "Skipping auto-redeploy: compiled output missing");
       return;
     }

package/src/stt/__tests__/daemon-batch-transcriber.test.ts

@@ -13,7 +13,9 @@ mock.module("../../providers/speech-to-text/openai-whisper.js", () => ({
   OpenAIWhisperProvider: class MockWhisperProvider {
     constructor(_apiKey: string) {}
     async transcribe(_audio: Buffer, _mimeType: string, _signal?: AbortSignal) {
-      if (mockWhisperTranscribeError) throw mockWhisperTranscribeError;
+      if (mockWhisperTranscribeError) {
+        throw mockWhisperTranscribeError;
+      }
       return mockWhisperTranscribeResult;
     }
   },
@@ -26,7 +28,9 @@ mock.module("../../providers/speech-to-text/deepgram.js", () => ({
   DeepgramProvider: class MockDeepgramProvider {
     constructor(_apiKey: string) {}
     async transcribe(_audio: Buffer, _mimeType: string, _signal?: AbortSignal) {
-      if (mockDeepgramTranscribeError) throw mockDeepgramTranscribeError;
+      if (mockDeepgramTranscribeError) {
+        throw mockDeepgramTranscribeError;
+      }
       return mockDeepgramTranscribeResult;
     }
   },
@@ -39,7 +43,9 @@ mock.module("../../providers/speech-to-text/google-gemini.js", () => ({
   GoogleGeminiProvider: class MockGoogleGeminiProvider {
     constructor(_apiKey: string) {}
     async transcribe(_audio: Buffer, _mimeType: string, _signal?: AbortSignal) {
-      if (mockGeminiTranscribeError) throw mockGeminiTranscribeError;
+      if (mockGeminiTranscribeError) {
+        throw mockGeminiTranscribeError;
+      }
       return mockGeminiTranscribeResult;
     }
   },
@@ -52,7 +58,9 @@ mock.module("../../providers/speech-to-text/xai.js", () => ({
   XAIProvider: class MockXAIProvider {
     constructor(_apiKey: string) {}
     async transcribe(_audio: Buffer, _mimeType: string, _signal?: AbortSignal) {
-      if (mockXAITranscribeError) throw mockXAITranscribeError;
+      if (mockXAITranscribeError) {
+        throw mockXAITranscribeError;
+      }
       return mockXAITranscribeResult;
     }
   },
@@ -466,3 +474,15 @@ describe("normalizeSttError", () => {
     expect(result.category).toBe("rate-limit");
   });
 });
+
+describe("vellum factory case", () => {
+  test("constructs the managed transcriber with no API key", () => {
+    const transcriber = createDaemonBatchTranscriber(null, "vellum");
+    expect(transcriber?.providerId).toBe("vellum");
+    expect(transcriber?.boundaryId).toBe("daemon-batch");
+  });
+
+  test("still returns null for key-based providers without a key", () => {
+    expect(createDaemonBatchTranscriber(null, "deepgram")).toBeNull();
+  });
+});

package/src/stt/daemon-batch-transcriber.ts

@@ -162,7 +162,9 @@ class XAIBatchTranscriber implements BatchTranscriber {
  * `BatchTranscriber.transcribe()` calls with this utility.
  */
 export function normalizeSttError(err: unknown): SttError {
-  if (err instanceof SttError) return err;
+  if (err instanceof SttError) {
+    return err;
+  }
 
   const message = err instanceof Error ? err.message : String(err);
 
@@ -203,11 +205,40 @@ export function normalizeSttError(err: unknown): SttError {
  * Returns `null` when `apiKey` is falsy, signalling to the caller that
  * batch transcription is unavailable.
  */
+// ---------------------------------------------------------------------------
+// Vellum managed adapter — implements BatchTranscriber on top of the
+// platform's managed speech endpoint. No API key: the platform connection
+// is the credential.
+// ---------------------------------------------------------------------------
+
+class VellumManagedBatchTranscriber implements BatchTranscriber {
+  readonly providerId = "vellum" as const;
+  readonly boundaryId = "daemon-batch" as const;
+
+  async transcribe(
+    request: SttTranscribeRequest,
+  ): Promise<SttTranscribeResult> {
+    const { vellumManagedTranscribe } =
+      await import("../providers/speech-to-text/vellum-managed.js");
+    return vellumManagedTranscribe(
+      request.audio,
+      request.mimeType,
+      request.signal,
+    );
+  }
+}
+
 export function createDaemonBatchTranscriber(
   apiKey: string | null | undefined,
   providerId: SttProviderId,
 ): BatchTranscriber | null {
-  if (!apiKey) return null;
+  // vellum authenticates via the platform connection, not an API key.
+  if (providerId === "vellum") {
+    return new VellumManagedBatchTranscriber();
+  }
+  if (!apiKey) {
+    return null;
+  }
 
   switch (providerId) {
     case "openai-whisper":

package/src/stt/stt-stream-session.ts

@@ -35,7 +35,11 @@ import {
   supportsBoundary,
 } from "../providers/speech-to-text/provider-catalog.js";
 import { getLogger } from "../util/logger.js";
-import type { StreamingTranscriber, SttStreamServerEvent } from "./types.js";
+import {
+  type StreamingTranscriber,
+  SttError,
+  type SttStreamServerEvent,
+} from "./types.js";
 
 const log = getLogger("stt-stream-session");
 
@@ -231,7 +235,9 @@ export class SttStreamSession {
       );
       this.sendEvent({
         type: "error",
-        category: "provider-error",
+        // Adapters reject with SttError when they know better than the
+        // generic bucket (e.g. a relay auth rejection at dial time).
+        category: err instanceof SttError ? err.category : "provider-error",
         message: `Failed to start streaming session: ${message}`,
       });
       this.sendEvent({ type: "closed" });
@@ -248,7 +254,7 @@ export class SttStreamSession {
    * {@link handleBinaryAudio}.
    */
   handleMessage(raw: string): void {
-    if (this.state === "closed") return;
+    if (this.state === "closed") {return;}
 
     this.resetIdleTimer();
 
@@ -261,7 +267,7 @@ export class SttStreamSession {
       return;
     }
 
-    if (!parsed || typeof parsed !== "object") return;
+    if (!parsed || typeof parsed !== "object") {return;}
 
     const event = parsed as {
       type?: string;
@@ -306,7 +312,7 @@ export class SttStreamSession {
    * frames rather than base64-encoded JSON.
    */
   handleBinaryAudio(data: Buffer | ArrayBuffer | Uint8Array): void {
-    if (this.state !== "active") return;
+    if (this.state !== "active") {return;}
 
     this.resetIdleTimer();
 
@@ -322,7 +328,7 @@ export class SttStreamSession {
    * Tears down the provider session and cleans up resources.
    */
   handleClose(code: number, reason?: string): void {
-    if (this.state === "closed") return;
+    if (this.state === "closed") {return;}
 
     log.info(
       { provider: this.provider, code, reason },
@@ -337,7 +343,7 @@ export class SttStreamSession {
    * ensure deterministic cleanup of all active sessions.
    */
   destroy(): void {
-    if (this.state === "closed") return;
+    if (this.state === "closed") {return;}
 
     log.info({ provider: this.provider }, "STT stream session destroyed");
     this.teardown();
@@ -389,7 +395,7 @@ export class SttStreamSession {
    * Handle events emitted by the streaming transcriber.
    */
   private handleTranscriberEvent(event: SttStreamServerEvent): void {
-    if (this.state === "closed") return;
+    if (this.state === "closed") {return;}
 
     this.sendEvent(event);
 
@@ -430,10 +436,10 @@ export class SttStreamSession {
   private resetIdleTimer(): void {
     this.clearIdleTimer();
 
-    if (this.state === "closed" || this.state === "stopping") return;
+    if (this.state === "closed" || this.state === "stopping") {return;}
 
     this.idleTimer = setTimeout(() => {
-      if (this.state === "closed") return;
+      if (this.state === "closed") {return;}
 
       log.warn({ provider: this.provider }, "STT stream session idle timeout");
       this.sendEvent({
@@ -463,7 +469,7 @@ export class SttStreamSession {
    * Idempotent — safe to call multiple times.
    */
   private teardown(): void {
-    if (this.state === "closed") return;
+    if (this.state === "closed") {return;}
     this.state = "closed";
 
     this.clearIdleTimer();

package/src/stt/types.ts

@@ -24,7 +24,8 @@ export type SttProviderId =
   | "openai-whisper"
   | "deepgram"
   | "google-gemini"
-  | "xai";
+  | "xai"
+  | "vellum";
 
 /**
  * Telephony-specific STT capability class.