@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -2,7 +2,7 @@
  * Tests for slash command interception in the POST /v1/messages handler.
  *
  * Validates that:
- * - Built-in slash commands (/status, /models, /commands) are intercepted and
+ * - Built-in slash commands (/context, /models, /commands) are intercepted and
  *   do NOT trigger the agent loop.
  * - Regular messages pass through to the agent loop unchanged.
  */
@@ -10,19 +10,13 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
-import type { SlashResolution } from "../daemon/conversation-slash.js";
-
-const resolveSlashMock = mock(
-  (_content: string, _context?: unknown): SlashResolution => ({
-    kind: "passthrough",
-    content: _content,
-  }),
+const formatCompactResultMock = mock(
+  (result: { maxInputTokens: number }) =>
+    `Context Compacted\n\nContext: 10,000 / ${result.maxInputTokens.toLocaleString(
+      "en-US",
+    )} tokens`,
 );
 
-mock.module("../daemon/conversation-slash.js", () => ({
-  resolveSlash: resolveSlashMock,
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
@@ -56,7 +50,11 @@ mock.module("../config/loader.js", () => ({
           },
         },
       },
-      profiles: {},
+      profiles: {
+        "short-context": {
+          contextWindow: { maxInputTokens: 150000 },
+        },
+      },
       callSites: {},
       pricingOverrides: [],
     },
@@ -133,6 +131,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     content: string,
     metadata?: Record<string, unknown>,
   ) => addMessageMock(conversationId, role, content, metadata),
+  getConversationOverrideProfile: () => "short-context",
   getMessages: () => [],
   provenanceFromTrustContext: (ctx: unknown) =>
     ctx
@@ -152,6 +151,7 @@ mock.module("../daemon/conversation-process.js", () => ({
   isModelSlashCommand: (content: string) => {
     return content.trim() === "/models";
   },
+  formatCompactResult: formatCompactResultMock,
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
@@ -220,6 +220,21 @@ function makeConversation() {
     ) => undefined,
   );
   const setPreactivatedSkillIds = mock((_ids: string[] | undefined) => {});
+  const forceCompact = mock(async () => ({
+    messages: [],
+    compacted: true,
+    previousEstimatedInputTokens: 12000,
+    estimatedInputTokens: 10000,
+    maxInputTokens: 150000,
+    thresholdTokens: 120000,
+    compactedMessages: 2,
+    compactedPersistedMessages: 2,
+    summaryCalls: 1,
+    summaryInputTokens: 500,
+    summaryOutputTokens: 100,
+    summaryModel: "claude-opus-4-7",
+    summaryText: "Summary",
+  }));
   const events: unknown[] = [];
   const messages: unknown[] = [];
   const conversation = {
@@ -236,18 +251,16 @@ function makeConversation() {
     enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
     persistUserMessage,
     runAgentLoop,
+    forceCompact,
     setPreactivatedSkillIds,
     drainQueue: async () => {},
     getMessages: () => messages,
     assistantId: "self",
     trustContext: undefined,
     hasPendingConfirmation: () => false,
-    setHostBashProxy: () => {},
     setHostBrowserProxy: () => {},
-    setHostFileProxy: () => {},
-    setHostTransferProxy: () => {},
-    getHostTransferProxy: () => undefined,
     setHostCuProxy: () => {},
+    setHostAppControlProxy: () => {},
     addPreactivatedSkillId: () => {},
     usageStats: {
       inputTokens: 1000,
@@ -262,13 +275,18 @@ function makeConversation() {
     setPreactivatedSkillIds,
     events,
     messages,
+    forceCompact,
   };
 }
 
 function makeRequest(content: string, extras: Record<string, unknown> = {}) {
   return new Request("http://localhost/v1/messages", {
     method: "POST",
-    headers: { "Content-Type": "application/json", "x-vellum-actor-principal-id": "test-user", "x-vellum-principal-type": "actor" },
+    headers: {
+      "Content-Type": "application/json",
+      "x-vellum-actor-principal-id": "test-user",
+      "x-vellum-principal-type": "actor",
+    },
     body: JSON.stringify({
       conversationKey: "slash-test-key",
       content,
@@ -293,22 +311,17 @@ function makeDeps(
 
 describe("handleSendMessage slash command interception", () => {
   beforeEach(() => {
-    resolveSlashMock.mockClear();
+    formatCompactResultMock.mockClear();
     addMessageMock.mockClear();
     ipcCallMock.mockClear();
   });
 
   test("intercepts built-in slash commands (unknown kind) without calling agent loop", async () => {
-    resolveSlashMock.mockReturnValue({
-      kind: "unknown",
-      message: "Conversation Status\n\nContext: 5%",
-    });
-
     const { conversation, persistUserMessage, runAgentLoop } =
       makeConversation();
     const res = await callHandler(
       (args) => handleSendMessage(args, makeDeps(conversation)),
-      makeRequest("/status"),
+      makeRequest("/context"),
       undefined,
       202,
     );
@@ -321,10 +334,6 @@ describe("handleSendMessage slash command interception", () => {
     expect(body.accepted).toBe(true);
     expect(body.messageId).toBe("persisted-user-id");
 
-    // Slash command was resolved
-    expect(resolveSlashMock).toHaveBeenCalledTimes(1);
-    expect(resolveSlashMock.mock.calls[0][0]).toBe("/status");
-
     // User + assistant messages persisted, but agent loop NOT called
     expect(addMessageMock).toHaveBeenCalledTimes(2);
     const roles = addMessageMock.mock.calls.map((c) => c[1]);
@@ -333,12 +342,35 @@ describe("handleSendMessage slash command interception", () => {
     expect(runAgentLoop).not.toHaveBeenCalled();
   });
 
-  test("passes regular messages through to agent loop unchanged", async () => {
-    resolveSlashMock.mockReturnValue({
-      kind: "passthrough",
-      content: "hello there",
-    });
+  test("handles /compact without calling agent loop and formats the compaction max", async () => {
+    const { conversation, persistUserMessage, runAgentLoop, forceCompact } =
+      makeConversation();
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(conversation)),
+      makeRequest("/compact"),
+      undefined,
+      202,
+    );
 
+    expect(res.status).toBe(202);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      messageId?: string;
+    };
+    expect(body.accepted).toBe(true);
+    expect(body.messageId).toBe("persisted-user-id");
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(forceCompact).toHaveBeenCalledTimes(1);
+    expect(formatCompactResultMock).toHaveBeenCalledWith(
+      expect.objectContaining({ maxInputTokens: 150000 }),
+    );
+    expect(persistUserMessage).not.toHaveBeenCalled();
+    expect(runAgentLoop).not.toHaveBeenCalled();
+  });
+
+  test("passes regular messages through to agent loop unchanged", async () => {
     const {
       conversation,
       persistUserMessage,
@@ -354,9 +386,6 @@ describe("handleSendMessage slash command interception", () => {
 
     expect(res.status).toBe(202);
 
-    // Slash command was resolved but passed through
-    expect(resolveSlashMock).toHaveBeenCalledTimes(1);
-
     // No skill preactivation
     expect(setPreactivatedSkillIds).not.toHaveBeenCalled();
 
@@ -367,41 +396,26 @@ describe("handleSendMessage slash command interception", () => {
     expect(loopContent).toBe("hello there");
   });
 
-  test("passes SlashContext with session usage stats", async () => {
-    resolveSlashMock.mockReturnValue({
-      kind: "passthrough",
-      content: "test",
-    });
-
+  test("passes SlashContext with resolved profile context budget", async () => {
     const { conversation } = makeConversation();
     await callHandler(
       (args) => handleSendMessage(args, makeDeps(conversation)),
-      makeRequest("test"),
+      makeRequest("/context"),
       undefined,
       202,
     );
 
-    expect(resolveSlashMock).toHaveBeenCalledTimes(1);
-    const context = resolveSlashMock.mock.calls[0][1] as Record<
-      string,
-      unknown
-    >;
-    expect(context).toMatchObject({
-      inputTokens: 1000,
-      outputTokens: 500,
-      estimatedCost: 0.05,
-      model: "claude-opus-4-7",
-      provider: "anthropic",
-      maxInputTokens: 200000,
-    });
+    const assistantPersist = addMessageMock.mock.calls.find(
+      (call) => call[1] === "assistant",
+    );
+    expect(assistantPersist).toBeDefined();
+    expect(String(assistantPersist?.[2])).toContain("1,000 / 150,000 tokens");
+    expect(String(assistantPersist?.[2])).toContain(
+      "claude-opus-4-7 (anthropic)",
+    );
   });
 
   test("applies riskThreshold override when provided", async () => {
-    resolveSlashMock.mockReturnValue({
-      kind: "passthrough",
-      content: "hello there",
-    });
-
     const { conversation } = makeConversation();
     const res = await callHandler(
       (args) => handleSendMessage(args, makeDeps(conversation)),
@@ -418,10 +432,6 @@ describe("handleSendMessage slash command interception", () => {
   });
 
   test("returns 500 when riskThreshold IPC fails", async () => {
-    resolveSlashMock.mockReturnValue({
-      kind: "passthrough",
-      content: "hello there",
-    });
     ipcCallMock.mockImplementationOnce(async () => undefined);
 
     const { conversation } = makeConversation();

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -28,11 +28,13 @@ import {
   buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
+  getSlackCompactionWatermarkForPrefix,
   injectChannelCapabilityContext,
   injectChannelCommandContext,
   isGroupChatType,
   isSlackChannelConversation,
   loadSlackActiveThreadFocusBlock,
+  loadSlackChronologicalContext,
   loadSlackChronologicalMessages,
   resolveChannelCapabilities,
   stripChannelCapabilityContext,
@@ -1159,9 +1161,7 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).toContain("member_policy: allow");
     // Behavioral guidance: conversational confirmation (one-time decision pattern)
     expect(text).toContain("trusted contact (non-guardian)");
-    expect(text).toContain(
-      "confirming the guardian's intent conversationally",
-    );
+    expect(text).toContain("confirming the guardian's intent conversationally");
     expect(text).not.toContain(
       "tool execution layer will automatically deny it and escalate",
     );
@@ -2298,6 +2298,24 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     });
   }
 
+  test("normalized Slack mention labels stay in assembled model context", async () => {
+    const rows: MessageRow[] = [
+      userRow({
+        id: "m-normalized-mention",
+        createdAt: 1700000000_000,
+        text: "@leo can you check this?",
+        slackMeta: buildSlackMeta({ channelTs: T0, displayName: "alice" }),
+      }),
+    ];
+
+    const result = await runSlackChannelAssembly(rows);
+    const renderedContext = texts(result).join("\n");
+
+    expect(renderedContext).toContain("@leo can you check this?");
+    expect(renderedContext).not.toContain("<@U_LEO>");
+    expect(renderedContext).not.toContain("U_LEO");
+  });
+
   // ── Scenario 1: reply in mid-thread ──────────────────────────────────
   // Alice posts to thread A, Bob replies in thread B (cross-thread). Then
   // Alice posts a follow-up reply in thread A. Cross-thread visibility:
@@ -2825,6 +2843,37 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).not.toContain("dm context");
   });
 
+  test("slack late-join notice is model-facing and non-persisted", async () => {
+    const slackChannelCaps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const notice =
+      "Slack context note: this turn joined an existing thread. 3 earlier thread messages were backfilled before the current message.";
+
+    const { messages: result, blocks } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "current turn" }] }],
+      {
+        channelCapabilities: slackChannelCaps,
+        slackRuntimeContextNotice: notice,
+        transportHints: [notice],
+      },
+    );
+
+    const allText = result
+      .flatMap((m) => m.content)
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text)
+      .join("\n");
+    expect(allText).toContain("<slack_context_notice>");
+    expect(allText).toContain(notice);
+    expect(allText).not.toContain("<transport_hints>");
+    expect(JSON.stringify(blocks)).not.toContain(notice);
+  });
+
   // ── transport_hints kept for non-slack channels ───────────────────────
   test("non-slack conversations still receive <transport_hints>", async () => {
     const { messages: result } = await applyRuntimeInjections(
@@ -2894,6 +2943,211 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     expect(allText).toContain("from untrusted actor");
   });
 
+  test("loadSlackChronologicalContext preserves summary and filters by Slack watermark", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const rows: MessageRow[] = [
+      userRow({
+        id: "newer-inserted-first",
+        createdAt: 1700000030_000,
+        text: "after watermark",
+        slackMeta: buildSlackMeta({
+          channelTs: T2,
+          displayName: "carol",
+        }),
+      }),
+      userRow({
+        id: "older-backfilled-later",
+        createdAt: 1700000040_000,
+        text: "before watermark even though inserted later",
+        slackMeta: buildSlackMeta({
+          channelTs: T0,
+          displayName: "alice",
+        }),
+      }),
+      userRow({
+        id: "legacy-before-watermark",
+        createdAt: 1700000008_000,
+        text: "legacy row before watermark",
+      }),
+      userRow({
+        id: "at-watermark",
+        createdAt: 1700000045_000,
+        text: "at watermark",
+        slackMeta: buildSlackMeta({
+          channelTs: T1,
+          displayName: "bob",
+        }),
+      }),
+    ];
+
+    const result = loadSlackChronologicalContext("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "guardian",
+      contextSummary: "## Summary\n- compacted Slack history",
+      contextCompactedMessageCount: 99,
+      slackContextCompactionWatermarkTs: T1,
+    });
+
+    expect(result).not.toBeNull();
+    const renderedText = result!.messages
+      .flatMap((message) => message.content)
+      .filter((block): block is { type: "text"; text: string } => {
+        return block.type === "text";
+      })
+      .map((block) => block.text)
+      .join("\n");
+    expect(renderedText).toContain("<context_summary>");
+    expect(renderedText).toContain("compacted Slack history");
+    expect(renderedText).toContain("after watermark");
+    expect(renderedText).not.toContain("before watermark");
+    expect(renderedText).not.toContain("legacy row before watermark");
+    expect(renderedText).not.toContain("at watermark");
+    expect(result!.renderedMessages.map((entry) => entry.message)).toEqual(
+      result!.messages,
+    );
+    expect(
+      result!.renderedMessages.map((entry) => entry.sourceChannelTs),
+    ).toEqual([null, T2]);
+    expect(getSlackCompactionWatermarkForPrefix(result, 1)).toBe(T2);
+  });
+
+  test("active-thread focus filters pre-watermark and legacy compacted rows", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const rows: MessageRow[] = [
+      userRow({
+        id: "thread-root",
+        createdAt: 1700000000_000,
+        text: "compacted root",
+        slackMeta: buildSlackMeta({
+          channelTs: T0,
+          threadTs: T0,
+          displayName: "alice",
+        }),
+      }),
+      userRow({
+        id: "legacy-old",
+        createdAt: 1700000005_000,
+        text: "legacy compacted row",
+      }),
+      userRow({
+        id: "reply-before",
+        createdAt: 1700000008_000,
+        text: "compacted reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY1,
+          threadTs: T0,
+          displayName: "bob",
+        }),
+      }),
+      userRow({
+        id: "reply-after",
+        createdAt: 1700000025_000,
+        text: "live reply",
+        slackMeta: buildSlackMeta({
+          channelTs: T0_REPLY2,
+          threadTs: T0,
+          displayName: "carol",
+        }),
+      }),
+    ];
+
+    const result = loadSlackActiveThreadFocusBlock("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "guardian",
+      contextCompactedMessageCount: 3,
+      slackContextCompactionWatermarkTs: T1,
+    });
+
+    expect(result).not.toBeNull();
+    expect(result!).toContain("live reply");
+    expect(result!).not.toContain("compacted root");
+    expect(result!).not.toContain("compacted reply");
+    expect(result!).not.toContain("legacy compacted row");
+  });
+
+  test("long Slack thread stays compacted after a later reply", () => {
+    const caps: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+      chatType: "channel",
+    };
+    const ts = (n: number) => `1700000${String(n).padStart(3, "0")}.000000`;
+    const watermark = ts(80);
+    const rows: MessageRow[] = [
+      ...Array.from({ length: 121 }, (_, index) =>
+        userRow({
+          id: `thread-${index}`,
+          createdAt: 1700000000_000 + index,
+          text: index === 0 ? "original root" : `pre-compaction ${index}`,
+          slackMeta: buildSlackMeta({
+            channelTs: ts(index),
+            threadTs: index === 0 ? undefined : ts(0),
+            displayName: index % 2 === 0 ? "alice" : "bob",
+          }),
+        }),
+      ),
+      userRow({
+        id: "subsequent-reply",
+        createdAt: 1700000000_500,
+        text: "reply after compaction",
+        slackMeta: buildSlackMeta({
+          channelTs: ts(121),
+          threadTs: ts(0),
+          displayName: "carol",
+        }),
+      }),
+    ];
+
+    const result = loadSlackChronologicalContext("conv-1", caps, {
+      loader: () => rows,
+      trustClass: "guardian",
+      contextSummary: "## Summary\n- compacted long Slack thread",
+      contextCompactedMessageCount: 81,
+      slackContextCompactionWatermarkTs: watermark,
+    });
+
+    expect(result).not.toBeNull();
+    const renderedText = result!.messages
+      .flatMap((message) => message.content)
+      .filter((block): block is { type: "text"; text: string } => {
+        return block.type === "text";
+      })
+      .map((block) => block.text)
+      .join("\n");
+
+    expect(renderedText).toContain("compacted long Slack thread");
+    expect(renderedText).toContain("reply after compaction");
+    expect(renderedText).not.toContain("original root");
+    expect(renderedText).not.toContain("pre-compaction 80");
+    const sourceChannelTs = result!.renderedMessages.map(
+      (entry) => entry.sourceChannelTs,
+    );
+    expect(sourceChannelTs[0]).toBeNull();
+    expect(
+      sourceChannelTs
+        .slice(1)
+        .every(
+          (channelTs) =>
+            channelTs !== null &&
+            Number.parseFloat(channelTs) > Number.parseFloat(watermark),
+        ),
+    ).toBe(true);
+  });
+
   // ── loadSlackChronologicalMessages returns null for non-slack channels ─
   test("loadSlackChronologicalMessages returns null for non-slack channels", () => {
     const result = loadSlackChronologicalMessages(

package/src/__tests__/conversation-slash-commands.test.ts

@@ -36,6 +36,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -51,6 +52,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -65,17 +67,19 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
     ]);
   });
 
-  test("keeps legacy fallback help when no interface is provided", async () => {
+  test("orders fallback help consistently when no interface is provided", async () => {
     const lines = await resolveCommandsLines(makeSlashContext());
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/context — Show conversation context usage",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
     ]);
@@ -92,13 +96,25 @@ describe("resolveSlash /commands interface-aware help", () => {
 });
 
 describe("resolveSlash command contract", () => {
+  test("/context reports the resolved context budget", async () => {
+    const result = await resolveSlash(
+      "/context",
+      makeSlashContext({ inputTokens: 75_000, maxInputTokens: 150_000 }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /context to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("50%");
+    expect(result.message).toContain("75,000 / 150,000 tokens");
+  });
+
   test("keeps unsupported slash forms as passthrough", async () => {
     const slashForms = [
       "/commands foo",
+      "/context foo",
       "/models foo",
       "/status foo",
-      "/pair foo",
-      "/pair",
       "/btw",
     ];
 
@@ -110,17 +126,18 @@ describe("resolveSlash command contract", () => {
       expect(result).toEqual({ kind: "passthrough", content: input });
     }
   });
-
-
 });
 
 describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
   // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
   // effects. The pure classifier is synchronous, takes no side-effecting
   // dependencies, and must agree with resolveSlash's `kind`.
-  const cases: Array<{ input: string; kind: "passthrough" | "compact" | "unknown" }> = [
-    { input: "/pair", kind: "passthrough" },
+  const cases: Array<{
+    input: string;
+    kind: "passthrough" | "compact" | "unknown";
+  }> = [
     { input: "/models", kind: "unknown" },
+    { input: "/context", kind: "unknown" },
     { input: "/status", kind: "unknown" },
     { input: "/commands", kind: "unknown" },
     { input: "/compact", kind: "compact" },
@@ -129,7 +146,6 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/opus", kind: "unknown" },
     { input: "hello", kind: "passthrough" },
     { input: "  /compact  ", kind: "compact" },
-    { input: "/pair foo", kind: "passthrough" },
     { input: "/models foo", kind: "passthrough" },
   ];
 

package/src/__tests__/conversation-slash-queue.test.ts

@@ -60,6 +60,8 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
+    conversations: { skipAutoRetitling: false },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,