@vellumai/assistant 0.8.12 → 0.9.0-staging.1

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -45,12 +45,14 @@ import {
 } from "../memory/canonical-guardian-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import { processGuardianDecision } from "../runtime/guardian-action-service.js";
 import { GUARDIAN_DECISION_ACTIONS } from "../runtime/guardian-decision-types.js";
 import {
   type GuardianReplyContext,
   routeGuardianReply,
 } from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { parseCallbackData } from "../runtime/routes/channel-route-shared.js";
 import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
 initializeDb();
@@ -168,6 +170,12 @@ describe("routing invariant: all decision paths reference applyCanonicalGuardian
       path: "runtime/routes/guardian-action-routes.ts",
       symbols: ["processGuardianDecision"],
     },
+    // Surface action route handler (Vellum in-app card buttons) — intercepts
+    // apr:* action IDs and routes through processGuardianDecision
+    {
+      path: "runtime/routes/surface-action-routes.ts",
+      symbols: ["processGuardianDecision"],
+    },
     // Shared service where processGuardianDecision is defined — must route
     // through the canonical primitive to complete the chain:
     // entrypoint → processGuardianDecision → applyCanonicalGuardianDecision
@@ -1941,3 +1949,133 @@ describe("routing invariant: kind-specific action sets in prompt mapping", () =>
     expect(actionIds).not.toContain("approve_conversation");
   });
 });
