@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/host-transfer-routes-targeted.test.ts

@@ -99,7 +99,7 @@ afterAll(() => {
 
 const handleTransferContentGet = ROUTES.find(
   (r) => r.endpoint === "transfers/:transferId/content" && r.method === "GET",
-)!.handler;
+)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
 
 const handleTransferContentPut = ROUTES.find(
   (r) => r.endpoint === "transfers/:transferId/content" && r.method === "PUT",
@@ -107,7 +107,7 @@ const handleTransferContentPut = ROUTES.find(
 
 const handleTransferResult = ROUTES.find(
   (r) => r.endpoint === "host-transfer-result",
-)!.handler;
+)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -186,15 +186,13 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("getTransferContent NOT called on 400", () => {
+    test("getTransferContent NOT called on 400", async () => {
       stubTargetClientId = "client-A";
-      try {
-        handleTransferContentGet({
-          pathParams: { transferId: TEST_TRANSFER_ID },
-        });
-      } catch {
+      await handleTransferContentGet({
+        pathParams: { transferId: TEST_TRANSFER_ID },
+      }).catch(() => {
         // expected
-      }
+      });
       expect(getTransferContentCalls).toHaveLength(0);
     });
   });
@@ -212,16 +210,14 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("getTransferContent NOT called on 403", () => {
+    test("getTransferContent NOT called on 403", async () => {
       stubTargetClientId = "client-A";
-      try {
-        handleTransferContentGet({
-          pathParams: { transferId: TEST_TRANSFER_ID },
-          headers: { "x-vellum-client-id": "client-B" },
-        });
-      } catch {
+      await handleTransferContentGet({
+        pathParams: { transferId: TEST_TRANSFER_ID },
+        headers: { "x-vellum-client-id": "client-B" },
+      }).catch(() => {
         // expected
-      }
+      });
       expect(getTransferContentCalls).toHaveLength(0);
     });
   });
@@ -526,23 +522,19 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
       );
     });
 
