@vellumai/assistant 0.6.4 → 0.6.6

package/src/approvals/__tests__/guardian-feed-event.test.ts

@@ -0,0 +1,304 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks — must be in place before dynamic imports resolve transitive
+// dependencies (emit-feed-event -> feed-writer -> assistant-event-hub).
+// ---------------------------------------------------------------------------
+
+const publishSpy = mock<(event: unknown) => Promise<void>>(async () => {});
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: publishSpy,
+    subscribe: () => () => {},
+  },
+}));
+
+// Capture emitFeedEvent calls without hitting the real persistence layer.
+const emitFeedEventCalls: Array<{
+  source: string;
+  title: string;
+  summary: string;
+  dedupKey?: string;
+  urgency?: string;
+}> = [];
+
+mock.module("../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: async (params: {
+    source: string;
+    title: string;
+    summary: string;
+    dedupKey?: string;
+    urgency?: string;
+  }) => {
+    emitFeedEventCalls.push(params);
+    return { id: params.dedupKey ?? "mock-id", ...params };
+  },
+}));
+
+// Stub heavy transitive dependencies that the resolvers import so the
+// test can load the module without standing up a full daemon environment.
+
+mock.module("../../calls/call-domain.js", () => ({
+  answerCall: async () => ({ ok: true }),
+}));
+
+mock.module("../../config/env.js", () => ({
+  getGatewayInternalBaseUrl: () => "http://localhost:0",
+}));
+
+mock.module("../../contacts/contact-store.js", () => ({
+  findContactChannel: () => null,
+}));
+
+mock.module("../../contacts/contacts-write.js", () => ({
+  upsertContactChannel: () => {},
+}));
+
+mock.module("../../memory/canonical-guardian-store.js", () => ({
+  getCanonicalGuardianRequest: () => null,
+}));
+
+mock.module("../../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async () => {},
+}));
+
+mock.module("../../notifications/signal.js", () => ({
+  isNotificationSourceChannel: () => false,
+}));
+
+mock.module("../../permissions/trust-store.js", () => ({
+  addRule: () => {},
+}));
+
+mock.module("../../permissions/v2-consent-policy.js", () => ({
+  isPermissionControlsV2Enabled: () => false,
+}));
+
+mock.module("../../runtime/assistant-scope.js", () => ({
+  DAEMON_INTERNAL_ASSISTANT_ID: "self",
+}));
+
+mock.module("../../runtime/auth/token-service.js", () => ({
+  mintDaemonDeliveryToken: () => "mock-token",
+}));
+
+mock.module("../../runtime/channel-approval-types.js", () => ({}));
+
+mock.module("../../runtime/channel-verification-service.js", () => ({
+  createOutboundSession: () => ({
+    sessionId: "mock-session",
+    secret: "123456",
+  }),
+}));
+
+mock.module("../../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async () => {},
+}));
+
+// Stub pending-interactions so tool_approval resolver can find/resolve.
+let mockInteraction: Record<string, unknown> | null = null;
+let mockResolved: Record<string, unknown> | null = null;
+
+mock.module("../../runtime/pending-interactions.js", () => ({
+  get: () => mockInteraction,
+  resolve: () => mockResolved,
+}));
+
+mock.module("../../tools/registry.js", () => ({
+  getTool: () => null,
+}));
+
+mock.module("../../tools/tool-approval-handler.js", () => ({
+  TC_GRANT_WAIT_MAX_MS: 30_000,
+}));
+
+// ---------------------------------------------------------------------------
+// Import the resolvers after all mocks are in place.
+// ---------------------------------------------------------------------------
+
+const { getResolver } = await import("../guardian-request-resolvers.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeRequest(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "req-001",
+    kind: "tool_approval",
+    status: "pending",
+    conversationId: "conv-abc",
+    toolName: "web_fetch",
+    sourceChannel: "vellum",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  } as never;
+}
+
+function makeCtx(
+  request: ReturnType<typeof makeRequest>,
+  decision: { action: string; userText?: string },
+) {
+  return {
+    request,
+    decision,
+    actor: {
+      actorPrincipalId: "principal-1",
+      actorExternalUserId: undefined,
+      channel: "vellum",
+      guardianPrincipalId: "principal-1",
+    },
+  } as never;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("guardian approval feed events", () => {
+  beforeEach(() => {
+    emitFeedEventCalls.length = 0;
+    mockInteraction = {
+      confirmationDetails: { toolName: "web_fetch" },
+    };
+    mockResolved = {
+      conversation: {
+        handleConfirmationResponse: () => {},
+      },
+    };
+  });
+
+  afterEach(() => {
+    mockInteraction = null;
+    mockResolved = null;
+  });
+
+  // -----------------------------------------------------------------------
+  // tool_approval (pendingInteractionResolver)
+  // -----------------------------------------------------------------------
+
+  describe("tool_approval", () => {
+    test("approval emits with title 'Tool Request Approved'", async () => {
+      const resolver = getResolver("tool_approval")!;
+      expect(resolver).toBeDefined();
+
+      const request = makeRequest();
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      // Allow microtask for the void promise to settle.
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Tool Request Approved",
+      );
+      expect(call).toBeDefined();
+      expect(call!.source).toBe("assistant");
+      expect(call!.summary).toContain("Approved");
+      expect(call!.summary).toContain("web_fetch");
+      expect(call!.urgency).toBeUndefined();
+    });
+
+    test("rejection emits with title 'Tool Request Denied' and urgency 'medium'", async () => {
+      const resolver = getResolver("tool_approval")!;
+
+      const request = makeRequest();
+      const ctx = makeCtx(request, { action: "reject" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Tool Request Denied",
+      );
+      expect(call).toBeDefined();
+      expect(call!.urgency).toBe("medium");
+      expect(call!.summary).toContain("Denied");
+    });
+
+    test("dedupKey includes request ID", async () => {
+      const resolver = getResolver("tool_approval")!;
+
+      const request = makeRequest({ id: "req-unique-42" });
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls[0];
+      expect(call).toBeDefined();
+      expect(call!.dedupKey).toBe("guardian-approval:req-unique-42");
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // access_request (accessRequestResolver)
+  // -----------------------------------------------------------------------
+
+  describe("access_request", () => {
+    test("approval emits with title 'Access Request Approved'", async () => {
+      const resolver = getResolver("access_request")!;
+      expect(resolver).toBeDefined();
+
+      const request = makeRequest({
+        kind: "access_request",
+        requesterExternalUserId: "user-123",
+        requesterChatId: "chat-456",
+      });
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Access Request Approved",
+      );
+      expect(call).toBeDefined();
+      expect(call!.source).toBe("assistant");
+      expect(call!.summary).toContain("Granted");
+      expect(call!.urgency).toBeUndefined();
+    });
+
+    test("denial emits with title 'Access Request Denied' and urgency 'medium'", async () => {
+      const resolver = getResolver("access_request")!;
+
+      const request = makeRequest({
+        kind: "access_request",
+        requesterExternalUserId: "user-123",
+        requesterChatId: "chat-456",
+      });
+      const ctx = makeCtx(request, { action: "reject" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls.find(
+        (c) => c.title === "Access Request Denied",
+      );
+      expect(call).toBeDefined();
+      expect(call!.urgency).toBe("medium");
+      expect(call!.summary).toContain("Denied");
+    });
+
+    test("dedupKey includes request ID", async () => {
+      const resolver = getResolver("access_request")!;
+
+      const request = makeRequest({
+        id: "req-access-99",
+        kind: "access_request",
+        requesterExternalUserId: "user-123",
+        requesterChatId: "chat-456",
+      });
+      const ctx = makeCtx(request, { action: "approve_once" });
+      await resolver.resolve(ctx);
+
+      await new Promise((r) => setTimeout(r, 10));
+
+      const call = emitFeedEventCalls[0];
+      expect(call).toBeDefined();
+      expect(call!.dedupKey).toBe("guardian-access:req-access-99");
+    });
+  });
+});

package/src/approvals/guardian-request-resolvers.ts

@@ -15,6 +15,7 @@ import { answerCall } from "../calls/call-domain.js";
 import { getGatewayInternalBaseUrl } from "../config/env.js";
 import { findContactChannel } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
+import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
   type CanonicalGuardianRequest,
   getCanonicalGuardianRequest,
@@ -266,6 +267,20 @@ const pendingInteractionResolver: GuardianRequestResolver = {
       ctx.emissionContext,
     );
 
+    const approved = decision.action !== "reject";
+    void emitFeedEvent({
+      source: "assistant",
+      title: approved ? "Tool Request Approved" : "Tool Request Denied",
+      summary: `${approved ? "Approved" : "Denied"} access to ${request.toolName ?? "unknown tool"}.`,
+      dedupKey: `guardian-approval:${request.id}`,
+      urgency: approved ? undefined : "medium",
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit guardian approval feed event",
+      );
+    });
+
     log.info(
       {
         event: "resolver_tool_approval_applied",
@@ -518,6 +533,19 @@ const accessRequestResolver: GuardianRequestResolver = {
         }
       }
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Access Request Denied",
+        summary: `Denied access request.`,
+        dedupKey: `guardian-access:${request.id}`,
+        urgency: "medium",
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit access request feed event",
+        );
+      });
+
       return {
         ok: true,
         applied: true,
@@ -558,6 +586,19 @@ const accessRequestResolver: GuardianRequestResolver = {
         "Access request resolver: voice approval — direct trusted-contact activation (no verification session)",
       );
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Access Request Approved",
+        summary: `Granted access request.`,
+        dedupKey: `guardian-access:${request.id}`,
+        urgency: undefined,
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit access request feed event",
+        );
+      });
+
       return { ok: true, applied: true };
     }
 