+
+// ===========================================================================
+// SECTION 11: Surface action → access request approval routing
+// ===========================================================================
+
+describe("routing invariant: surface action apr:* buttons route through canonical primitive", () => {
+  beforeEach(() => resetTables());
+
+  test("parseCallbackData extracts requestId and action from apr: action IDs", () => {
+    const result = parseCallbackData(
+      "apr:access-req-test-slack-U123-1700000000:approve_once",
+      "vellum",
+    );
+    expect(result).not.toBeNull();
+    expect(result!.requestId).toBe("access-req-test-slack-U123-1700000000");
+    expect(result!.action).toBe("approve_once");
+    expect(result!.source).toBe("vellum_surface");
+  });
+
+  test("parseCallbackData returns vellum_surface source for vellum channel", () => {
+    const result = parseCallbackData("apr:req-1:reject", "vellum");
+    expect(result).not.toBeNull();
+    expect(result!.source).toBe("vellum_surface");
+  });
+
+  test("processGuardianDecision approves access_request from vellum surface", async () => {
+    const requestId = `access-req-test-slack-U123-${Date.now()}`;
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "slack",
+      conversationId: "conv-surface-test",
+      requesterExternalUserId: "U123",
+      requesterChatId: "D456",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "ingress_access_request",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const result = await processGuardianDecision({
+      requestId,
+      action: "approve_once",
+      channel: "vellum",
+      actorContext: {
+        actorPrincipalId: TEST_PRINCIPAL_ID,
+        guardianPrincipalId: TEST_PRINCIPAL_ID,
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok && "applied" in result) {
+      expect(result.applied).toBe(true);
+    }
+
+    const resolved = getCanonicalGuardianRequest(requestId);
+    expect(resolved!.status).toBe("approved");
+  });
+
+  test("processGuardianDecision denies access_request from vellum surface", async () => {
+    const requestId = `access-req-test-slack-U789-${Date.now()}`;
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "slack",
+      conversationId: "conv-surface-deny",
+      requesterExternalUserId: "U789",
+      requesterChatId: "D012",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "ingress_access_request",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const result = await processGuardianDecision({
+      requestId,
+      action: "reject",
+      channel: "vellum",
+      actorContext: {
+        actorPrincipalId: TEST_PRINCIPAL_ID,
+        guardianPrincipalId: TEST_PRINCIPAL_ID,
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok && "applied" in result) {
+      expect(result.applied).toBe(true);
+    }
+
+    const resolved = getCanonicalGuardianRequest(requestId);
+    expect(resolved!.status).toBe("denied");
+  });
+
+  test("principal mismatch rejects surface action decision", async () => {
+    const requestId = `access-req-test-slack-U999-${Date.now()}`;
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "slack",
+      conversationId: "conv-surface-mismatch",
+      requesterExternalUserId: "U999",
+      requesterChatId: "D345",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "ingress_access_request",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const result = await processGuardianDecision({
+      requestId,
+      action: "approve_once",
+      channel: "vellum",
+      actorContext: {
+        actorPrincipalId: "wrong-principal",
+        guardianPrincipalId: "wrong-principal",
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok && "applied" in result) {
+      expect(result.applied).toBe(false);
+    }
+
+    const req = getCanonicalGuardianRequest(requestId);
+    expect(req!.status).toBe("pending");
+  });
+});

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -64,7 +64,6 @@ mock.module("../../daemon/approval-generators.js", () => ({
 import type {
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
-  GuardianActionCopyGenerator,
   MessageProcessor,
 } from "../../runtime/http-types.js";
 import {
@@ -111,7 +110,6 @@ export async function handleChannelInbound(
   _assistantId?: string,
   _approvalCopyGenerator?: ApprovalCopyGenerator,
   _approvalConversationGenerator?: ApprovalConversationGenerator,
-  _guardianActionCopyGenerator?: GuardianActionCopyGenerator,
 ): Promise<Response> {
   const body = await req.json();
   return wrapHandler(() => _handleChannelInbound({ body }));

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -33,6 +33,10 @@ import {
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import {
+  MEMORY_RETROSPECTIVE_FORK_SOURCE,
+  MEMORY_RETROSPECTIVE_INSTRUCTION_KIND,
+} from "../memory/memory-retrospective-constants.js";
 import { messages } from "../memory/schema.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 
@@ -334,4 +338,99 @@ describe("handleListMessages metadata.hidden filtering", () => {
     expect(latest.hasMore).toBe(false);
     expect(latest.oldestTimestamp).not.toBeNull();
   });
+
+  test("fork retrospective conversations expose the hidden instruction and keep the review as its own turn", async () => {
+    const conv = createConversation({
+      source: MEMORY_RETROSPECTIVE_FORK_SOURCE,
+    });
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "source question" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "source answer" }]),
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "text", text: "background memory pass instruction" },
+      ]),
+      {
+        metadata: { kind: MEMORY_RETROSPECTIVE_INSTRUCTION_KIND, hidden: true },
+      },
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "retrospective review" }]),
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // The hidden instruction is shown, and because it sits between the two
+    // assistant rows they do NOT merge — the review stands as its own turn.
+    expect(body.messages.map((m) => m.role)).toEqual([
+      "user",
+      "assistant",
+      "user",
+      "assistant",
+    ]);
+    expect(plainText(body.messages[1])).toBe("source answer");
+    expect(plainText(body.messages[2])).toContain(
+      "background memory pass instruction",
+    );
+    expect(plainText(body.messages[3])).toBe("retrospective review");
+  });
+
+  test("non-fork conversations still hide the retrospective instruction (relaxation is fork-scoped)", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "source question" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "source answer" }]),
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "text", text: "background memory pass instruction" },
+      ]),
+      {
+        metadata: { kind: MEMORY_RETROSPECTIVE_INSTRUCTION_KIND, hidden: true },
+      },
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "retrospective review" }]),
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // Instruction stays hidden for non-retrospective conversations; the review
+    // (a normal assistant message) is still returned.
+    expect(
+      body.messages.some((m) =>
+        plainText(m).includes("background memory pass instruction"),
+      ),
+    ).toBe(false);
+    expect(
+      body.messages.some((m) => plainText(m).includes("retrospective review")),
+    ).toBe(true);
+  });
 });

package/src/__tests__/llm-request-log-source-clickhouse.test.ts

