@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/context-search-conversations-source.test.ts

@@ -5,6 +5,7 @@ import type { RecallSearchContext } from "../memory/context-search/types.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { rawRun } from "../memory/raw-query.js";
+import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 initializeDb();
 
 let seedId = 0;
@@ -225,6 +226,99 @@ describe("searchConversationSource", () => {
     );
   });
 
+  test("preserves external_content boundaries in recall evidence", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Slack recall",
+      content:
+        '<external_content source="slack" origin="@alice">\nThe recalltoken decision came from Slack.\n</external_content>',
+    });
+
+    const result = await searchConversationSource(
+      "recalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe recalltoken decision came from Slack.\n</external_content>',
+    });
+  });
+
+  test("wraps raw non-guardian Slack recall evidence from metadata", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Raw Slack recall",
+      role: "user",
+      content: "The rawrecalltoken decision came from Slack.",
+      metadata: slackMetadata("1700000100.000000", {
+        provenanceTrustClass: "unknown",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "rawrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe rawrecalltoken decision came from Slack.\n</external_content>',
+    });
+  });
+
+  test("wraps raw non-guardian Slack recall evidence that mentions external_content", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Raw Slack tag mention recall",
+      role: "user",
+      content:
+        "The tagmentionrecalltoken text mentions <external_content but is raw Slack content.",
+      metadata: slackMetadata("1700000102.000000", {
+        provenanceTrustClass: "unknown",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "tagmentionrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe tagmentionrecalltoken text mentions <external_content but is raw Slack content.\n</external_content>',
+    });
+  });
+
+  test("does not wrap guardian Slack recall evidence", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Guardian Slack recall",
+      role: "user",
+      content: "The guardianrecalltoken decision came from Slack.",
+      metadata: slackMetadata("1700000101.000000", {
+        provenanceTrustClass: "guardian",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "guardianrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt: "The guardianrecalltoken decision came from Slack.",
+    });
+  });
+
   test("broadens overconstrained recall queries to salient terms", async () => {
     const specific = await seedConversation({
       title: "Birthday cake plan",
@@ -258,6 +352,7 @@ function seedConversation(opts: {
   memoryScopeId?: string;
   role?: string;
   content: string;
+  metadata?: string;
 }) {
   const id = ++seedId;
   const now = Date.now() + id;
@@ -297,19 +392,39 @@ function seedConversation(opts: {
       conversation_id,
       role,
       content,
-      created_at
-    ) VALUES (?, ?, ?, ?, ?)
+      created_at,
+      metadata
+    ) VALUES (?, ?, ?, ?, ?, ?)
     `,
     message.id,
     conversation.id,
     opts.role ?? "assistant",
     opts.content,
     now,
+    opts.metadata ?? null,
   );
 
   return { conversation, message };
 }
 
+function slackMetadata(
+  channelTs: string,
+  extra: Record<string, unknown>,
+): string {
+  return JSON.stringify({
+    userMessageChannel: "slack",
+    assistantMessageChannel: "slack",
+    slackMeta: writeSlackMetadata({
+      source: "slack",
+      channelId: "C0123",
+      channelTs,
+      eventKind: "message",
+      displayName: "@alice",
+    }),
+    ...extra,
+  });
+}
+
 function makeContext(
   overrides: Partial<RecallSearchContext> = {},
 ): RecallSearchContext {

package/src/__tests__/context-search-memory-v2-source.test.ts

@@ -41,7 +41,6 @@ mock.module("../memory/embedding-backend.js", () => ({
     model: "test-model",
     vectors: [denseEmbedReturn],
   }),
-  generateSparseEmbedding: () => ({ indices: [1], values: [1] }),
 }));
 
 interface QdrantHit {

package/src/__tests__/context-search-workspace-source.test.ts

@@ -126,10 +126,15 @@ describe("searchWorkspaceSource", () => {
     writeWorkspaceFile(root, "api-key.md", "needle key");
     writeWorkspaceFile(root, "secret-plan.md", "needle secret");
     writeWorkspaceFile(root, "token-cache.md", "needle token");
+    writeWorkspaceFile(root, "apiKey.json", "needle camel key");
+    writeWorkspaceFile(root, "userToken.txt", "needle camel token");
+    writeWorkspaceFile(root, "MySecret.md", "needle camel secret");
     writeWorkspaceFile(root, "credentials.json", "needle credentials");
     writeWorkspaceFile(root, "protected/readme.md", "needle protected");
     writeWorkspaceFile(root, "gateway-security/readme.md", "needle gateway");
     writeWorkspaceFile(root, "ces-security/readme.md", "needle ces");
+    writeWorkspaceFile(root, "keyboard.ts", "needle keyboard");
+    writeWorkspaceFile(root, "tokenizer.py", "needle tokenizer");
     writeWorkspaceFile(root, "src/readme.md", "needle safe");
 
     const result = await searchWorkspaceSource("needle", makeContext(root), 10);
@@ -138,7 +143,9 @@ describe("searchWorkspaceSource", () => {
       ".hidden.md:1",
       ".notes/.format-rec.md:1",
       ".notes/cake.md:1",
+      "keyboard.ts:1",
       "src/readme.md:1",
+      "tokenizer.py:1",
     ]);
   });
 

package/src/__tests__/context-token-estimator.test.ts

@@ -33,6 +33,7 @@ function makePngBase64(width: number, height: number): string {
 describe("token estimator", () => {
   test("estimates text tokens from character length", () => {
     expect(estimateTextTokens("")).toBe(0);
+    expect(estimateTextTokens(undefined)).toBe(0);
     expect(estimateTextTokens("abcd")).toBe(1);
     expect(estimateTextTokens("abcde")).toBe(2);
   });

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -55,7 +55,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -84,6 +84,7 @@ mock.module("../config/loader.js", () => ({
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
     ui: {},
   }),
   loadRawConfig: () => ({}),

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -7,8 +7,9 @@
  *   2. Token estimation significantly underestimates actual token count
  *   3. No mid-loop budget check to prevent hitting the provider limit
  *
- * All tests are test.todo — they document expected behavior for bugs
+ * Most tests are test.todo — they document expected behavior for bugs
  * to be fixed in subsequent PRs (PR 2 for tests 1–5, PR 3 for tests 6–7).
+ * Tests 2, 8, 9, and 10 are now active and passing against current code.
  */
 import { createRequire } from "node:module";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -87,7 +88,9 @@ mock.module("../config/loader.js", () => ({
     llm: mockLlmConfig,
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
     ui: {},
+    compaction: { enabled: true, autoThreshold: 0.7 },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
@@ -851,111 +854,108 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
   // When estimation says we're within budget but the provider rejects,
   // the post-run convergence loop should kick in and recover.
   // This test should PASS against current code (when no progress is made).
-  test.todo(
-    "overflow recovery compacts below limit even when estimation underestimates",
-    async () => {
-      const events: ServerMessage[] = [];
-      let callCount = 0;
-      let reducerCalled = false;
+  test("overflow recovery compacts below limit even when estimation underestimates", async () => {
+    const events: ServerMessage[] = [];
+    let callCount = 0;
+    let reducerCalled = false;
 
-      // Estimator says 185k (below 190k budget = 200k * 0.95)
-      mockEstimateTokens = 185_000;
+    // Estimator says 185k (below 190k budget = 200k * 0.95)
+    mockEstimateTokens = 185_000;
 
-      // Reducer successfully compacts
-      mockReducerStepFn = (msgs: Message[]) => {
-        reducerCalled = true;
-        return {
+    // Reducer successfully compacts
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCalled = true;
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: ["forced_compaction"],
+          injectionMode: "full",
+          exhausted: false,
+        },
+        estimatedTokens: 100_000,
+        compactionResult: {
+          compacted: true,
           messages: msgs,
-          tier: "forced_compaction",
-          state: {
-            appliedTiers: ["forced_compaction"],
-            injectionMode: "full",
-            exhausted: false,
-          },
-          estimatedTokens: 100_000,
-          compactionResult: {
-            compacted: true,
-            messages: msgs,
-            compactedPersistedMessages: 10,
-            summaryText: "Summary",
-            previousEstimatedInputTokens: 185_000,
-            estimatedInputTokens: 100_000,
-            maxInputTokens: 200_000,
-            thresholdTokens: 160_000,
-            compactedMessages: 20,
-            summaryCalls: 1,
-            summaryInputTokens: 800,
-            summaryOutputTokens: 300,
-            summaryModel: "mock-model",
-          },
-        };
+          compactedPersistedMessages: 10,
+          summaryText: "Summary",
+          previousEstimatedInputTokens: 185_000,
+          estimatedInputTokens: 100_000,
+          maxInputTokens: 200_000,
+          thresholdTokens: 160_000,
+          compactedMessages: 20,
+          summaryCalls: 1,
+          summaryInputTokens: 800,
+          summaryOutputTokens: 300,
+          summaryModel: "mock-model",
+        },
       };
+    };
 
-      const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
-        callCount++;
-        if (callCount === 1) {
-          // Provider rejects with "prompt is too long: 242201 tokens > 200000"
-          // even though estimator said 185k
-          onEvent({
-            type: "error",
-            error: new Error(
-              "prompt is too long: 242201 tokens > 200000 maximum",
-            ),
-          });
-          onEvent({
-            type: "usage",
-            inputTokens: 0,
-            outputTokens: 0,
-            model: "test-model",
-            providerDurationMs: 10,
-          });
-          // No progress — return same messages
-          return messages;
-        }
-        // Second call succeeds
+    const agentLoopRun: AgentLoopRun = async (messages, onEvent) => {
+      callCount++;
+      if (callCount === 1) {
+        // Provider rejects with "prompt is too long: 242201 tokens > 200000"
+        // even though estimator said 185k
         onEvent({
-          type: "message_complete",
-          message: {
-            role: "assistant",
-            content: [{ type: "text", text: "recovered" }],
-          },
+          type: "error",
+          error: new Error(
+            "prompt is too long: 242201 tokens > 200000 maximum",
+          ),
         });
         onEvent({
           type: "usage",
-          inputTokens: 80_000,
-          outputTokens: 200,
+          inputTokens: 0,
+          outputTokens: 0,
           model: "test-model",
-          providerDurationMs: 500,
+          providerDurationMs: 10,
         });
-        return [
-          ...messages,
-          {
-            role: "assistant" as const,
-            content: [{ type: "text", text: "recovered" }] as ContentBlock[],
-          },
-        ];
-      };
-
-      const ctx = makeCtx({
-        agentLoopRun,
-        contextWindowManager: {
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        // No progress — return same messages
+        return messages;
+      }
+      // Second call succeeds
+      onEvent({
+        type: "message_complete",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "recovered" }],
+        },
       });
+      onEvent({
+        type: "usage",
+        inputTokens: 80_000,
+        outputTokens: 200,
+        model: "test-model",
+        providerDurationMs: 500,
+      });
+      return [
+        ...messages,
+        {
+          role: "assistant" as const,
+          content: [{ type: "text", text: "recovered" }] as ContentBlock[],
+        },
+      ];
+    };
 
-      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+    const ctx = makeCtx({
+      agentLoopRun,
+      contextWindowManager: {
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        maybeCompact: async () => ({ compacted: false }),
+      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+    });
 
-      // The reducer should be called in the convergence loop
-      expect(reducerCalled).toBe(true);
-      // Should recover without conversation_error
-      const conversationError = events.find(
-        (e) => e.type === "conversation_error",
-      );
-      expect(conversationError).toBeUndefined();
-      expect(callCount).toBe(2);
-    },
-  );
+    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+    // The reducer should be called in the convergence loop
+    expect(reducerCalled).toBe(true);
+    // Should recover without conversation_error
+    const conversationError = events.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationError).toBeUndefined();
+    expect(callCount).toBe(2);
+  });
 
   // ── Test 3 ────────────────────────────────────────────────────────
   // BUG: When the provider rejection reveals actual token count (e.g.,

package/src/__tests__/conversation-agent-loop.test.ts

@@ -61,7 +61,9 @@ mock.module("../config/loader.js", () => ({
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
     ui: mockUiConfig,
+    compaction: { enabled: true, autoThreshold: 0.7 },
   }),
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},

package/src/__tests__/conversation-error.test.ts

@@ -596,12 +596,51 @@ describe("classifyConversationError", () => {
       expect(result.retryable).toBe(true);
     });
 
-    it("classifies ProviderError with 401 as PROVIDER_NOT_CONFIGURED (non-retryable)", () => {
+    it("classifies ProviderError with 401 as PROVIDER_INVALID_KEY (non-retryable)", () => {
+      // 401 means the upstream provider rejected the configured key
+      // (vs. PROVIDER_NOT_CONFIGURED which is for a never-set key).
+      // The macOS chat renders these on different banners.
       const err = new ProviderError("Unauthorized", "anthropic", 401);
       const result = classifyConversationError(err, baseCtx);
-      expect(result.code).toBe("PROVIDER_NOT_CONFIGURED");
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.retryable).toBe(false);
-      expect(result.errorCategory).toBe("provider_not_configured");
+      expect(result.errorCategory).toBe("provider_invalid_key");
+    });
+
+    it("classifies ProviderError 401 with 'invalid x-api-key' message as PROVIDER_INVALID_KEY", () => {
+      // Regex-match branch — Anthropic's standard 401 wording.
+      const err = new ProviderError(
+        "Anthropic API error: invalid x-api-key",
+        "anthropic",
+        401,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.errorCategory).toBe("provider_invalid_key");
+    });
+
+    it("classifies ProviderError 403 with 'invalid api key' message as PROVIDER_INVALID_KEY", () => {
+      const err = new ProviderError(
+        "OpenAI: Invalid API key",
+        "openai",
+        403,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.errorCategory).toBe("provider_invalid_key");
+    });
+
+    it("includes connection/profile attribution in PROVIDER_INVALID_KEY when provided", () => {
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "my-anthropic",
+        profileName: "personal",
+      });
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.connectionName).toBe("my-anthropic");
+      expect(result.profileName).toBe("personal");
+      expect(result.userMessage).toContain("personal");
     });
 
     it("classifies direct ProviderError with 402 as provider_billing (non-retryable)", () => {

package/src/__tests__/conversation-fork-crud.test.ts

@@ -609,6 +609,88 @@ describe("forkConversation", () => {
     expect(await hydrateActivationState(db, fork.id)).toBeNull();
     expect(loadGraphMemoryState(fork.id)).toBeNull();
   });
+
+  test("does not copy memory state when the fork is truncated mid-history", async () => {
+    const source = createConversation("Truncated thread");
+    const firstMessage = await addMessage(
+      source.id,
+      "user",
+      "first turn",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "assistant", "first reply", undefined, {
+      skipIndexing: true,
+    });
+    const lastMessage = await addMessage(
+      source.id,
+      "user",
+      "second turn",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const db = getDb();
+    db.insert(activationState)
+      .values({
+        conversationId: source.id,
+        messageId: lastMessage.id,
+        stateJson: JSON.stringify({ "concepts/foo": 0.5 }),
+        everInjectedJson: JSON.stringify([{ slug: "concepts/foo", turn: 2 }]),
+        currentTurn: 2,
+        updatedAt: 1_700_000_000_000,
+      })
+      .run();
+    saveGraphMemoryState(
+      source.id,
+      JSON.stringify({
+        initialized: true,
+        needsReload: false,
+        inContext: ["node-foo"],
+        log: [{ nodeId: "node-foo", turn: 2 }],
+        currentTurn: 2,
+      }),
+    );
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: firstMessage.id,
+    });
+
+    expect(await hydrateActivationState(db, fork.id)).toBeNull();
+    expect(loadGraphMemoryState(fork.id)).toBeNull();
+  });
+
+  test("copies memory state when throughMessageId points at the last message", async () => {
+    const source = createConversation("Through-last thread");
+    const lastMessage = await addMessage(
+      source.id,
+      "user",
+      "only turn",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const db = getDb();
+    db.insert(activationState)
+      .values({
+        conversationId: source.id,
+        messageId: lastMessage.id,
+        stateJson: JSON.stringify({ "concepts/foo": 0.9 }),
+        everInjectedJson: JSON.stringify([{ slug: "concepts/foo", turn: 1 }]),
+        currentTurn: 1,
+        updatedAt: 1_700_000_000_000,
+      })
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: lastMessage.id,
+    });
+
+    const childState = await hydrateActivationState(db, fork.id);
+    expect(childState?.currentTurn).toBe(1);
+  });
 });
 
 describe("forkConversation + memory_retrospective_state", () => {