@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/__tests__/access-request-seed-content-blocks.test.ts

@@ -1,8 +1,30 @@
 import { describe, expect, test } from "bun:test";
 
 import { parseAccessRequestPayload } from "../notifications/access-request-copy.js";
+import type {
+  ApprovalCardBlock,
+  ApprovalCardFallbackBlock,
+  ApprovalCardSurfaceBlock,
+} from "../notifications/approval-card-builder.js";
 import { buildAccessRequestSeedContentBlocks } from "../notifications/approval-card-data.js";
 
+// The builder returns a schema-derived `ApprovalCardBlock[]`, so tests narrow by
+// the block's discriminant instead of casting to `Record<string, unknown>`.
+function surfaceOf(blocks: ApprovalCardBlock[]): ApprovalCardSurfaceBlock {
+  const block = blocks[0];
+  if (block?.type !== "ui_surface") {
+    throw new Error("expected a ui_surface block at index 0");
+  }
+  return block;
+}
+function textOf(blocks: ApprovalCardBlock[]): ApprovalCardFallbackBlock {
+  const block = blocks[1];
+  if (block?.type !== "text") {
+    throw new Error("expected a text fallback block at index 1");
+  }
+  return block;
+}
+
 describe("buildAccessRequestSeedContentBlocks", () => {
   const basePayload: Record<string, unknown> = {
     requestId: "req-123",
@@ -20,173 +42,131 @@ describe("buildAccessRequestSeedContentBlocks", () => {
   test("produces a ui_surface block and a text fallback block", () => {
     const blocks = buildAccessRequestSeedContentBlocks(basePayload);
     expect(blocks).toHaveLength(2);
-    expect((blocks[0] as Record<string, unknown>).type).toBe("ui_surface");
-    expect((blocks[1] as Record<string, unknown>).type).toBe("text");
+    expect(surfaceOf(blocks).type).toBe("ui_surface");
+    expect(textOf(blocks).type).toBe("text");
+    // The fallback block is flagged so surface-capable clients skip it.
+    expect(textOf(blocks)._surfaceFallback).toBe(true);
   });
 
   test("card surface has correct surfaceType and surfaceId", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const surface = blocks[0] as Record<string, unknown>;
+    const surface = surfaceOf(buildAccessRequestSeedContentBlocks(basePayload));
     expect(surface.surfaceType).toBe("card");
     expect(surface.surfaceId).toBe("access-request-req-123");
     expect(surface.title).toBe("Access Request");
   });
 
   test("card data uses actorDisplayName as title", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const surface = blocks[0] as Record<string, unknown>;
-    const data = surface.data as Record<string, unknown>;
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
     expect(data.title).toBe("Alice");
     expect(data.subtitle).toBe("Requesting access to the assistant");
   });
 
   test("card data falls back to senderIdentifier when no displayName", () => {
-    const payload = { ...basePayload, actorDisplayName: undefined };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    expect(data.title).toBe("U999");
+    const blocks = buildAccessRequestSeedContentBlocks({
+      ...basePayload,
+      actorDisplayName: undefined,
+    });
+    expect(surfaceOf(blocks).data.title).toBe("U999");
   });
 
   test("card data falls back to 'Someone' when no identity", () => {
-    const payload = {
+    const blocks = buildAccessRequestSeedContentBlocks({
       ...basePayload,
       actorDisplayName: undefined,
       senderIdentifier: undefined,
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    expect(data.title).toBe("Someone");
+    });
+    expect(surfaceOf(blocks).data.title).toBe("Someone");
   });
 
   test("includes username and source in metadata", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const metadata = data.metadata as Array<{ label: string; value: string }>;
-    expect(metadata).toContainEqual({
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
+    expect(data.metadata).toContainEqual({
       label: "Username",
       value: "@alice",
     });
-    expect(metadata).toContainEqual({
+    expect(data.metadata).toContainEqual({
       label: "Source",
       value: "Slack — #C01ABC",
     });
   });
 
   test("DM channel renders as Direct message", () => {
-    const payload = { ...basePayload, conversationExternalId: "D01XYZ" };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const metadata = data.metadata as Array<{ label: string; value: string }>;
-    expect(metadata).toContainEqual({
+    const blocks = buildAccessRequestSeedContentBlocks({
+      ...basePayload,
+      conversationExternalId: "D01XYZ",
+    });
+    expect(surfaceOf(blocks).data.metadata).toContainEqual({
       label: "Source",
       value: "Slack — Direct message",
     });
   });
 
   test("body includes message preview when present", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
     expect(data.body).toContain("Hello, I need help with something");
   });
 
   test("body includes trust signal warnings", () => {
-    const payload = {
-      ...basePayload,
-      isStranger: true,
-      isRestricted: true,
-      previousMemberStatus: "revoked",
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const body = data.body as string;
-    expect(body).toContain("External Slack user");
-    expect(body).toContain("Guest / restricted account");
-    expect(body).toContain("previously revoked");
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks({
+        ...basePayload,
+        isStranger: true,
+        isRestricted: true,
+        previousMemberStatus: "revoked",
+      }),
+    );
+    expect(data.body).toContain("External Slack user");
+    expect(data.body).toContain("Guest / restricted account");
+    expect(data.body).toContain("previously revoked");
   });
 
   test("body includes Slack message permalink", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    const body = data.body as string;
-    expect(body).toContain("View message");
-    expect(body).toContain(
+    const { data } = surfaceOf(
+      buildAccessRequestSeedContentBlocks(basePayload),
+    );
+    expect(data.body).toContain("View message");
+    expect(data.body).toContain(
       "https://slack.com/archives/C01ABC/p1700000000000100",
     );
   });
 
   test("text fallback block contains contract text", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const textBlock = blocks[1] as Record<string, unknown>;
-    expect(textBlock.type).toBe("text");
-    const text = textBlock.text as string;
-    expect(text).toContain("requesting access to the assistant");
-    expect(text).toContain("ABC123");
+    const textBlock = textOf(buildAccessRequestSeedContentBlocks(basePayload));
+    expect(textBlock.text).toContain("requesting access to the assistant");
+    expect(textBlock.text).toContain("ABC123");
   });
 
   test("body shows fallback when no preview/warnings/permalink", () => {
-    const payload = {
+    const blocks = buildAccessRequestSeedContentBlocks({
       requestId: "req-456",
       requestCode: "XYZ",
       senderIdentifier: "someone",
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const data = (blocks[0] as Record<string, unknown>).data as Record<
-      string,
-      unknown
-    >;
-    expect(data.body).toBe("No additional context available.");
+    });
+    expect(surfaceOf(blocks).data.body).toBe(
+      "No additional context available.",
+    );
   });
 
   test("surface block includes approve/reject actions when requestId present", () => {
-    const blocks = buildAccessRequestSeedContentBlocks(basePayload);
-    const surface = blocks[0] as Record<string, unknown>;
-    const actions = surface.actions as Array<{
-      id: string;
-      label: string;
-      style: string;
-    }>;
-    expect(actions).toHaveLength(2);
-    expect(actions[0]).toEqual({
-      id: "apr:req-123:approve_once",
-      label: "Approve",
-      style: "primary",
-    });
-    expect(actions[1]).toEqual({
-      id: "apr:req-123:reject",
-      label: "Reject",
-      style: "destructive",
-    });
+    const surface = surfaceOf(buildAccessRequestSeedContentBlocks(basePayload));
+    expect(surface.actions).toEqual([
+      { id: "apr:req-123:approve_once", label: "Approve", style: "primary" },
+      { id: "apr:req-123:reject", label: "Reject", style: "destructive" },
+    ]);
   });
 
   test("surface block omits actions when requestId is missing", () => {
-    const payload = {
+    const blocks = buildAccessRequestSeedContentBlocks({
       ...basePayload,
       requestId: undefined,
-    };
-    const blocks = buildAccessRequestSeedContentBlocks(payload);
-    const surface = blocks[0] as Record<string, unknown>;
-    expect(surface.actions).toBeUndefined();
+    });
+    expect(surfaceOf(blocks).actions).toBeUndefined();
   });
 
   test("parseAccessRequestPayload extracts typed fields", () => {

package/src/__tests__/activation-early-marking.test.ts

@@ -36,7 +36,7 @@ const { getDb } = await import("../memory/db-connection.js");
 const { initializeDb } = await import("../memory/db-init.js");
 const { activationSessions } = await import("../memory/schema.js");
 
-initializeDb();
+await initializeDb();
 
 /** Seed the workspace BOOTSTRAP.md with the unmodified generic template so the
  *  one-shot reseed inside `applyBootstrapTemplate` fires. */

package/src/__tests__/actor-token-service.test.ts

@@ -46,13 +46,13 @@ import { resetDbForTesting } from "./db-test-helpers.js";
 const TEST_KEY = Buffer.from("test-signing-key-32-bytes-long!!");
 
 // ---------------------------------------------------------------------------
-initializeDb();
+await initializeDb();
 
-beforeEach(() => {
+beforeEach(async () => {
   initAuthSigningKey(TEST_KEY);
   resetExternalAssistantIdCache();
   resetDbForTesting();
-  initializeDb();
+  await initializeDb();
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/agent-loop-callsite-precedence.test.ts

@@ -9,8 +9,7 @@
  * for these knobs is silently ignored.
  *
  * Precedence (highest wins):
- *   1. Per-turn explicit (from `resolveSystemPrompt`'s
- *      `resolved.maxTokens` / `resolved.model`)
+ *   1. Per-run explicit (from `run()`'s `model` param)
  *   2. Call-site resolved values (from `resolveCallSiteConfig` via the
  *      normalizer)
  *   3. Conversation defaults (`this.config.*`, from `llm.default`)
@@ -33,7 +32,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => ({ llm: mockLlmConfig }),
 }));
 
-import type { ResolvedSystemPrompt } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import { LLMSchema } from "../config/schemas/llm.js";
 import { RetryProvider } from "../providers/retry.js";
@@ -298,41 +296,4 @@ describe("AgentLoop — call-site precedence", () => {
     // No callSite → loop sets the wire-format thinking directly.
     expect(config.thinking).toEqual({ type: "adaptive" });
   });
-
-  test("per-turn resolveSystemPrompt.maxTokens wins over both call-site and default", async () => {
-    setLlmConfig({
-      default: {
-        provider: "anthropic",
-        model: "claude-default",
-        maxTokens: 64000,
-      },
-      callSites: { mainAgent: { maxTokens: 4096 } },
-    });
-
-    const { provider, lastConfig } = makePipeline("anthropic");
-    const resolveSystemPrompt = (): ResolvedSystemPrompt => ({
-      systemPrompt: "per-turn system",
-      maxTokens: 8192,
-    });
-
-    const loop = new AgentLoop({
-      provider: provider,
-      systemPrompt: "system",
-      conversationId: "test-conversation",
-      config: { maxTokens: 64000 },
-      resolveSystemPrompt: resolveSystemPrompt,
-    });
-
-    await loop.run({
-      requestId: "test-request",
-      messages: [userMessage],
-      onEvent: () => {},
-      trust: { sourceChannel: "vellum", trustClass: "unknown" },
-      callSite: "mainAgent",
-    });
-
-    // Per-turn explicit value beats both the call-site (4096) and the
-    // default (64000).
-    expect(lastConfig()!.max_tokens).toBe(8192);
-  });
 });

package/src/__tests__/agent-loop-compaction-events.test.ts

@@ -104,7 +104,6 @@ function fakeCompaction(
 ): { trust: TrustContext } {
   createContextWindowManager({
     provider: { name: "mock-provider" } as unknown as Provider,
-    systemPrompt: "system",
     config: {} as unknown as ContextWindowConfig,
     conversationId,
   });

package/src/__tests__/agent-loop-compaction-strip.test.ts

@@ -106,7 +106,6 @@ function installCapturingManager(capture: CompactionInputCapture): {
 } {
   createContextWindowManager({
     provider: { name: "mock-provider" } as unknown as Provider,
-    systemPrompt: "system",
     config: {} as unknown as ContextWindowConfig,
     conversationId: CONVERSATION_ID,
   });

package/src/__tests__/agent-loop-exit-reason.test.ts

@@ -142,7 +142,6 @@ function fakeCompaction(
 ): { trust: TrustContext } {
   createContextWindowManager({
     provider: { name: "mock-provider" } as unknown as Provider,
-    systemPrompt: "system",
     config: {} as unknown as ContextWindowConfig,
     conversationId,
   });

package/src/__tests__/agent-loop-pushes-post-hook-prompt.test.ts

@@ -0,0 +1,306 @@
+/**
+ * Tests for the `system_prompt_changed` event emitted by AgentLoop when the
+ * `pre-model-call` hook chain mutates the system prompt.
+ *
+ * The event fires whenever the post-hook `systemPrompt` differs from the
+ * value the loop handed the hook (compared against `providerOptions.systemPrompt`,
+ * not the context object — which the hook may mutate in place).
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Stub pipes ──────────────────────────────────────────────────────
+// Same logger-stub shape as the rest of the test suite — pino pulls are
+// agent-loop-time too, but we silence them so the test stays deterministic.
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// Mock plugin pipeline. Two modes:
+//  - return mode (default): returns `hookResponse` as the hook result.
+//  - in-place mode: mutates ctx.systemPrompt directly and returns the same
+//    object, simulating a hook that edits the context without returning a
+//    new value — the scenario that requires comparing against
+//    providerOptions.systemPrompt, not preModelCtx.systemPrompt.
+type PreModelCallCtx = {
+  conversationId: string;
+  callSite: string | null;
+  systemPrompt: string | null;
+  modelProfile: string | null;
+  deferAssistantOutput: boolean;
+  logger: unknown;
+};
+let hookResponse: PreModelCallCtx = {
+  conversationId: "test-conv",
+  callSite: "mainAgent",
+  systemPrompt:
+    "BASELINE-PROMPT\n\n<!-- advisor:steering -->\nAPPENDED-FROM-HOOK",
+  modelProfile: null,
+  deferAssistantOutput: false,
+  logger: {},
+};
+let hookMutatesInPlace = false;
+mock.module("../plugins/pipeline.js", () => ({
+  runHook: async (
+    _hook: unknown,
+    ctx: PreModelCallCtx,
+  ): Promise<PreModelCallCtx> => {
+    if (hookMutatesInPlace) {
+      ctx.systemPrompt = hookResponse.systemPrompt;
+      return ctx;
+    }
+    return hookResponse;
+  },
+}));
+
+// Minimal `getConfig` so the loop's defaults/loader path doesn't trip.
+let mockLlmConfig: Record<string, unknown> = {};
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ llm: mockLlmConfig }),
+}));
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "hi" }],
+};
+
+const trust: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+function setLlmConfig(raw: unknown): void {
+  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+}
+
+beforeEach(() => {
+  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
+  hookMutatesInPlace = false;
+  hookResponse = {
+    conversationId: "test-conv",
+    callSite: "mainAgent",
+    systemPrompt:
+      "BASELINE-PROMPT\n\n<!-- advisor:steering -->\nAPPENDED-FROM-HOOK",
+    modelProfile: null,
+    deferAssistantOutput: false,
+    logger: {},
+  };
+});
+
+/**
+ * Provider that records the system prompt it sees on every send and short-
+ * circuits the turn after one call. We don't need streaming for verifying
+ * prompt pushback.
+ */
+function makeRecordingProvider(): {
+  provider: Provider;
+  capturedSystemPrompts: () => string[];
+} {
+  const captured: string[] = [];
+  let callCount = 0;
+  const provider: Provider = {
+    name: "anthropic",
+    async sendMessage(
+      _messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      if (options?.systemPrompt !== undefined) {
+        captured.push(options.systemPrompt);
+      }
+      callCount += 1;
+      return {
+        content: [{ type: "text", text: callCount === 1 ? "done" : "..." }],
+        model: "mock-model",
+        usage: { inputTokens: 1, outputTokens: 1 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return { provider, capturedSystemPrompts: () => captured };
+}
+
+describe("AgentLoop system_prompt_changed event", () => {
+  test("fires when the hook mutates the prompt on mainAgent", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "mock-model" },
+    });
+
+    const mutatedPrompt = "BASELINE\n\n<!-- advisor:steering -->";
+    hookResponse = {
+      conversationId: "test-conv",
+      callSite: "mainAgent",
+      systemPrompt: mutatedPrompt,
+      modelProfile: null,
+      deferAssistantOutput: false,
+      logger: {},
+    };
+
+    const { provider } = makeRecordingProvider();
+    const events: AgentEvent[] = [];
+
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "BASELINE",
+      config: {},
+      conversationId: "test-conv",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust,
+      callSite: "mainAgent",
+    });
+
+    const changedEvents = events.filter(
+      (e) => e.type === "system_prompt_changed",
+    );
+    expect(changedEvents).toHaveLength(1);
+    expect(changedEvents[0].systemPrompt).toBe(mutatedPrompt);
+  });
+
+  test("fires on non-mainAgent call sites too", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "mock-model" },
+    });
+
+    hookResponse = {
+      conversationId: "test-conv",
+      callSite: "subagentSpawn",
+      systemPrompt: "MUTATED-BY-HOOK",
+      modelProfile: null,
+      deferAssistantOutput: false,
+      logger: {},
+    };
+
+    const { provider } = makeRecordingProvider();
+    const events: AgentEvent[] = [];
+
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "BASELINE",
+      config: {},
+      conversationId: "test-conv",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust,
+      callSite: "subagentSpawn",
+    });
+
+    const changedEvents = events.filter(
+      (e) => e.type === "system_prompt_changed",
+    );
+    expect(changedEvents).toHaveLength(1);
+    expect(changedEvents[0].systemPrompt).toBe("MUTATED-BY-HOOK");
+  });
+
+  test("does not fire when hook returns the same prompt", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "mock-model" },
+    });
+
+    hookResponse = {
+      conversationId: "test-conv",
+      callSite: "mainAgent",
+      systemPrompt: "SAME-PROMPT",
+      modelProfile: null,
+      deferAssistantOutput: false,
+      logger: {},
+    };
+
+    const { provider } = makeRecordingProvider();
+    const events: AgentEvent[] = [];
+
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "SAME-PROMPT",
+      config: {},
+      conversationId: "test-conv",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust,
+      callSite: "mainAgent",
+    });
+
+    const changedEvents = events.filter(
+      (e) => e.type === "system_prompt_changed",
+    );
+    expect(changedEvents).toHaveLength(0);
+  });
+
+  test("fires when the hook mutates ctx.systemPrompt in place", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "mock-model" },
+    });
+
+    // In-place mode: the mock mutates ctx.systemPrompt directly and
+    // returns the same object reference. The old comparison against
+    // preModelCtx.systemPrompt would miss this because preModelCtx IS
+    // the mutated object. Comparing against providerOptions.systemPrompt
+    // (captured pre-hook) catches it.
+    hookMutatesInPlace = true;
+    hookResponse = {
+      conversationId: "test-conv",
+      callSite: "mainAgent",
+      systemPrompt: "BASELINE\n\n<!-- advisor:steering -->",
+      modelProfile: null,
+      deferAssistantOutput: false,
+      logger: {},
+    };
+
+    const { provider } = makeRecordingProvider();
+    const events: AgentEvent[] = [];
+
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "BASELINE",
+      config: {},
+      conversationId: "test-conv",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust,
+      callSite: "mainAgent",
+    });
+
+    const changedEvents = events.filter(
+      (e) => e.type === "system_prompt_changed",
+    );
+    expect(changedEvents).toHaveLength(1);
+    expect(changedEvents[0].systemPrompt).toBe(
+      "BASELINE\n\n<!-- advisor:steering -->",
+    );
+  });
+});