@@ -134,7 +134,9 @@ describe("ClickHouseLlmRequestLogSource", () => {
     const call = recorder[0]!;
     const parsed = new URL(call.url);
     expect(parsed.searchParams.get("database")).toBe("default");
-    expect(parsed.searchParams.get("param_assistant_id")).toBe("asst-fixture-001");
+    expect(parsed.searchParams.get("param_assistant_id")).toBe(
+      "asst-fixture-001",
+    );
     expect(parsed.searchParams.get("param_log_id")).toBe("log-1");
     expect(call.init?.method).toBe("POST");
     const auth = (call.init?.headers as Record<string, string>).Authorization;
@@ -224,6 +226,90 @@ describe("ClickHouseLlmRequestLogSource", () => {
     expect(body).not.toContain(`'msg-b'`);
   });
 
+  test("getRequestLogMetaById returns metadata without selecting either payload column", async () => {
+    // GIVEN a stored row in ClickHouse
+    const recorder: FakeFetchCall[] = [];
+    const metaRow = {
+      id: "log-1",
+      conversation_id: "conv-1",
+      message_id: "msg-1",
+      provider: "anthropic",
+      created_at: "1778465138786",
+      agent_loop_exit_reason: "no_tool_calls",
+      call_site: "compactionAgent",
+    };
+    const src = makeSource({
+      body: JSON.stringify(metaRow) + "\n",
+      recorder,
+    });
+
+    // WHEN looking it up by id
+    const row = await src.getRequestLogMetaById("log-1");
+
+    // THEN the metadata comes back without payload fields
+    expect(row).toEqual({
+      id: "log-1",
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      provider: "anthropic",
+      createdAt: 1778465138786,
+      agentLoopExitReason: "no_tool_calls",
+      callSite: "compactionAgent",
+    });
+    // AND the query never selects the payload columns (a single request
+    // payload can be a full context window)
+    const body = String(recorder[0]!.init?.body ?? "");
+    expect(body).not.toContain("request_payload");
+    expect(body).not.toContain("response_payload");
+  });
+
+  test("getCompactionLogsBetween computes message count in SQL and skips the request payload", async () => {
+    // GIVEN compaction rows whose message count ClickHouse computed via
+    // JSONLength (Int64 arrives as a quoted string under JSONEachRow)
+    const recorder: FakeFetchCall[] = [];
+    const compactionRow = {
+      id: "log-1",
+      conversation_id: "conv-1",
+      message_id: "",
+      provider: "anthropic",
+      response_payload: '{"bar":2}',
+      request_message_count: "42",
+      created_at: "1778465138786",
+      agent_loop_exit_reason: "",
+      call_site: "compactionAgent",
+    };
+    const src = makeSource({
+      body:
+        JSON.stringify(compactionRow) +
+        "\n" +
+        JSON.stringify({
+          ...compactionRow,
+          id: "log-2",
+          request_message_count: null,
+        }) +
+        "\n",
+      recorder,
+    });
+
+    // WHEN querying the trail window
+    const rows = await src.getCompactionLogsBetween("conv-1", 100, 500);
+
+    // THEN each row carries the numeric message count (null when the
+    // payload had no known message array) and no request payload
+    expect(rows).toHaveLength(2);
+    expect(rows[0]!.requestMessageCount).toBe(42);
+    expect(rows[1]!.requestMessageCount).toBeNull();
+    expect(rows[0]!.responsePayload).toBe('{"bar":2}');
+    expect("requestPayload" in rows[0]!).toBe(false);
+    // AND the SQL only touches request_payload inside JSONLength —
+    // it is never selected as a column
+    const body = String(recorder[0]!.init?.body ?? "");
+    expect(body).toContain("JSONLength(request_payload");
+    expect(body.match(/request_payload/g)).toHaveLength(
+      body.match(/JSONLength\(request_payload/g)!.length,
+    );
+  });
+
   test("missing clickhouse:url credential surfaces a clear error", async () => {
     const src = new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
       resolveUrl: async () => null,

package/src/__tests__/llm-resolver.test.ts

@@ -341,6 +341,97 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.verbosity).toBe("low");
   });
 
+  test("forceOverrideProfile floats the override profile above site profile and callsite fields for non-main call sites", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        active: { verbosity: "low" },
+        sitep: { effort: "none", speed: "fast" },
+        forced: {
+          model: "claude-haiku-4-5",
+          effort: "high",
+          thinking: { enabled: false },
+        },
+      },
+      callSites: {
+        memoryExtraction: { profile: "sitep", maxTokens: 1000 },
+      },
+      activeProfile: "active",
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "forced",
+      forceOverrideProfile: true,
+    });
+    // Forced override wins over both the site profile and the call-site
+    // override fields it touches.
+    expect(resolved.model).toBe("claude-haiku-4-5");
+    expect(resolved.effort).toBe("high");
+    expect(resolved.thinking.enabled).toBe(false);
+    // Call-site layers still win where the forced profile is silent.
+    expect(resolved.maxTokens).toBe(1000);
+    expect(resolved.speed).toBe("fast");
+    // Active profile still applies under everything.
+    expect(resolved.verbosity).toBe("low");
+  });
+
+  test("forceOverrideProfile absent leaves the override below callsite fields (unchanged precedence)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        forced: { effort: "high" },
+      },
+      callSites: {
+        memoryExtraction: { effort: "none" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "forced",
+    });
+    expect(resolved.effort).toBe("none");
+  });
+
+  test("forceOverrideProfile with a missing profile reference falls through to unchanged precedence", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        sitep: { effort: "low", model: "claude-haiku-4-5" },
+      },
+      callSites: {
+        memoryExtraction: { profile: "sitep" },
+      },
+    });
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm, {
+      overrideProfile: "nonexistent",
+      forceOverrideProfile: true,
+    });
+    // The missing reference is inert: site profile still wins.
+    expect(resolved.effort).toBe("low");
+    expect(resolved.model).toBe("claude-haiku-4-5");
+  });
+
+  test("forceOverrideProfile is a no-op for mainAgent (override already resolves on top)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        active: { effort: "low" },
+        override: { effort: "high" },
+      },
+      callSites: {
+        mainAgent: { effort: "none" },
+      },
+      activeProfile: "active",
+    });
+    const withForce = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "override",
+      forceOverrideProfile: true,
+    });
+    const withoutForce = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "override",
+    });
+    expect(withForce).toEqual(withoutForce);
+    expect(withForce.effort).toBe("high");
+  });
+
   test("overrideProfile absent leaves prior behavior intact", () => {
     // No `opts` argument at all — the resolver must behave exactly as it did
     // before this PR for configs without activeProfile/overrideProfile.
@@ -579,6 +670,30 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.effort).toBe("medium");
   });
 