-    test("resolveTransferResult NOT called on 400", () => {
+    test("resolveTransferResult NOT called on 400", async () => {
       registerHostTransferPending("client-A");
-      try {
-        handleTransferResult({ body: resultBody() });
-      } catch {
+      await handleTransferResult({ body: resultBody() }).catch(() => {
         // expected
-      }
+      });
       expect(resolveTransferResultCalls).toHaveLength(0);
     });
 
-    test("pending interaction still present after 400", () => {
+    test("pending interaction still present after 400", async () => {
       registerHostTransferPending("client-A");
-      try {
-        handleTransferResult({ body: resultBody() });
-      } catch {
+      await handleTransferResult({ body: resultBody() }).catch(() => {
         // expected
-      }
+      });
       expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
     });
   });
@@ -560,29 +552,25 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("resolveTransferResult NOT called on 403", () => {
+    test("resolveTransferResult NOT called on 403", async () => {
       registerHostTransferPending("client-A");
-      try {
-        handleTransferResult({
-          body: resultBody(),
-          headers: { "x-vellum-client-id": "client-B" },
-        });
-      } catch {
+      await handleTransferResult({
+        body: resultBody(),
+        headers: { "x-vellum-client-id": "client-B" },
+      }).catch(() => {
         // expected
-      }
+      });
       expect(resolveTransferResultCalls).toHaveLength(0);
     });
 
-    test("pending interaction still present after 403", () => {
+    test("pending interaction still present after 403", async () => {
       registerHostTransferPending("client-A");
-      try {
-        handleTransferResult({
-          body: resultBody(),
-          headers: { "x-vellum-client-id": "client-B" },
-        });
-      } catch {
+      await handleTransferResult({
+        body: resultBody(),
+        headers: { "x-vellum-client-id": "client-B" },
+      }).catch(() => {
         // expected
-      }
+      });
       expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
     });
   });

package/src/__tests__/http-conversation-lineage.test.ts

@@ -41,7 +41,7 @@ import { rawRun } from "../memory/raw-query.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 type ConversationSummary = {
   id: string;

package/src/__tests__/http-user-message-parity.test.ts

@@ -62,6 +62,21 @@ mock.module("../runtime/guardian-reply-router.js", () => ({
   routeGuardianReply: routeGuardianReplyMock,
 }));
 
+// Stub for the shared reset-drift helper. handleSendMessage only consumes its
+// result (a guardian TrustContext or null) on a first-pass-unknown actor; the
+// gate itself is covered in runtime/__tests__/guardian-vellum-migration.test.ts.
+const reResolveCalls: string[] = [];
+let mockReResolve: { trustClass: string; sourceChannel: string } | null = null;
+mock.module("../runtime/guardian-vellum-migration.js", () => ({
+  reResolveTrustOnResetDrift: async (
+    incomingPrincipalId: string,
+    _sourceChannel: string,
+  ) => {
+    reResolveCalls.push(incomingPrincipalId);
+    return mockReResolve;
+  },
+}));
+
 mock.module("../memory/canonical-guardian-store.js", () => ({
   createCanonicalGuardianRequest: () => ({
     id: "canonical-id",
@@ -104,17 +119,32 @@ mock.module("../memory/conversation-crud.js", () => ({
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
-  resolveLocalTrustContext: () => ({
-    trustClass: "guardian",
-    sourceChannel: "vellum",
-  }),
+  findLocalGuardianPrincipalId: async () =>
+    mockGuardians?.find(
+      (g) => g.channelType === "vellum" && g.status === "active",
+    )?.principalId as string | undefined,
+}));
+
+let mockGuardians: Array<Record<string, unknown>> | null = [
+  {
+    channelType: "vellum",
+    contactId: "guardian-contact",
+    principalId: "test-user",
+    address: "test-user",
+    status: "active",
+  },
+];
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => mockGuardians,
+  guardianForChannel: (
+    list: Array<Record<string, unknown>>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
 }));
 
+// handleSendMessage wraps the first-pass resolve with withSourceChannel.
 mock.module("../runtime/trust-context-resolver.js", () => ({
-  resolveTrustContext: () => ({
-    trustClass: "guardian",
-    sourceChannel: "vellum",
-  }),
   withSourceChannel: (sourceChannel: unknown, ctx: unknown) => ({
     ...(ctx as Record<string, unknown>),
     sourceChannel,
@@ -454,3 +484,130 @@ describe("HTTP POST /v1/messages clientTimezone transport metadata", () => {
     expect(runAgentLoop).toHaveBeenCalledTimes(1);
   });
 });
+
+// ============================================================================
+// TRUST CONTEXT — derived from the gateway guardian binding
+// ============================================================================
+describe("HTTP POST /v1/messages trust context from the gateway binding", () => {
+  beforeEach(() => {
+    mockGuardians = [
+      {
+        channelType: "vellum",
+        contactId: "guardian-contact",
+        principalId: "test-user",
+        address: "test-user",
+        status: "active",
+      },
+    ];
+    reResolveCalls.length = 0;
+    mockReResolve = null;
+  });
+
+  function requestAs(principalId: string, sourceChannel = "vellum") {
+    return new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-vellum-actor-principal-id": principalId,
+        "x-vellum-principal-type": "actor",
+      },
+      body: JSON.stringify({
+        conversationKey: "trust-test-key",
+        content: "hi",
+        sourceChannel,
+        interface: "macos",
+      }),
+    });
+  }
+
+  async function trustContextFor(
+    principalId: string,
+    sourceChannel = "vellum",
+  ): Promise<Record<string, unknown>> {
+    let captured: Record<string, unknown> | undefined;
+    const conversation = makeConversation({
+      setTrustContext: (ctx: Record<string, unknown>) => {
+        captured = ctx;
+      },
+    });
+    const res = await callHandler(
+      (args) =>
+        handleSendMessage(args, {
+          sendMessageDeps: {
+            getOrCreateConversation: async () => conversation,
+            assistantEventHub: { publish: async () => {} } as any,
+            resolveAttachments: () => [],
+          },
+        }),
+      requestAs(principalId, sourceChannel),
+      undefined,
+      202,
+    );
+    expect(res.status).toBe(202);
+    return captured ?? {};
+  }
+
+  async function trustClassFor(principalId: string): Promise<string> {
+    return (await trustContextFor(principalId)).trustClass as string;
+  }
+
+  test("guardian principal resolves to guardian context, helper not called", async () => {
+    expect(await trustClassFor("test-user")).toBe("guardian");
+    expect(reResolveCalls).toEqual([]);
+  });
+
+  test("non-guardian principal: helper consulted, null result stays unknown", async () => {
+    mockReResolve = null;
+    expect(await trustClassFor("vellum-principal-stranger")).toBe("unknown");
+    expect(reResolveCalls).toEqual(["vellum-principal-stranger"]);
+  });
+
+  test("reset drift: helper returns guardian → route adopts it", async () => {
+    mockGuardians = [
+      {
+        channelType: "vellum",
+        contactId: "guardian-contact",
+        principalId: "vellum-principal-stale",
+        address: "vellum-principal-stale",
+        status: "active",
+      },
+    ];
+    mockReResolve = { trustClass: "guardian", sourceChannel: "vellum" };
+
+    expect(await trustClassFor("vellum-principal-healed")).toBe("guardian");
+    expect(reResolveCalls).toEqual(["vellum-principal-healed"]);
+  });
+
+  test("helper returns an unknown-class ctx → trust stays unknown (not adopted)", async () => {
+    mockGuardians = [
+      {
+        channelType: "vellum",
+        contactId: "guardian-contact",
+        principalId: "vellum-principal-stale",
+        address: "vellum-principal-stale",
+        status: "active",
+      },
+    ];
+    mockReResolve = { trustClass: "unknown", sourceChannel: "vellum" };
+
+    expect(await trustClassFor("vellum-principal-healed")).toBe("unknown");
+  });
+
+  test("dev-bypass maps the gateway guardian principal to guardian", async () => {
+    expect(await trustClassFor("dev-bypass")).toBe("guardian");
+  });
+
+  test("dev-bypass fails closed to unknown on an empty gateway", async () => {
+    // No active gateway binding: dev-bypass cannot translate to a real guardian,
+    // and the helper (null) leaves trust unknown — parity with /v1/surface-actions.
+    mockGuardians = [];
+    mockReResolve = null;
+    expect(await trustClassFor("dev-bypass")).toBe("unknown");
+  });
+
+  test("preserves the request body channel on the guardian-match happy path", async () => {
+    const ctx = await trustContextFor("test-user", "telegram");
+    expect(ctx.trustClass).toBe("guardian");
+    expect(ctx.sourceChannel).toBe("telegram");
+  });
+});

package/src/__tests__/image-recovery-hook.test.ts

@@ -51,7 +51,7 @@ import {
 } from "../plugins/registry.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
-initializeDb();
+await initializeDb();
 
 /** Provider rejection text matched by `isImageDimensionsTooLargeError`. */
 const IMAGE_ERROR_MESSAGE =

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -74,7 +74,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { createInvite, revokeInvite } from "../memory/invite-store.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -93,7 +93,6 @@ function resetState(): void {
   db.run("DELETE FROM assistant_ingress_invites");
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
-  db.run("DELETE FROM channel_guardian_approval_requests");
   db.run("DELETE FROM notification_events");
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");

package/src/__tests__/inbound-trust-verdict.test.ts

@@ -0,0 +1,254 @@
+/**
+ * The inbound text path builds `trustCtx` from the gateway-stamped
+ * `sourceMetadata.trustVerdict` via `trustContextFromVerdict`. Admission follows
+ * the trust class + floor, and the Slack requester timezone attaches to the
+ * resulting context.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Enable the channel-trust-floors flag so the admission-policy stage runs.
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) => key === "channel-trust-floors",
+}));
+
+mock.module("../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async () => {},
+}));
+
+import type { TrustVerdict } from "@vellumai/gateway-client";
+
+import type { TrustContext } from "../daemon/trust-context.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { messages } from "../memory/schema.js";
+import {
+  handleChannelInbound,
+  setAdapterProcessMessage,
+} from "./helpers/channel-test-adapter.js";
+
+await initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM canonical_guardian_requests");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
+}
+
+/** Capture the `trustContext` the handler dispatches to the agent loop. */
+function captureTrustContextProcessor(captured: { ctx?: TrustContext }) {
+  return async (
+    conversationId: string,
+    _content: string,
+    options?: Record<string, unknown>,
+  ) => {
+    captured.ctx = options?.trustContext as TrustContext | undefined;
+    const messageId = `msg-${Date.now()}-${Math.random()
+      .toString(36)
+      .slice(2, 8)}`;
+    getDb()
+      .insert(messages)
+      .values({
+        id: messageId,
+        conversationId,
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "hello" }]),
+        createdAt: Date.now(),
+      })
+      .run();
+    return { messageId };
+  };
+}
+
+function makeInboundRequest(
+  sourceMetadata: Record<string, unknown>,
+  overrides: Record<string, unknown> = {},
+): Request {
+  return new Request("http://localhost/channels/inbound", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Gateway-Origin": "test-token",
+    },
+    body: JSON.stringify({
+      sourceChannel: "telegram",
+      interface: "telegram",
+      conversationExternalId: "chat-123",
+      externalMessageId: `msg-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2, 8)}`,
+      content: "hello",
+      actorExternalId: "user-1",
+      replyCallbackUrl: "https://gateway.test/deliver/telegram",
+      sourceMetadata,
+      ...overrides,
+    }),
+  });
+}
+
+/** A full member verdict (ACL passes) for the given trust class. */
+function memberVerdict(
+  trustClass: TrustVerdict["trustClass"],
+  overrides: Partial<TrustVerdict> = {},
+): TrustVerdict {
+  return {
+    trustClass,
+    canonicalSenderId: "user-1",
+    contactId: "contact-1",
+    channelId: "channel-1",
+    type: "telegram",
+    address: "user-1",
+    externalChatId: "chat-123",
+    status: "active",
+    policy: "allow",
+    memberDisplayName: "Member One",
+    ...overrides,
+  } satisfies TrustVerdict;
+}
+
+describe("inbound trust verdict → TrustContext", () => {
+  beforeEach(() => {
+    resetTables();
+    setAdapterProcessMessage(undefined);
+  });
+
+  test("guardian verdict admits with guardian-class trustCtx and guardian fields", async () => {
+    const verdict = memberVerdict("guardian", {
+      guardianExternalUserId: "user-1",
+      guardianDeliveryChatId: "guardian-chat-1",
+      guardianPrincipalId: "vellum-principal-1",
+    });
+
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: verdict,
+        admissionPolicy: "trusted_contacts",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBeUndefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(captured.ctx?.trustClass).toBe("guardian");
+    expect(captured.ctx?.guardianExternalUserId).toBe("user-1");
+    expect(captured.ctx?.guardianChatId).toBe("guardian-chat-1");
+    expect(captured.ctx?.guardianPrincipalId).toBe("vellum-principal-1");
+  });
+
+  test("trusted_contact admitted under a trusted_contacts floor", async () => {
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: memberVerdict("trusted_contact"),
+        admissionPolicy: "trusted_contacts",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBeUndefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(captured.ctx?.trustClass).toBe("trusted_contact");
+  });
+
+  test("trusted_contact denied under a guardian_only floor", async () => {
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: memberVerdict("trusted_contact"),
+        admissionPolicy: "guardian_only",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBe(true);
+    expect(body.reason).toBe("admission_policy_guardian_only");
+  });
+
+  test("present unknown (stranger) verdict admitted under a strangers floor", async () => {
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: {
+          trustClass: "unknown",
+          canonicalSenderId: "user-1",
+        } satisfies TrustVerdict,
+        admissionPolicy: "strangers",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBeUndefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(captured.ctx?.trustClass).toBe("unknown");
+  });
+
+  test("present unknown (stranger) verdict denied under a trusted_contacts floor", async () => {
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: {
+          trustClass: "unknown",
+          canonicalSenderId: "user-1",
+        } satisfies TrustVerdict,
+        admissionPolicy: "trusted_contacts",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBe(true);
+    expect(body.reason).toBe("not_a_member");
+  });
+
+  test("slack requester timezone is attached to the verdict-sourced trustCtx", async () => {
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest(
+        {
+          trustVerdict: memberVerdict("trusted_contact", {
+            type: "slack",
+            externalChatId: "slack-chan-1",
+          }),
+          admissionPolicy: "trusted_contacts",
+          timezone: "America/New_York",
+          timezoneLabel: "ET",
+          timezoneOffsetSeconds: -18000,
+        },
+        {
+          sourceChannel: "slack",
+          interface: "slack",
+          conversationExternalId: "slack-chan-1",
+          replyCallbackUrl: "https://gateway.test/deliver/slack",
+        },
+      ),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(captured.ctx?.trustClass).toBe("trusted_contact");
+    expect(captured.ctx?.requesterTimezone).toBe("America/New_York");
+    expect(captured.ctx?.requesterTimezoneLabel).toBe("ET");
+    expect(captured.ctx?.requesterTimezoneOffsetSeconds).toBe(-18000);
+  });
+});

package/src/__tests__/inference-profile-reaper.test.ts

@@ -27,7 +27,7 @@ import {
 } from "../runtime/routes/inference-profile-session-reaper.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 function clearTables(): void {
   const db = getDb();

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -65,7 +65,7 @@ import {
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 
-initializeDb();
+await initializeDb();
 
 import {
   closeInferenceProfileSession,

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -43,7 +43,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 const openRoute = ROUTES.find(
   (r) => r.operationId === "inference_profile_open",

package/src/__tests__/injector-chain.test.ts

@@ -84,7 +84,7 @@ import { getWorkspacePromptPath } from "../util/platform.js";
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
 // turns; with no seeded rows the focus loader resolves to null.
-initializeDb();
+await initializeDb();
 
 // `makeTurnContext` and the workspace registry seed share this id so the
 // `workspace-context` injector resolves the seeded block for the turn.