@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/memory-v2-static-injector.test.ts

@@ -2,26 +2,46 @@
  * Tests for the `memory-v2-static` runtime injector.
  *
  * Covers:
- *   - Returns null when `memoryV2Static` is missing/empty.
+ *   - Returns null when the v2 static memory files are absent/empty.
  *   - Returns null when `mode === "minimal"`.
  *   - Wraps content in `<info>...</info>` and uses
  *     `after-memory-prefix` placement.
  *   - Escapes any `</info>` substring inside the authored content so the
  *     wrapper cannot be broken out of.
+ *   - Skips (re)injection when the `<info>` block is already present in the
+ *     turn's working messages (presence detection — the block persists in
+ *     history between compactions).
  *
- * Hermetic: drives the injector's `produce()` directly with a synthesized
- * `TurnContext` — no daemon, no filesystem.
+ * The injector sources its content itself via `readMemoryV2StaticContent()`
+ * behind the personal-memory trust gate, so each test seeds the workspace
+ * memory files rather than passing the content in as an option. Mocks
+ * `config/loader` so the v2 gates are on without standing up a full config.
  */
 
-import { describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { defaultInjectorsPlugin } from "../plugins/defaults/injectors/register.js";
+const realLoader = await import("../config/loader.js");
+
+mock.module("../config/loader.js", () => ({
+  ...realLoader,
+  loadConfig: () => ({
+    memory: { enabled: true, v2: { enabled: true } },
+  }),
+  getConfig: () => ({
+    memory: { enabled: true, v2: { enabled: true } },
+  }),
+}));
+
+const { defaultInjectors } =
+  await import("../plugins/defaults/memory-retrieval/injectors.js");
 import type { Injector, TurnContext } from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 
 function findInjector(name: string): Injector {
-  const injector = defaultInjectorsPlugin.injectors?.find(
-    (i) => i.name === name,
-  );
+  const injector = defaultInjectors.find((i) => i.name === name);
   if (!injector) {
     throw new Error(`injector '${name}' not registered`);
   }
@@ -34,57 +54,69 @@ function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
     conversationId: "conv-test",
     turnIndex: 0,
     trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    injectionInputs: {},
     ...overrides,
   };
 }
 