@@ -793,6 +834,19 @@ const accessRequestResolver: GuardianRequestResolver = {
       ? `Access approved for ${requesterLabel}. Give them this verification code: \`${session.secret}\`. The code expires in 10 minutes.`
       : `Access approved for ${requesterLabel}. Give them this verification code: \`${session.secret}\`. The code expires in 10 minutes. I could not notify them automatically, so please tell them to send the code manually.`;
 
+    void emitFeedEvent({
+      source: "assistant",
+      title: "Access Request Approved",
+      summary: `Granted access request.`,
+      dedupKey: `guardian-access:${request.id}`,
+      urgency: undefined,
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit access request feed event",
+      );
+    });
+
     return {
       ok: true,
       applied: true,
@@ -867,6 +921,19 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
         }
       }
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Tool Grant Denied",
+        summary: `Denied grant request for ${request.toolName ?? "unknown tool"}.`,
+        dedupKey: `guardian-grant:${request.id}`,
+        urgency: "medium",
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit tool grant denial feed event",
+        );
+      });
+
       return { ok: true, applied: true };
     }
 
@@ -965,6 +1032,19 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
       }
     }
 
+    void emitFeedEvent({
+      source: "assistant",
+      title: "Tool Grant Approved",
+      summary: `Approved grant request for ${request.toolName ?? "unknown tool"}.`,
+      dedupKey: `guardian-grant:${request.id}`,
+      urgency: undefined,
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit tool grant approval feed event",
+      );
+    });
+
     return { ok: true, applied: true, grantMinted: false };
   },
 };

