@vellumai/assistant 0.11.6 → 0.11.7-staging.1

package/src/__tests__/workspace-migration-149-repoint-backup-profile-selections.test.ts

@@ -0,0 +1,144 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repointBackupProfileSelectionsMigration } from "../workspace/migrations/149-repoint-backup-profile-selections.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+let workspaceDir: string;
+
+function dbPath(): string {
+  return join(workspaceDir, "data", "db", "assistant.db");
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, any> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function seedProfilePinTables(): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(dbPath());
+  db.run(
+    "CREATE TABLE conversations (id TEXT PRIMARY KEY, inference_profile TEXT)",
+  );
+  db.run(
+    "CREATE TABLE cron_jobs (id TEXT PRIMARY KEY, inference_profile TEXT)",
+  );
+  db.query(
+    "INSERT INTO conversations (id, inference_profile) VALUES (?, ?)",
+  ).run("conv-1", "quality-optimized-backup");
+  db.query("INSERT INTO cron_jobs (id, inference_profile) VALUES (?, ?)").run(
+    "job-1",
+    "balanced-backup",
+  );
+  db.close();
+}
+
+function readPins(table: "conversations" | "cron_jobs"): string[] {
+  const db = new Database(dbPath());
+  try {
+    return (
+      db
+        .query(`SELECT inference_profile AS profile FROM ${table} ORDER BY id`)
+        .all() as Array<{ profile: string }>
+    ).map((row) => row.profile);
+  } finally {
+    db.close();
+  }
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-149-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("149-repoint-backup-profile-selections migration", () => {
+  test("is registered", () => {
+    expect(repointBackupProfileSelectionsMigration.id).toBe(
+      "149-repoint-backup-profile-selections",
+    );
+    // The "newest migration" assertion lives with whichever migration is
+    // actually last; this one only has to stay in the ordered list.
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "149-repoint-backup-profile-selections",
+    );
+  });
+
+  test("repoints direct config selections and preserves fallback metadata", async () => {
+    writeConfig({
+      llm: {
+        activeProfile: "balanced-backup",
+        advisorProfile: "quality-optimized-backup",
+        profileOrder: ["balanced", "balanced-backup"],
+        callSites: {
+          mainAgent: { profile: "cost-optimized-backup" },
+        },
+        profiles: {
+          custom: {
+            mix: [{ profile: "latency-optimized-backup", weight: 1 }],
+          },
+          balanced: {
+            source: "managed",
+            fallbackProfile: "balanced-backup",
+          },
+        },
+      },
+    });
+
+    await repointBackupProfileSelectionsMigration.run(workspaceDir);
+
+    const llm = readConfig().llm;
+    expect(llm.activeProfile).toBe("balanced");
+    expect(llm.advisorProfile).toBe("quality-optimized");
+    expect(llm.callSites.mainAgent.profile).toBe("cost-optimized");
+    expect(llm.profiles.custom.mix[0].profile).toBe("latency-optimized");
+    expect(llm.profiles.balanced.fallbackProfile).toBe("balanced-backup");
+    expect(llm.profileOrder).toEqual(["balanced", "balanced-backup"]);
+  });
+
+  test("repoints conversation and schedule pins", async () => {
+    seedProfilePinTables();
+
+    await repointBackupProfileSelectionsMigration.run(workspaceDir);
+
+    expect(readPins("conversations")).toEqual(["quality-optimized"]);
+    expect(readPins("cron_jobs")).toEqual(["balanced"]);
+  });
+
+  test("is idempotent and tolerates a missing config or database", async () => {
+    await expect(
+      repointBackupProfileSelectionsMigration.run(workspaceDir),
+    ).resolves.toBeUndefined();
+
+    writeConfig({ llm: { activeProfile: "balanced" } });
+    const before = readConfig();
+    await repointBackupProfileSelectionsMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(before);
+  });
+});

package/src/agent/loop.ts

@@ -43,7 +43,10 @@ import type {
   ToolDefinition,
   ToolResultContent,
 } from "../providers/types.js";