+/** Seed a single v2 static memory section under `## Essentials`. */
+function seedEssentials(body: string): void {
+  const path = getWorkspacePromptPath("memory/essentials.md");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, body, "utf-8");
+}
+
+function seedThreads(body: string): void {
+  const path = getWorkspacePromptPath("memory/threads.md");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, body, "utf-8");
+}
+
+function clearV2StaticFiles(): void {
+  for (const file of [
+    "memory/essentials.md",
+    "memory/threads.md",
+    "memory/recent.md",
+    "memory/buffer.md",
+  ]) {
+    rmSync(getWorkspacePromptPath(file), { force: true });
+  }
+}
+
 const memoryV2StaticInjector = findInjector("memory-v2-static");
 
 describe("memory-v2-static injector", () => {
-  test("returns null when memoryV2Static is undefined", async () => {
-    const ctx = makeContext({ injectionInputs: {} });
-    expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
-  });
+  beforeEach(() => clearV2StaticFiles());
+  afterEach(() => clearV2StaticFiles());
 
-  test("returns null when memoryV2Static is null", async () => {
-    const ctx = makeContext({ injectionInputs: { memoryV2Static: null } });
-    expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
-  });
-
-  test("returns null when memoryV2Static is an empty string", async () => {
-    const ctx = makeContext({ injectionInputs: { memoryV2Static: "" } });
+  test("returns null when the v2 static memory files are absent", async () => {
+    const ctx = makeContext();
     expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
   });
 
   test("returns null in minimal mode even with content", async () => {
-    const ctx = makeContext({
-      injectionInputs: {
-        mode: "minimal",
-        memoryV2Static: "## Essentials\n\nAlice prefers VS Code.",
-      },
-    });
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext({ injectionInputs: { mode: "minimal" } });
     expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
   });
 
   test("wraps content in <info>...</info> with after-memory-prefix placement", async () => {
-    const content =
-      "## Essentials\n\nAlice prefers VS Code.\n\n## Threads\n\nOpen: ship PR.";
-    const ctx = makeContext({
-      injectionInputs: { memoryV2Static: content },
-    });
+    seedEssentials("Alice prefers VS Code.");
+    seedThreads("Open: ship PR.");
+    const ctx = makeContext();
 
     const block = await memoryV2StaticInjector.produce(ctx);
     expect(block).not.toBeNull();
     expect(block!.id).toBe("memory-v2-static");
     expect(block!.placement).toBe("after-memory-prefix");
-    expect(block!.text).toBe(`<info>\n${content}\n</info>`);
+    expect(block!.text).toBe(
+      "<info>\n## Essentials\n\nAlice prefers VS Code.\n\n## Threads\n\nOpen: ship PR.\n</info>",
+    );
   });
 
   test("escapes inner </info> closing tags so the wrapper cannot be broken out of", async () => {
-    const content = "## Essentials\n\nText with </info> embedded.";
-    const ctx = makeContext({
-      injectionInputs: { memoryV2Static: content },
-    });
+    seedEssentials("Text with </info> embedded.");
+    const ctx = makeContext();
 
     const block = await memoryV2StaticInjector.produce(ctx);
     expect(block).not.toBeNull();
@@ -92,4 +124,40 @@ describe("memory-v2-static injector", () => {
       "<info>\n## Essentials\n\nText with &lt;/info&gt; embedded.\n</info>",
     );
   });
+
+  test("skips (re)injection when the <info> block is already present", async () => {
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const runMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<info>\nstale memory\n</info>" },
+          { type: "text", text: "What next?" },
+        ],
+      },
+    ];
+    expect(await memoryV2StaticInjector.produce(ctx, runMessages)).toBeNull();
+  });
+
+  test("skips (re)injection when a legacy <memory>-wrapped static block is present", async () => {
+    // Rows persisted before the `<info>` switch rehydrate the static block as
+    // `<memory>…</memory>`. Re-injecting a fresh `<info>` copy alongside it
+    // would duplicate the content until the next compaction.
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const runMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+          },
+          { type: "text", text: "What next?" },
+        ],
+      },
+    ];
+    expect(await memoryV2StaticInjector.produce(ctx, runMessages)).toBeNull();
+  });
 });

package/src/__tests__/native-web-search.test.ts

@@ -71,9 +71,56 @@ mock.module("@anthropic-ai/sdk", () => ({
   },
 }));
 
+// Mock daemon collaborators the handler module imports at load time so the
+// handler-level tests below can drive `server_tool_complete` in isolation.
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: () => null,
+  updateMessageContent: () => {},
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
 // Import after mocking