package/src/avatar/resvg-lazy.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Tests for resvg-lazy and the writeTraitsAndRenderAvatar fallback it feeds.
+ *
+ * Covers the graceful-degradation path when the native @resvg/resvg-js binding
+ * is missing (e.g. bun install skipped the platform-specific optional
+ * dependency). The lazy loader must warn once and report unavailability, and
+ * writeTraitsAndRenderAvatar must return `native_unavailable` so the HTTP
+ * layer can respond 503 instead of 500.
+ *
+ * Bun's `mock.module` evaluates factories eagerly on re-registration, which
+ * makes it awkward to flip a module between "throws" and "returns fake
+ * export" across tests in the same file. We instead install a single
+ * throwing mock at module scope for the require-path test, and use the
+ * `__setResvgCacheForTests` / `__resetResvgCacheForTests` hooks to drive the
+ * rest of the cases deterministically.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type LogCall = { bindings: unknown; msg: string };
+const warnCalls: LogCall[] = [];
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    warn: (bindings: unknown, msg: string) => {
+      warnCalls.push({ bindings, msg });
+    },
+    info: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+  }),
+}));
+
+mock.module("../util/platform.js", () => ({
+  AVATAR_IMAGE_FILENAME: "avatar-image.png",
+  getAvatarDir: () => "/tmp/vellum-test-avatar-never-written",
+}));
+
+// Install a throwing @resvg/resvg-js mock at module scope. Bun only calls
+// this factory the first time the module is required within the test worker;
+// later `require` calls return whatever was produced by that first call (or
+// throw, if the factory threw). That's exactly what we want for the
+// "require fails" test below.
+mock.module("@resvg/resvg-js", () => {
+  throw new Error("Cannot require module @resvg/resvg-js-darwin-x64");
+});
+
+describe("resvg-lazy — require failure path", () => {
+  beforeEach(async () => {
+    warnCalls.length = 0;
+    const { __resetResvgCacheForTests } = await import("./resvg-lazy.js");
+    __resetResvgCacheForTests();
+  });
+
+  test("real require failure triggers warn log with platform context", async () => {
+    const { isResvgAvailable } = await import("./resvg-lazy.js");
+
+    // Call twice — caching must prevent a duplicate warn.
+    expect(isResvgAvailable()).toBe(false);
+    expect(isResvgAvailable()).toBe(false);
+
+    expect(warnCalls.length).toBe(1);
+    const call = warnCalls[0]!;
+    const bindings = call.bindings as Record<string, unknown>;
+    expect(bindings.platform).toBe(process.platform);
+    expect(bindings.arch).toBe(process.arch);
+    expect(String(bindings.module)).toContain("@resvg/resvg-js-");
+    expect(bindings.err).toBeInstanceOf(Error);
+    expect(call.msg).toContain("@resvg/resvg-js");
+  });
+});
+
+describe("resvg-lazy — API shape when unavailable", () => {
+  beforeEach(async () => {
+    warnCalls.length = 0;
+    const { __setResvgCacheForTests } = await import("./resvg-lazy.js");
+    __setResvgCacheForTests({
+      available: false,
+      error: new Error("Cannot require module @resvg/resvg-js-darwin-x64"),
+    });
+  });
+
+  test("isResvgAvailable returns false", async () => {
+    const { isResvgAvailable } = await import("./resvg-lazy.js");
+    expect(isResvgAvailable()).toBe(false);
+  });
+
+  test("getResvg throws the underlying error", async () => {
+    const { getResvg } = await import("./resvg-lazy.js");
+    expect(() => getResvg()).toThrow(
+      /Cannot require module @resvg\/resvg-js-darwin-x64/,
+    );
+  });
+});
+
+describe("writeTraitsAndRenderAvatar — native module missing", () => {
+  beforeEach(async () => {
+    warnCalls.length = 0;
+    const { __setResvgCacheForTests } = await import("./resvg-lazy.js");
+    __setResvgCacheForTests({
+      available: false,
+      error: new Error("Cannot require module @resvg/resvg-js-darwin-x64"),
+    });
+  });
+
+  test("returns native_unavailable without attempting disk writes", async () => {
+    const { writeTraitsAndRenderAvatar } = await import("./traits-png-sync.js");
+
+    const result = writeTraitsAndRenderAvatar({
+      bodyShape: "blob",
+      eyeStyle: "curious",
+      color: "green",
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return; // narrow for TypeScript
+    expect(result.reason).toBe("native_unavailable");
+    expect(result.message).toContain("@resvg/resvg-js");
+  });
+
+  test("returns invalid_traits (not native_unavailable) when traits are bad", async () => {
+    const { writeTraitsAndRenderAvatar } = await import("./traits-png-sync.js");
+
+    // Empty traits object fails the shape check before we ever consult resvg.
+    const result = writeTraitsAndRenderAvatar({
+      bodyShape: "",
+      eyeStyle: "",
+      color: "",
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toBe("invalid_traits");
+  });
+});

package/src/avatar/resvg-lazy.ts

@@ -1,21 +1,94 @@
 import type { Resvg as ResvgType } from "@resvg/resvg-js";
 
-let ResvgClass: typeof ResvgType | undefined;
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("resvg-lazy");
+
+type ResvgLoadResult =
+  | { available: true; Resvg: typeof ResvgType }
+  | { available: false; error: Error };
+
+let cached: ResvgLoadResult | undefined;
+
+function loadResvg(): ResvgLoadResult {
+  try {
+    // Inline require is necessary here: @resvg/resvg-js loads a platform-specific
+    // native .node addon at import time. A top-level import would crash the daemon
+    // on startup inside bun --compile binaries where native addons are unavailable.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require("@resvg/resvg-js") as typeof import("@resvg/resvg-js");
+    return { available: true, Resvg: mod.Resvg };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    // Log once at warn level (not error) — the daemon should keep running and
+    // callers should fall back to a non-native path (ASCII only, or a 503 at
+    // the HTTP layer). Emitting at error level would page Sentry on every
+    // install that skipped the platform-specific optional dependency.
+    log.warn(
+      {
+        err: error,
+        platform: process.platform,
+        arch: process.arch,
+        module: `@resvg/resvg-js-${process.platform}-${process.arch}`,
+      },
+      "Failed to load @resvg/resvg-js native module — avatar PNG rendering will be unavailable. " +
+        "The platform-specific optional dependency is likely missing.",
+    );
+    return { available: false, error };
+  }
+}
+
+function getLoadResult(): ResvgLoadResult {
+  if (!cached) {
+    cached = loadResvg();
+  }
+  return cached;
+}
+
+/**
+ * Returns `true` if the native @resvg/resvg-js binding loaded successfully on
+ * first access. Callers should check this before calling `getResvg()` and fall
+ * back to a non-native path (e.g. ASCII-only rendering, or a 503 at the HTTP
+ * layer) when it is `false`.
+ *
+ * Loading is attempted lazily on first access and the result is cached, so
+ * calling this multiple times is cheap and does not re-emit warnings.
+ */
+export function isResvgAvailable(): boolean {
+  return getLoadResult().available;
+}
 
 /**
  * Returns the Resvg constructor, loading the native module on first call.
  * Defers the native-addon require so the daemon can start even when the
  * platform-specific binary is unavailable (e.g. inside a bun --compile
  * single-file executable).
+ *
+ * Throws if the native module could not be loaded. Callers that need to
+ * degrade gracefully should check `isResvgAvailable()` first.
  */
 export function getResvg(): typeof ResvgType {
-  if (!ResvgClass) {
-    // Inline require is necessary here: @resvg/resvg-js loads a platform-specific
-    // native .node addon at import time. A top-level import would crash the daemon
-    // on startup inside bun --compile binaries where native addons are unavailable.
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const mod = require("@resvg/resvg-js") as typeof import("@resvg/resvg-js");
-    ResvgClass = mod.Resvg;
+  const result = getLoadResult();
+  if (!result.available) {
+    throw result.error;
   }
-  return ResvgClass;
+  return result.Resvg;
+}
+
+/**
+ * Test-only hook to reset the cached load result between test cases. Do not
+ * call from production code.
+ */
+export function __resetResvgCacheForTests(): void {
+  cached = undefined;
+}
+
+/**
+ * Test-only hook to force the cached load result to a specific state without
+ * exercising the real `require`. Useful for asserting the unavailable path
+ * without depending on Bun's module-mock behavior (which re-imports the real
+ * module after the factory throws once).
+ */
+export function __setResvgCacheForTests(result: ResvgLoadResult): void {
+  cached = result;
 }