@vellumai/assistant 0.4.56 → 0.4.57

package/src/__tests__/media-generate-image.test.ts

@@ -11,10 +11,11 @@ import type { ToolContext } from "../tools/types.js";
 // ---------------------------------------------------------------------------
 
 let mockApiKey: string | undefined = "test-gemini-key";
+let mockImageGenMode: "your-own" | "managed" = "your-own";
 let mockGenerateResult = {
   images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
   text: "A beautiful image",
-  resolvedModel: "gemini-2.5-flash-image",
+  resolvedModel: "gemini-3.1-flash-image-preview",
 };
 let mockGenerateError: Error | null = null;
 let lastGenerateCredentials: unknown = null;
@@ -29,11 +30,11 @@ mock.module("../config/loader.js", () => ({
         model: "claude-opus-4-6",
       },
       "image-generation": {
-        mode: "your-own",
+        mode: mockImageGenMode,
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
 }));
@@ -43,6 +44,10 @@ mock.module("../security/secure-keys.js", () => ({
     if (account === "gemini") return mockApiKey;
     return undefined;
   },
+  getProviderKeyAsync: async (provider: string) => {
+    if (provider === "gemini") return mockApiKey;
+    return undefined;
+  },
 }));
 
 mock.module("../media/gemini-image-service.js", () => ({
@@ -171,10 +176,11 @@ const CONFIG_DIR = join(
 
 beforeEach(() => {
   mockApiKey = "test-gemini-key";
+  mockImageGenMode = "your-own";
   mockGenerateResult = {
     images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
     text: "A beautiful image",
-    resolvedModel: "gemini-2.5-flash-image",
+    resolvedModel: "gemini-3.1-flash-image-preview",
   };
   mockGenerateError = null;
   mockAttachments = [];
@@ -208,9 +214,9 @@ describe("image-studio skill script wrapper", () => {
     expect(result.content).toContain("No Gemini API key");
   });
 
-  test("falls back to managed proxy when no API key is configured", async () => {
-    mockApiKey = undefined;
-    mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/vertex";
+  test("managed mode uses managed proxy credentials", async () => {
+    mockImageGenMode = "managed";
+    mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
     mockManagedProxyContext = {
       enabled: true,
       platformBaseUrl: "https://platform.example.com",
@@ -224,13 +230,25 @@ describe("image-studio skill script wrapper", () => {
     expect(lastGenerateCredentials).toEqual({
       type: "managed-proxy",
       assistantApiKey: "managed-key-123",
-      baseUrl: "https://platform.example.com/v1/runtime-proxy/vertex",
+      baseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
     });
   });
 
-  test("prefers direct API key over managed proxy", async () => {
+  test("managed mode returns error when managed proxy is unavailable", async () => {
+    mockImageGenMode = "managed";
+    mockApiKey = "direct-key"; // should be ignored in managed mode
+    mockManagedBaseUrl = undefined;
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Managed proxy is not available");
+  });
+
+  test("your-own mode uses direct API key", async () => {
+    mockImageGenMode = "your-own";
     mockApiKey = "direct-key";
-    mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/vertex";
+    mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
     mockManagedProxyContext = {
       enabled: true,
       platformBaseUrl: "https://platform.example.com",
@@ -250,7 +268,7 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Generated 1 image");
-    expect(result.content).toContain("gemini-2.5-flash-image");
+    expect(result.content).toContain("gemini-3.1-flash-image-preview");
     expect(result.content).toContain("A beautiful image");
     expect(result.contentBlocks).toHaveLength(1);
     expect(result.contentBlocks![0]).toEqual({
@@ -270,7 +288,7 @@ describe("image-studio skill script wrapper", () => {
         { mimeType: "image/png", dataBase64: "img2" },
       ],
       text: undefined as unknown as string,
-      resolvedModel: "gemini-2.5-flash-image",
+      resolvedModel: "gemini-3.1-flash-image-preview",
     };
 
     const result = await run({ prompt: "test", variants: 2 }, fakeContext);
@@ -357,8 +375,7 @@ describe("image-studio TOOLS.json manifest", () => {
     expect(props.mode.enum).toEqual(["generate", "edit"]);
     expect(props.attachment_ids.type).toBe("array");
     expect(props.model.enum).toEqual([
-      "gemini-2.5-flash-image",
-      "gemini-3-pro-image",
+      "gemini-3.1-flash-image-preview",
       "gemini-3-pro-image-preview",
     ]);
     expect(props.variants.type).toBe("number");

package/src/__tests__/media-reuse-story.e2e.test.ts

@@ -53,7 +53,7 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { shellDefaultTimeoutSec: 30, shellMaxTimeoutSec: 60 },
     sandbox: { enabled: false, backend: "native" },
   }),

package/src/__tests__/memory-context-benchmark.benchmark.test.ts

@@ -248,7 +248,7 @@ describe("Memory context benchmark", () => {
         ...DEFAULT_CONFIG.memory,
         embeddings: {
           ...DEFAULT_CONFIG.memory.embeddings,
-          provider: "openai" as const,
+          provider: "local" as const,
           required: false,
         },
         retrieval: {

package/src/__tests__/memory-lifecycle-e2e.test.ts

@@ -82,6 +82,7 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
+import { stripUserTextBlocksByPrefix } from "../daemon/conversation-runtime-assembly.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import {
   resetCleanupScheduleThrottle,
@@ -89,8 +90,7 @@ import {
 } from "../memory/jobs-worker.js";
 import {
   buildMemoryRecall,
-  injectMemoryRecallAsSeparateMessage,
-  stripMemoryRecallMessages,
+  injectMemoryRecallAsUserBlock,
 } from "../memory/retriever.js";
 import {
   conversations,
@@ -98,6 +98,7 @@ import {
   memoryItemSources,
   messages,
 } from "../memory/schema.js";
+import type { Message } from "../providers/types.js";
 
 describe("Memory lifecycle E2E regression", () => {
   beforeAll(() => {
@@ -322,7 +323,7 @@ describe("Memory lifecycle E2E regression", () => {
         totalOutputTokens: 0,
         totalEstimatedCost: 0,
         contextSummary: null,
-        contextCompactedMessageCount: 0,
+        contextCompactedMessageCount: 1,
         contextCompactedAt: null,
       })
       .run();
@@ -365,34 +366,39 @@ describe("Memory lifecycle E2E regression", () => {
     expect(recall.enabled).toBe(true);
     expect(recall.injectedText.length).toBeGreaterThan(0);
     expect(recall.injectedTokens).toBeGreaterThan(0);
-    expect(recall.injectedText).toContain("<memory_context>");
+    expect(recall.injectedText).toContain("<memory_context __injected>");
     expect(recall.injectedText).toContain("</memory_context>");
   });
 
-  test("stripping removes <memory_context> tags from injected recall", () => {
+  test("stripping removes <memory_context> block from injected recall", () => {
     const memoryRecallText =
-      "<memory_context>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
-    const originalMessages = [
+      "<memory_context __injected>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
+    const originalMessages: Message[] = [
       {
-        role: "user" as const,
-        content: [{ type: "text", text: "Actual user request" }],
+        role: "user",
+        content: [{ type: "text" as const, text: "Actual user request" }],
       },
     ];
-    const injected = injectMemoryRecallAsSeparateMessage(
+    const injected = injectMemoryRecallAsUserBlock(
       originalMessages,
       memoryRecallText,
     );
 
-    expect(injected).toHaveLength(3);
+    // Memory context prepended to the last user message as a content block
+    expect(injected).toHaveLength(1);
     expect(injected[0].role).toBe("user");
-    expect(injected[0].content[0].text).toBe(memoryRecallText);
-    expect(injected[1].role as string).toBe("assistant");
-    expect(injected[2].role).toBe("user");
-    expect(injected[2].content[0].text).toBe("Actual user request");
-
-    const cleaned = stripMemoryRecallMessages(injected, memoryRecallText);
+    expect(injected[0].content).toHaveLength(2);
+    const b0 = injected[0].content[0];
+    const b1 = injected[0].content[1];
+    expect(b0.type === "text" && b0.text).toBe(memoryRecallText);
+    expect(b1.type === "text" && b1.text).toBe("Actual user request");
+
+    // Stripped by prefix-based stripping (same mechanism as workspace/temporal)
+    const cleaned = stripUserTextBlocksByPrefix(injected, ["<memory_context __injected>"]);
     expect(cleaned).toHaveLength(1);
-    expect(cleaned[0].content[0].text).toBe("Actual user request");
+    expect(cleaned[0].content).toHaveLength(1);
+    const cb0 = cleaned[0].content[0];
+    expect(cb0.type === "text" && cb0.text).toBe("Actual user request");
   });
 
   test("empty retrieval returns no injection", async () => {

package/src/__tests__/memory-recall-quality.test.ts

@@ -112,6 +112,7 @@ function insertConversation(
   db: ReturnType<typeof getDb>,
   id: string,
   createdAt: number,
+  contextCompactedMessageCount = 0,
 ) {
   db.insert(conversations)
     .values({
@@ -123,7 +124,7 @@ function insertConversation(
       totalOutputTokens: 0,
       totalEstimatedCost: 0,
       contextSummary: null,
-      contextCompactedMessageCount: 0,
+      contextCompactedMessageCount,
       contextCompactedAt: null,
     })
     .run();
@@ -629,7 +630,7 @@ describe("Memory Recall Quality", () => {
     test("invalidated items are excluded from recall", async () => {
       const db = getDb();
       const now = 1_700_000_275_000;
-      insertConversation(db, "conv-invalid-status", now);
+      insertConversation(db, "conv-invalid-status", now, 1);
       insertMessage(
         db,
         "msg-invalid-status",
@@ -989,7 +990,7 @@ describe("Memory Recall Quality", () => {
     test("precision@k guard verifies pipeline completes with seeded segments", async () => {
       const db = getDb();
       const now = 1_700_000_700_000;
-      insertConversation(db, "conv-pk", now);
+      insertConversation(db, "conv-pk", now, 3);
 
       const prefs = [
         {

package/src/__tests__/memory-regressions.test.ts

@@ -67,8 +67,8 @@ import { and, eq } from "drizzle-orm";
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 import { vectorToBlob } from "../memory/job-utils.js";
 
-// Disable LLM extraction in tests to avoid real API calls and ensure
-// deterministic pattern-based extraction.
+// Disable LLM extraction and summarization in tests to avoid real API calls
+// and ensure deterministic pattern-based extraction / fallback summaries.
 const TEST_CONFIG = {
   ...DEFAULT_CONFIG,
   memory: {
@@ -77,6 +77,10 @@ const TEST_CONFIG = {
       ...DEFAULT_CONFIG.memory.extraction,
       useLLM: false,
     },
+    summarization: {
+      ...DEFAULT_CONFIG.memory.summarization,
+      useLLM: false,
+    },
   },
 };
 
@@ -86,6 +90,7 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 import { estimateTextTokens } from "../context/token-estimator.js";
+import { stripUserTextBlocksByPrefix } from "../daemon/conversation-runtime-assembly.js";
 import {
   getMemorySystemStatus,
   requestMemoryBackfill,
@@ -120,8 +125,7 @@ import {
   escapeXmlTags,
   formatAbsoluteTime,
   formatRelativeTime,
-  injectMemoryRecallAsSeparateMessage,
-  stripMemoryRecallMessages,
+  injectMemoryRecallAsUserBlock,
 } from "../memory/retriever.js";
 import {
   conversations,
@@ -133,6 +137,7 @@ import {
   messages,
 } from "../memory/schema.js";
 import { buildCoreIdentityContext } from "../prompts/system-prompt.js";
+import type { Message } from "../providers/types.js";
 
 describe("Memory regressions", () => {
   beforeAll(() => {
@@ -308,133 +313,124 @@ describe("Memory regressions", () => {
     expect(recall.enabled).toBe(true);
   });
 
-  test("memory recall injection via separate message and stripped from runtime history", () => {
+  test("memory recall injection as user block and stripped from runtime history", () => {
     const memoryRecallText =
-      "<memory_context>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
-    const originalMessages = [
+      "<memory_context __injected>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
+    const originalMessages: Message[] = [
       {
-        role: "user" as const,
-        content: [{ type: "text", text: "Actual user request" }],
+        role: "user",
+        content: [{ type: "text" as const, text: "Actual user request" }],
       },
     ];
-    const injected = injectMemoryRecallAsSeparateMessage(
+    const injected = injectMemoryRecallAsUserBlock(
       originalMessages,
       memoryRecallText,
     );
 
-    expect(injected).toHaveLength(3);
+    // Memory context prepended to last user message as content block
+    expect(injected).toHaveLength(1);
     expect(injected[0].role).toBe("user");
-    expect(injected[0].content[0].text).toBe(memoryRecallText);
-    expect(injected[1].role as string).toBe("assistant");
-    expect(injected[2].role).toBe("user");
-    expect(injected[2].content[0].text).toBe("Actual user request");
-
-    const cleaned = stripMemoryRecallMessages(injected, memoryRecallText);
+    expect(injected[0].content).toHaveLength(2);
+    const b0 = injected[0].content[0];
+    const b1 = injected[0].content[1];
+    expect(b0.type === "text" && b0.text).toBe(memoryRecallText);
+    expect(b1.type === "text" && b1.text).toBe("Actual user request");
+
+    // Stripped by prefix-based stripping
+    const cleaned = stripUserTextBlocksByPrefix(injected, [
+      "<memory_context __injected>",
+    ]);
     expect(cleaned).toHaveLength(1);
-    expect(cleaned[0].content[0].text).toBe("Actual user request");
+    expect(cleaned[0].content).toHaveLength(1);
+    const cb0 = cleaned[0].content[0];
+    expect(cb0.type === "text" && cb0.text).toBe("Actual user request");
   });
 
-  test("recall stripping removes last matching block in merged content after deep-repair", () => {
+  test("prefix-based stripping removes all <memory_context> blocks from merged content", () => {
     const memoryRecallText =
-      "[Memory Recall v1]\n- [item:abc] user prefers concise answers";
-    // Simulate deep-repair merging two consecutive user messages where both
-    // contain the recall text. The injected (active) recall block is the last one.
-    const mergedUserMessage = {
-      role: "user" as const,
+      "<memory_context __injected>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
+    // Simulate deep-repair merging where multiple memory context blocks exist.
+    // Prefix-based stripping removes all blocks starting with <memory_context __injected>.
+    const mergedUserMessage: Message = {
+      role: "user",
       content: [
-        { type: "text", text: memoryRecallText },
-        { type: "text", text: "Earlier user request" },
-        { type: "text", text: memoryRecallText },
-        { type: "text", text: "Latest user request" },
+        { type: "text" as const, text: memoryRecallText },
+        { type: "text" as const, text: "Earlier user request" },
+        { type: "text" as const, text: memoryRecallText },
+        { type: "text" as const, text: "Latest user request" },
       ],
     };
 
-    const cleaned = stripMemoryRecallMessages(
+    const cleaned = stripUserTextBlocksByPrefix(
       [mergedUserMessage],
-      memoryRecallText,
+      ["<memory_context __injected>"],
     );
     expect(cleaned).toHaveLength(1);
-    // The last (active) recall block should be stripped, the first (leaked) one preserved
     expect(cleaned[0].content).toEqual([
-      { type: "text", text: memoryRecallText },
       { type: "text", text: "Earlier user request" },
       { type: "text", text: "Latest user request" },
     ]);
   });
 
-  test("separate_context_message injects memory as user+assistant pair before last user message", () => {
-    const history = [
-      { role: "user" as const, content: [{ type: "text", text: "Hello" }] },
-      { role: "assistant" as const, content: [{ type: "text", text: "Hi!" }] },
+  test("injectMemoryRecallAsUserBlock prepends memory to last user message", () => {
+    const history: Message[] = [
+      { role: "user", content: [{ type: "text" as const, text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text" as const, text: "Hi!" }] },
       {
-        role: "user" as const,
-        content: [{ type: "text", text: "Tell me about X" }],
+        role: "user",
+        content: [{ type: "text" as const, text: "Tell me about X" }],
       },
     ];
-    const recallText = "<memory>Some recalled fact</memory>";
-    const result = injectMemoryRecallAsSeparateMessage(history, recallText);
-    // Should have 5 messages: original 2 + injected user + injected assistant ack + original last user
-    expect(result).toHaveLength(5);
+    const recallText =
+      "<memory_context __injected>\n\n<relevant_context>\nSome recalled fact\n</relevant_context>\n\n</memory_context>";
+    const result = injectMemoryRecallAsUserBlock(history, recallText);
+    // Same number of messages — no synthetic pair
+    expect(result).toHaveLength(3);
     expect(result[0]).toBe(history[0]);
     expect(result[1]).toBe(history[1]);
-    // Injected context message
-    expect(result[2].role).toBe("user");
-    expect(result[2].content).toEqual([{ type: "text", text: recallText }]);
-    // Assistant acknowledgment
-    expect(result[3].role).toBe("assistant");
-    expect(result[3].content).toEqual([
-      { type: "text", text: "[Memory context loaded.]" },
-    ]);
-    // Original user message preserved unchanged
-    expect(result[4]).toBe(history[2]);
+    // Last user message has memory prepended
+    const r0 = result[2].content[0];
+    const r1 = result[2].content[1];
+    expect(r0.type === "text" && r0.text).toBe(recallText);
+    expect(r1.type === "text" && r1.text).toBe("Tell me about X");
   });
 
-  test("separate_context_message with empty text is a no-op", () => {
-    const history = [
-      { role: "user" as const, content: [{ type: "text", text: "Hello" }] },
+  test("injectMemoryRecallAsUserBlock with empty text is a no-op", () => {
+    const history: Message[] = [
+      { role: "user", content: [{ type: "text" as const, text: "Hello" }] },
     ];
-    const result = injectMemoryRecallAsSeparateMessage(history, "  ");
+    const result = injectMemoryRecallAsUserBlock(history, "  ");
     expect(result).toBe(history);
   });
 
-  test("stripMemoryRecallMessages removes separate_context_message pair", () => {
-    const recallText = "<memory>Some recalled fact</memory>";
-    const messages = [
-      { role: "user" as const, content: [{ type: "text", text: "Hello" }] },
-      { role: "assistant" as const, content: [{ type: "text", text: "Hi!" }] },
-      // Injected context message pair
-      { role: "user" as const, content: [{ type: "text", text: recallText }] },
+  test("stripUserTextBlocksByPrefix removes memory_context block from user message", () => {
+    const recallText =
+      "<memory_context __injected>\n\n<relevant_context>\nSome recalled fact\n</relevant_context>\n\n</memory_context>";
+    const msgs: Message[] = [
+      { role: "user", content: [{ type: "text" as const, text: "Hello" }] },
       {
-        role: "assistant" as const,
-        content: [{ type: "text", text: "[Memory context loaded.]" }],
-      },
-      // Real user message
-      {
-        role: "user" as const,
-        content: [{ type: "text", text: "Tell me about X" }],
+        role: "assistant",
+        content: [{ type: "text" as const, text: "Hi!" }],
       },
-    ];
-    const cleaned = stripMemoryRecallMessages(messages, recallText);
-    expect(cleaned).toHaveLength(3);
-    expect(cleaned[0].content[0].text).toBe("Hello");
-    expect(cleaned[1].content[0].text).toBe("Hi!");
-    expect(cleaned[2].content[0].text).toBe("Tell me about X");
-  });
-
-  test("stripMemoryRecallMessages falls back to prepend_user_block when no separate pair found", () => {
-    const recallText = "<memory>Fact</memory>";
-    const messages = [
       {
-        role: "user" as const,
+        role: "user",
         content: [
-          { type: "text", text: recallText },
-          { type: "text", text: "User query" },
+          { type: "text" as const, text: recallText },
+          { type: "text" as const, text: "Tell me about X" },
         ],
       },
     ];
-    const cleaned = stripMemoryRecallMessages(messages, recallText);
-    expect(cleaned).toHaveLength(1);
-    expect(cleaned[0].content).toEqual([{ type: "text", text: "User query" }]);
+    const cleaned = stripUserTextBlocksByPrefix(msgs, [
+      "<memory_context __injected>",
+    ]);
+    expect(cleaned).toHaveLength(3);
+    const c0 = cleaned[0].content[0];
+    const c1 = cleaned[1].content[0];
+    const c2 = cleaned[2].content[0];
+    expect(c0.type === "text" && c0.text).toBe("Hello");
+    expect(c1.type === "text" && c1.text).toBe("Hi!");
+    expect(cleaned[2].content).toHaveLength(1);
+    expect(c2.type === "text" && c2.text).toBe("Tell me about X");
   });
 
   test("aborting memory recall embedding returns a non-degraded aborted recall result", async () => {
@@ -1819,7 +1815,7 @@ describe("Memory regressions", () => {
         totalOutputTokens: 0,
         totalEstimatedCost: 0,
         contextSummary: null,
-        contextCompactedMessageCount: 0,
+        contextCompactedMessageCount: 1,
         contextCompactedAt: null,
       })
       .run();
@@ -2064,7 +2060,7 @@ describe("Memory regressions", () => {
         totalOutputTokens: 0,
         totalEstimatedCost: 0,
         contextSummary: null,
-        contextCompactedMessageCount: 0,
+        contextCompactedMessageCount: 1,
         contextCompactedAt: null,
       })
       .run();
@@ -2138,7 +2134,7 @@ describe("Memory regressions", () => {
         totalOutputTokens: 0,
         totalEstimatedCost: 0,
         contextSummary: null,
-        contextCompactedMessageCount: 0,
+        contextCompactedMessageCount: 1,
         contextCompactedAt: null,
       })
       .run();