+import {
+  createEventHandlerState,
+  type EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
 import { AnthropicProvider } from "../providers/anthropic/client.js";
 import { isNativeWebSearchCapableProvider } from "../providers/registry.js";
+import { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } from "../tools/network/web-search-error.js";
+import {
+  completeNativeWebSearch,
+  createHandlerDeps,
+  lastToolResult,
+  toolResults,
+} from "./helpers/native-web-search-harness.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -499,3 +546,147 @@ describe("Native Web Search — Streaming Events", () => {
     expect(toolUseEvents).toHaveLength(1);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Tests — Native server_tool_complete backend-failure handling (ATL-727)
+// ---------------------------------------------------------------------------
+
+describe("Native Web Search — Backend Failure Handling", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    state = createEventHandlerState();
+  });
+
+  test("backend failure surfaces friendly copy with isError true and empty results", async () => {
+    const { deps, events } = createHandlerDeps();
+    await completeNativeWebSearch(state, deps, "tu_backend", {
+      isError: true,
+      errorCode: "unavailable",
+    });
+
+    const result = lastToolResult(events);
+    expect(result?.activityMetadata?.webSearch?.errorMessage).toBe(
+      WEB_SEARCH_BACKEND_FAILURE_MESSAGE,
+    );
+    expect(result?.isError).toBe(true);
+    expect(result?.activityMetadata?.webSearch?.resultCount).toBe(0);
+    expect(result?.activityMetadata?.webSearch?.results).toEqual([]);
+  });
+
+  test("raw error_code is logged under web_search_backend_failure but absent from user copy", async () => {
+    const { deps, events, warnings } = createHandlerDeps();
+    await completeNativeWebSearch(state, deps, "tu_log", {
+      isError: true,
+      errorCode: "unavailable",
+    });
+
+    const failureLog = warnings.find(
+      (w) => w.obj.event === "web_search_backend_failure",
+    );
+    expect(failureLog).toBeDefined();
+    expect(failureLog?.obj.provider).toBe("anthropic-native");
+    expect(String(failureLog?.obj.rawDetail)).toContain("unavailable");
+    expect(failureLog?.obj.fallbackShown).toBe(true);
+
+    const errorMessage = lastToolResult(events)?.activityMetadata?.webSearch
+      ?.errorMessage;
+    expect(errorMessage).not.toContain("unavailable");
+  });
+
+  test("dedups repeat backend failures within one turn to a single friendly notice", async () => {
+    const { deps, events, warnings } = createHandlerDeps();
+
+    await completeNativeWebSearch(state, deps, "tu_dup_1", {
+      isError: true,
+      errorCode: "unavailable",
+    });
+    await completeNativeWebSearch(state, deps, "tu_dup_2", {
+      isError: true,
+      errorCode: "overloaded_error",
+    });
+
+    const results = toolResults(events);
+    expect(results).toHaveLength(2);
+    expect(results[0]?.activityMetadata?.webSearch?.errorMessage).toBe(
+      WEB_SEARCH_BACKEND_FAILURE_MESSAGE,
+    );
+    // The second backend failure in the same turn is terse, not the full notice.
+    expect(results[1]?.activityMetadata?.webSearch?.errorMessage).not.toBe(
+      WEB_SEARCH_BACKEND_FAILURE_MESSAGE,
+    );
+
+    const failureLogs = warnings.filter(
+      (w) => w.obj.event === "web_search_backend_failure",
+    );
+    // Both failures are logged, but only the first reports fallbackShown.
+    expect(failureLogs).toHaveLength(2);
+    expect(failureLogs.filter((w) => w.obj.fallbackShown === true)).toHaveLength(
+      1,
+    );
+  });
+
+  test("successful search leaves errorMessage undefined and populates results", async () => {
+    const { deps, events, warnings } = createHandlerDeps();
+    await completeNativeWebSearch(state, deps, "tu_ok", {
+      isError: false,
+      content: [
+        {
+          type: "web_search_result",
+          title: "Weather",
+          url: "https://example.com/weather",
+        },
+      ],
+    });
+
+    const meta = lastToolResult(events)?.activityMetadata?.webSearch;
+    expect(meta?.errorMessage).toBeUndefined();
+    expect(meta?.resultCount).toBe(1);
+    expect(meta?.results[0]?.title).toBe("Weather");
+    expect(lastToolResult(events)?.isError).toBe(false);
+    expect(
+      warnings.filter((w) => w.obj.event === "web_search_backend_failure"),
+    ).toHaveLength(0);
+  });
+
+  test("query_too_long yields a distinct non-backend message", async () => {
+    const { deps, events, warnings } = createHandlerDeps();
+    await completeNativeWebSearch(state, deps, "tu_long", {
+      isError: true,
+      errorCode: "query_too_long",
+    });
+
+    const errorMessage = lastToolResult(events)?.activityMetadata?.webSearch
+      ?.errorMessage;
+    expect(errorMessage).toBeDefined();
+    expect(errorMessage).not.toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    // Recoverable non-backend errors must NOT emit backend-failure telemetry.
+    expect(
+      warnings.filter((w) => w.obj.event === "web_search_backend_failure"),
+    ).toHaveLength(0);
+  });
+
+  test("message-less native failure (no error_code) surfaces friendly copy, not the terse 'Search failed' placeholder, and emits no backend telemetry", async () => {
+    const { deps, events, warnings } = createHandlerDeps("req-unknown");
+    // `isError:true` with no error_code/message classifies as `unknown`
+    // (isBackendFailure:false, empty userMessage). It must still get the
+    // friendly copy rather than the bare "Search failed".
+    await completeNativeWebSearch(state, deps, "tu_unknown", {
+      isError: true,
+    });
+
+    const result = lastToolResult(events);
+    const meta = result?.activityMetadata?.webSearch;
+    expect(meta?.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(meta?.errorMessage).not.toBe("Search failed");
+    expect(result?.isError).toBe(true);
+    expect(meta?.resultCount).toBe(0);
+    expect(meta?.results).toEqual([]);
+
+    // An unclassifiable failure borrows the friendly copy but must NOT be
+    // logged as a backend outage.
+    expect(
+      warnings.filter((w) => w.obj.event === "web_search_backend_failure"),
+    ).toHaveLength(0);
+  });
+});