-import { isContextOverflowError } from "../providers/types.js";
+import {
+  isContextOverflowError,
+  NATIVE_WEB_SEARCH_TOOL_NAME,
+} from "../providers/types.js";
 import { getTool } from "../tools/registry.js";
 import type { SensitiveOutputBinding } from "../tools/sensitive-output-placeholders.js";
 import {
@@ -133,7 +136,7 @@ export interface AgentLoopConfig {
  * `input_schema` is informational — the provider supplies the real schema.
  */
 const NATIVE_WEB_SEARCH_TOOL: ToolDefinition = {
-  name: "web_search",
+  name: NATIVE_WEB_SEARCH_TOOL_NAME,
   description:
     "Search the web for current information to ground your response.",
   input_schema: {
@@ -369,6 +372,16 @@ export type AgentEvent =
       cacheReadInputTokens?: number;
       model: string;
       actualProvider?: string;
+      /**
+       * Inference profile that actually governed the call, set only when a
+       * wrapper re-routed the request away from the caller's own resolution
+       * (`RetryProvider`'s fallback-profile escalation). Travels alongside
+       * `actualProvider` so the daemon's usage ledger attributes a degraded
+       * serve to the backup profile that answered rather than to the primary
+       * that failed. Absent on the normal (non-rerouted) path, where the
+       * caller's own resolution is already correct.
+       */
+      actualInferenceProfile?: string;
       providerDurationMs: number;
       rawRequest?: unknown;
       rawResponse?: unknown;
@@ -1468,6 +1481,14 @@ export class AgentLoop {
           providerConfig.tool_choice = { type: "auto" };
         }
 
+        // Mark the sentinel so a route change downstream can tell it from an
+        // app-executed `web_search` of the same name (see
+        // `SendMessageConfig.nativeWebSearchSentinel`). Only set when true so
+        // the wire config stays byte-identical otherwise.
+        if (attachNativeWebSearch) {
+          providerConfig.nativeWebSearchSentinel = true;
+        }
+
         if (this.config.cacheTtl) {
           providerConfig.cacheTtl = this.config.cacheTtl;
         }
@@ -1809,6 +1830,14 @@ export class AgentLoop {
           cacheReadInputTokens: response.usage.cacheReadInputTokens,
           model: response.model,
           actualProvider: response.actualProvider ?? this.provider.name,
+          // Only present when a wrapper rerouted this call, so the normal
+          // path's event shape stays byte-identical. There is no caller-side
+          // fallback value to fill in: the loop's own profile resolution is
+          // exactly what a reroute invalidates, and the daemon already reads
+          // its own resolution when this is absent.
+          ...(response.actualInferenceProfile !== undefined
+            ? { actualInferenceProfile: response.actualInferenceProfile }
+            : {}),
           providerDurationMs,
           rawRequest: response.rawRequest,
           rawResponse: response.rawResponse,

package/src/approvals/guardian-card-withdrawal.ts

@@ -31,6 +31,7 @@ import {
   completeSurfaceAndNotify,
   markSurfaceCompleted,
 } from "../daemon/conversation-surfaces.js";
+import { withdrawDiscordApprovalCard } from "../messaging/providers/discord/withdraw.js";
 import { withdrawSlackApprovalCard } from "../messaging/providers/slack/withdraw.js";
 import { withdrawTelegramApprovalCard } from "../messaging/providers/telegram-bot/withdraw.js";
 import { approvalCardSurfaceId } from "../notifications/approval-card-data.js";
@@ -131,6 +132,8 @@ export async function withdrawGuardianRequestCards(
           decidedAction,
           hasOriginGuardianReply ?? false,
         );
+      } else if (delivery.destinationChannel === "discord") {
+        await withdrawDiscordCard(delivery, status, decidedAction);
       }
       // WhatsApp direct delivery can't edit a message in place (it would
       // post a new one), so its stale clicks are left to the existing
@@ -231,6 +234,25 @@ async function withdrawSlackCard(
  * outcome. No-ops when the channel-native message id was not captured at
  * delivery time.
  */
+async function withdrawDiscordCard(
+  delivery: GuardianRequestDeliveryWire,
+  status: GuardianRequestStatus,
+  decidedAction: ApprovalAction | undefined,
+): Promise<void> {
+  if (!delivery.destinationChatId || !delivery.destinationMessageId) {
+    return;
+  }
+  // The Discord edit rewrites the card's actionable tail to the outcome, so
+  // it serves both halves of withdrawal in one call and needs no separate
+  // status reply regardless of where the decision originated.
+  await withdrawDiscordApprovalCard({
+    guardianUserId: delivery.destinationChatId,
+    messageId: delivery.destinationMessageId,
+    status,
+    ...(decidedAction ? { decidedAction } : {}),
+  });
+}
+
 async function withdrawTelegramCard(
   delivery: GuardianRequestDeliveryWire,
   status: GuardianRequestStatus,

package/src/avatar/__tests__/ensure-raster.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Tests for ensureAvatarRaster and ensureAvatarRasterPath.
+ *
+ * Character re-render routes through the native @resvg/resvg-js binding. As in
+ * avatar-store.test.ts, the re-render case branches on `isResvgAvailable()` so
+ * the suite is deterministic whether or not the binding is installed.
+ */
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  ensureAvatarRaster,
+  ensureAvatarRasterPath,
+} from "../ensure-raster.js";
+import {
+  __resetResvgCacheForTests,
+  __setResvgCacheForTests,
+  isResvgAvailable,
+} from "../resvg-lazy.js";
+
+const VALID_TRAITS = { bodyShape: "blob", eyeStyle: "curious", color: "green" };
+
+const IMAGE_FILENAME = "avatar-image.png";
+const MANIFEST_FILENAME = "avatar.json";
+const NATIVE_RENDER_TEST_TIMEOUT_MS = 15_000;
+
+const FAKE_PNG = Buffer.from("not-really-a-png");
+
+describe("ensureAvatarRaster", () => {
+  let workspaceDir: string;
+  let avatarDir: string;
+  let prevWorkspaceDir: string | undefined;
+
+  beforeEach(() => {
+    workspaceDir = mkdtempSync(join(tmpdir(), "ensure-raster-test-"));
+    avatarDir = join(workspaceDir, "data", "avatar");
+    mkdirSync(avatarDir, { recursive: true });
+    prevWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+  });
+
+  afterEach(() => {
+    __resetResvgCacheForTests();
+    if (prevWorkspaceDir === undefined) {
+      delete process.env.VELLUM_WORKSPACE_DIR;
+    } else {
+      process.env.VELLUM_WORKSPACE_DIR = prevWorkspaceDir;
+    }
+    rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  const writeManifestFile = (manifest: Record<string, unknown>) => {
+    writeFileSync(join(avatarDir, MANIFEST_FILENAME), JSON.stringify(manifest));
+  };
+
+  test("returns null for kind none", async () => {
+    writeManifestFile({
+      kind: "none",
+      traits: null,
+      source: null,
+      image: null,
+    });
+    expect(await ensureAvatarRaster()).toBeNull();
+  });
+
+  test("returns null with no manifest and no legacy files", async () => {
+    expect(await ensureAvatarRaster()).toBeNull();
+  });
+
+  test("returns the existing PNG bytes for an image avatar", async () => {
+    writeFileSync(join(avatarDir, IMAGE_FILENAME), FAKE_PNG);
+    writeManifestFile({
+      kind: "image",
+      traits: null,
+      source: "upload",
+      image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+    });
+    const raster = await ensureAvatarRaster();
+    expect(raster).not.toBeNull();
+    expect(raster!.equals(FAKE_PNG)).toBe(true);
+  });
+
+  test("returns the existing PNG for a character without re-rendering", async () => {
+    writeFileSync(join(avatarDir, IMAGE_FILENAME), FAKE_PNG);
+    writeManifestFile({
+      kind: "character",
+      traits: VALID_TRAITS,
+      source: "builder",
+      image: null,
+    });
+    // Force the unavailable path: a re-render attempt would return null.
+    __setResvgCacheForTests({ available: false, error: new Error("nope") });
+    const raster = await ensureAvatarRaster();
+    expect(raster).not.toBeNull();
+    expect(raster!.equals(FAKE_PNG)).toBe(true);
+  });
+
+  test("returns null for a symlinked PNG but still reports its path", async () => {
+    const outside = join(workspaceDir, "outside.png");
+    writeFileSync(outside, FAKE_PNG);
+    symlinkSync(outside, join(avatarDir, IMAGE_FILENAME));
+    writeManifestFile({
+      kind: "image",
+      traits: null,
+      source: "upload",
+      image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+    });
+    expect(await ensureAvatarRasterPath()).toBe(
+      join(avatarDir, IMAGE_FILENAME),
+    );
+    expect(await ensureAvatarRaster()).toBeNull();
+  });
+
+  test("returns null when the avatar dir is a symlink to another workspace", async () => {
+    const foreign = mkdtempSync(join(tmpdir(), "foreign-avatar-"));
+    writeFileSync(join(foreign, IMAGE_FILENAME), FAKE_PNG);
+    rmSync(avatarDir, { recursive: true, force: true });
+    symlinkSync(foreign, avatarDir);
+    writeManifestFile({
+      kind: "image",
+      traits: null,
+      source: "upload",
+      image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+    });
+    expect(await ensureAvatarRaster()).toBeNull();
+    rmSync(foreign, { recursive: true, force: true });
+  });
+
+  test("returns null for an image avatar whose PNG is missing", async () => {
+    writeManifestFile({
+      kind: "image",
+      traits: null,
+      source: "upload",
+      image: { updatedAt: new Date().toISOString(), etag: "0123456789abcdef" },
+    });
+    expect(await ensureAvatarRaster()).toBeNull();
+    expect(existsSync(join(avatarDir, IMAGE_FILENAME))).toBe(false);
+  });
+
+  test("returns null for a character when resvg is unavailable", async () => {
+    writeManifestFile({
+      kind: "character",
+      traits: VALID_TRAITS,
+      source: "builder",
+      image: null,
+    });
+    __setResvgCacheForTests({ available: false, error: new Error("nope") });
+    expect(await ensureAvatarRaster()).toBeNull();
+    expect(existsSync(join(avatarDir, IMAGE_FILENAME))).toBe(false);
+  });
+
+  test(
+    "re-renders a character whose PNG is missing",
+    async () => {
+      writeManifestFile({
+        kind: "character",
+        traits: VALID_TRAITS,
+        source: "builder",
+        image: null,
+      });
+      const raster = await ensureAvatarRaster();
+      if (!isResvgAvailable()) {
+        expect(raster).toBeNull();
+        return;
+      }
+      expect(raster).not.toBeNull();
+      expect(raster!.length).toBeGreaterThan(0);
+      // PNG magic bytes
+      expect(
+        raster!.subarray(0, 4).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47])),
+      ).toBe(true);
+      expect(existsSync(join(avatarDir, IMAGE_FILENAME))).toBe(true);
+    },
+    NATIVE_RENDER_TEST_TIMEOUT_MS,
+  );
+
+  test("accepts an explicit state instead of reading the manifest", async () => {
+    writeFileSync(join(avatarDir, IMAGE_FILENAME), FAKE_PNG);
+    // No manifest on disk; explicit `none` wins over the legacy PNG.
+    expect(
+      await ensureAvatarRaster({
+        kind: "none",
+        traits: null,
+        source: null,
+        image: null,
+      }),
+    ).toBeNull();
+  });
+
+  describe("ensureAvatarRasterPath", () => {
+    test("returns null for kind none", async () => {
+      writeFileSync(join(avatarDir, IMAGE_FILENAME), FAKE_PNG);
+      writeManifestFile({
+        kind: "none",
+        traits: null,
+        source: null,
+        image: null,
+      });
+      expect(await ensureAvatarRasterPath()).toBeNull();
+    });
+
+    test("returns the path of an existing PNG without reading it", async () => {
+      writeFileSync(join(avatarDir, IMAGE_FILENAME), FAKE_PNG);
+      writeManifestFile({
+        kind: "image",
+        traits: null,
+        source: "upload",
+        image: {
+          updatedAt: new Date().toISOString(),
+          etag: "0123456789abcdef",
+        },
+      });
+      expect(await ensureAvatarRasterPath()).toBe(
+        join(avatarDir, IMAGE_FILENAME),
+      );
+    });
+
+    test("returns null for a symlinked PNG but still reports its path", async () => {
+      const outside = join(workspaceDir, "outside.png");
+      writeFileSync(outside, FAKE_PNG);
+      symlinkSync(outside, join(avatarDir, IMAGE_FILENAME));
+      writeManifestFile({
+        kind: "image",
+        traits: null,
+        source: "upload",
+        image: {
+          updatedAt: new Date().toISOString(),
+          etag: "0123456789abcdef",
+        },
+      });
+      expect(await ensureAvatarRasterPath()).toBe(
+        join(avatarDir, IMAGE_FILENAME),
+      );
+      expect(await ensureAvatarRaster()).toBeNull();
+    });
+
+    test("returns null for an image avatar whose PNG is missing", async () => {
+      writeManifestFile({
+        kind: "image",
+        traits: null,
+        source: "upload",
+        image: {
+          updatedAt: new Date().toISOString(),
+          etag: "0123456789abcdef",
+        },
+      });
+      expect(await ensureAvatarRasterPath()).toBeNull();
+    });
+
+    test("returns null for a character when resvg is unavailable", async () => {
+      writeManifestFile({
+        kind: "character",
+        traits: VALID_TRAITS,
+        source: "builder",
+        image: null,
+      });
+      __setResvgCacheForTests({ available: false, error: new Error("nope") });
+      expect(await ensureAvatarRasterPath()).toBeNull();
+      expect(existsSync(join(avatarDir, IMAGE_FILENAME))).toBe(false);
+    });
+
+    test(
+      "re-renders a character whose PNG is missing and returns its path",
+      async () => {
+        writeManifestFile({
+          kind: "character",
+          traits: VALID_TRAITS,
+          source: "builder",
+          image: null,
+        });
+        const path = await ensureAvatarRasterPath();
+        if (!isResvgAvailable()) {
+          expect(path).toBeNull();
+          return;
+        }
+        expect(path).toBe(join(avatarDir, IMAGE_FILENAME));
+        expect(existsSync(path!)).toBe(true);
+      },
+      NATIVE_RENDER_TEST_TIMEOUT_MS,
+    );
+  });
+});