+  test("workflowLeaf defaults to the cost-optimized profile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: {
+          model: "claude-sonnet-4-7",
+          effort: "medium",
+        },
+        "cost-optimized": {
+          model: "claude-haiku-4-5-20251001",
+          effort: "low",
+        },
+      },
+    });
+
+    expect(resolveDefaultProfileKey("workflowLeaf", llm)).toBe(
+      "cost-optimized",
+    );
+    const resolved = resolveCallSiteConfig("workflowLeaf", llm);
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    expect(resolved.effort).toBe("low");
+    expect(resolved.thinking.enabled).toBe(false);
+  });
+
   test("explicit callSites config overrides CALL_SITE_DEFAULTS", () => {
     const llm = LLMSchema.parse({
       default: fullDefault,

package/src/__tests__/managed-profile-guard.test.ts

@@ -66,6 +66,7 @@ mock.module("../config/loader.js", () => ({
     deepMergeForTest(target, overrides);
   },
   getConfig: () => rawConfig,
+  getDeploymentContextDefaults: () => ({}),
   invalidateConfigCache: () => {},
   withSuppressedConfigDiskWrites: async (fn: () => unknown) => fn(),
   withSuppressedConfigDiskWritesSync: (fn: () => unknown) => fn(),
@@ -321,7 +322,7 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
     const result = await patchRoute.handler({
       body: { llm: { profiles: { "custom-balanced": null } } },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("allows deletion of a user-defined profile via null", async () => {
@@ -329,14 +330,14 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
     const result = await patchRoute.handler({
       body: { llm: { profiles: { "my-custom": null } } },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("allows non-profile config patches", async () => {
     const result = await patchRoute.handler({
       body: { someOtherKey: "value" },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("clears stale Velay ownership when manually patching public base URL", async () => {
@@ -353,7 +354,7 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
       },
     });
 
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("ingress");
     expect(savedRaw).toEqual({
       ingress: {
         publicBaseUrl: "https://manual.example.test",
@@ -371,7 +372,7 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
         },
       },
     });
-    expect(result).toEqual({ ok: true });
+    expect(result).toHaveProperty("llm");
   });
 
   test("rejects nulling the entire profiles map", async () => {