package/src/__tests__/onboarding-template-contract.test.ts

@@ -71,6 +71,8 @@ describe("onboarding template contracts", () => {
 
     test("offers assistant migration during low-signal first openings", () => {
       expect(bootstrap).toContain("## Assistant migration");
+      expect(bootstrap).toContain("onboarding self-introduction");
+      expect(bootstrap).toContain("treat it as the real first user turn");
       expect(bootstrap).toContain(
         "If the first real user turn is only a greeting",
       );

package/src/__tests__/openai-image-service.test.ts

@@ -351,6 +351,23 @@ describe("mapOpenAIError", () => {
     expect(msg).toContain("Rate limit");
   });
 
+  test("maps 402 status to a non-retryable out-of-credits message", () => {
+    const msg = mapOpenAIError(new FakeAPIError(402, "payment required"));
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Please try again");
+  });
+
+  test("maps insufficient_quota (reported as 429) to out-of-credits message", () => {
+    const msg = mapOpenAIError(
+      new FakeAPIError(
+        429,
+        "You exceeded your current quota, please check your plan and billing details. (insufficient_quota)",
+      ),
+    );
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Rate limit");
+  });
+
   test("maps 500 status to server error message", () => {
     const msg = mapOpenAIError(new FakeAPIError(500, "internal"));
     expect(msg).toContain("temporarily unavailable");

package/src/__tests__/openai-provider.test.ts

@@ -105,7 +105,10 @@ mock.module("openai", () => ({
 import { FireworksProvider } from "../providers/fireworks/client.js";
 import { MinimaxProvider } from "../providers/minimax/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
-import { OpenAIChatCompletionsProvider } from "../providers/openai/chat-completions-provider.js";
+import {
+  EMPTY_ASSISTANT_TURN_PLACEHOLDER,
+  OpenAIChatCompletionsProvider,
+} from "../providers/openai/chat-completions-provider.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
 import { OpenRouterProvider } from "../providers/openrouter/client.js";
 
@@ -1584,6 +1587,33 @@ describe("OpenRouterProvider reasoning", () => {
     expect(lastCreateParams).not.toHaveProperty("usageAttributionHeaders");
   });
 
+  test("backfills placeholder content for a reasoning-only assistant turn", async () => {
+    const provider = new OpenRouterProvider("or-key", "deepseek/deepseek-chat");
+    await provider.sendMessage([
+      userMsg("question"),
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "truncated reasoning", signature: "" },
+        ],
+      },
+    ]);
+
+    const sent = lastCreateParams!.messages as Array<{
+      role: string;
+      content: string | null;
+      reasoning?: string;
+      tool_calls?: unknown;
+    }>;
+    const assistantMsg = sent.find((m) => m.role === "assistant")!;
+    // DeepSeek via OpenRouter rejects an assistant message with neither content
+    // nor tool_calls, so the reasoning-only turn is backfilled with the sentinel
+    // while the reasoning itself travels in the separate `reasoning` field.
+    expect(assistantMsg.content).toBe(EMPTY_ASSISTANT_TURN_PLACEHOLDER);
+    expect(assistantMsg.tool_calls).toBeUndefined();
+    expect(assistantMsg.reasoning).toBe("truncated reasoning");
+  });
+
   test("RetryProvider + OpenRouterProvider enables thinking end-to-end", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     const retry = new RetryProvider(provider);