@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/plugins/defaults/memory/tools.ts

@@ -3,12 +3,14 @@
  *
  * Core, always-loaded tools registered via the host tool manifest
  * (`tools/tool-manifest.ts`), so they carry core/workspace-override precedence
- * and the `"memory"` tool category. Their implementations source from the
- * memory feature (`src/memory/*`).
+ * and the `"memory"` tool category. The host's central input check covers only
+ * tools it can import, which excludes a plugin's, so each tool here parses its
+ * own input.
  */
 
-import { throwIfCancelled } from "@vellumai/plugin-api";
+import { invalidToolInputResult, throwIfCancelled } from "@vellumai/plugin-api";
 
+import { RememberInputSchema } from "../../../api/remember-tool.js";
 import { getConfig, getConfigReadOnly } from "../../../config/loader.js";
 import { usesConceptPageMemory } from "../../../config/memory-v3-gate.js";
 import { RiskLevel } from "../../../permissions/types.js";
@@ -19,8 +21,8 @@ import type {
   ToolExecutionResult,
 } from "../../../tools/types.js";
 import { runAgenticRecall } from "./context-search/agent-runner.js";
-import type { RecallInput } from "./context-search/types.js";
-import { handleRemember, type RememberInput } from "./graph/tool-handlers.js";
+import { RecallInputSchema } from "./context-search/recall-input.js";
+import { handleRemember } from "./graph/tool-handlers.js";
 import {
   buildRememberInputSchema,
   graphRecallDefinition,
@@ -52,18 +54,35 @@ export const rememberTool = {
     input: Record<string, unknown>,
     context: ToolContext,
   ): Promise<ToolExecutionResult> {
-    const typedInput = input as unknown as RememberInput;
     // The append below writes the memory buffer, so a cancelled turn stops here.
     throwIfCancelled(context);
+    if (!resolveCapabilities(context.trustClass).canAccessMemory) {
+      // No yield even when finish_turn is set: the model has to see this, so
+      // it never tells someone a fact was saved when it was not. An error, not
+      // a quiet no-op: a non-error `remember` result reads as a durable write to
+      // `memory-run-evidence`.
+      return {
+        content:
+          "Not saved: remember writes the guardian's long-term memory, which is only available on the guardian's own turns. Retrying will not help. Tell the person only if they asked you to remember this or you said you would.",
+        isError: true,
+      };
+    }
+    const parsed = RememberInputSchema.safeParse(input);
+    if (!parsed.success) {
+      return invalidToolInputResult("remember", parsed.error);
+    }
     const result = handleRemember(
-      typedInput,
+      parsed.data,
       context.conversationId,
       getConfig(),
     );
     return {
       content: result.message,
       isError: !result.success,
-      ...(typedInput.finish_turn === true ? { yieldToUser: true } : {}),
+      ...(result.success
+        ? { activityMetadata: { remember: { facts: result.facts } } }
+        : {}),
+      ...(parsed.data.finish_turn === true ? { yieldToUser: true } : {}),
     };
   },
 } satisfies ToolDefinition;
@@ -90,15 +109,23 @@ export const recallTool = {
       };
     }
 
+    const parsed = RecallInputSchema.safeParse(input);
+    if (!parsed.success) {
+      return invalidToolInputResult("recall", parsed.error);
+    }
     const config = getConfig();
-    const result = await runAgenticRecall(input as unknown as RecallInput, {
+    const result = await runAgenticRecall(parsed.data, {
       workingDir: context.workingDir,
       conversationId: context.conversationId,
       config,
       signal: context.signal,
     });
 
-    return { content: result.content, isError: false };
+    return {
+      content: result.content,
+      isError: false,
+      activityMetadata: { recall: result.activity },
+    };
   },
 } satisfies ToolDefinition;
 
@@ -127,7 +154,7 @@ export const recallTool = {
 export const deleteMemoryPageTool = {
   name: "delete_memory_page",
   description:
-    "Delete one concept page from your memory wiki, addressed by slug (its path under `memory/concepts/` minus `.md` — e.g. `alice`, `people/alice`, `procs/git-flow`). Use during a consolidation/maintenance pass to retire a page you merged into another, renamed (write the new page, then delete the old slug), or dropped as a dead stub. Only concept pages can be deleted — the index files (`recent.md`, `essentials.md`, `threads.md`, `buffer.md`) are rewritten with file_write/file_edit, never deleted. Idempotent: deleting a slug that is already gone is not an error. The immutable archive retains buffer history, so removing a page never loses source facts.",
+    "Delete one concept page from your memory wiki, addressed by slug (its path under `memory/concepts/` minus `.md`, e.g. `alice`, `people/alice`, `procs/git-flow`). Use during a consolidation/maintenance pass to retire a page you merged into another, renamed (write the new page, then delete the old slug), or dropped as a dead stub. Only concept pages can be deleted: the index files (`recent.md`, `essentials.md`, `threads.md`) are rewritten with file_write/file_edit, never deleted, and `buffer.md` is never written by you at all; the runtime removes the entries it handed you once the pass completes. Idempotent: deleting a slug that is already gone is not an error.",
   category: "memory",
   executionTarget: "sandbox",
   defaultRiskLevel: RiskLevel.Low,

package/src/plugins/defaults/memory/v1/graph/consolidation.ts

@@ -10,7 +10,7 @@
 // (same format as extraction) that is applied to the graph.
 // ---------------------------------------------------------------------------
 
-import { getConfiguredProvider } from "@vellumai/plugin-api";
+import { getConfiguredProvider, safeStringSlice } from "@vellumai/plugin-api";
 
 import type { AssistantConfig } from "../../../../../config/types.js";
 import { getMemoryDb } from "../../../../../persistence/db-connection.js";
@@ -26,7 +26,7 @@ import {
 } from "../../graph/store.js";
 import type { MemoryNode } from "../../graph/types.js";
 import { isCapabilityNode } from "../../graph/types.js";
-import { BackendUnavailableError, safeStringSlice } from "../../host-utils.js";
+import { BackendUnavailableError } from "../../host-utils.js";
 import { extractToolUse, userMessage } from "../../llm-helpers.js";
 import { getLogger } from "../../logging.js";
 import {

package/src/plugins/defaults/memory/v1/graph/extraction.ts

@@ -13,6 +13,7 @@ import type { ContentBlock, ImageContent, Message } from "@vellumai/plugin-api";
 import {
   getConfiguredProvider,
   getConversationDirPath,
+  safeStringSlice,
 } from "@vellumai/plugin-api";
 import { and, asc, desc, eq, gt } from "drizzle-orm";
 
@@ -46,7 +47,7 @@ import type {
   SourceType,
   TriggerType,
 } from "../../graph/types.js";
-import { BackendUnavailableError, safeStringSlice } from "../../host-utils.js";
+import { BackendUnavailableError } from "../../host-utils.js";
 import { extractToolUse, userMessage } from "../../llm-helpers.js";
 import { getLogger } from "../../logging.js";
 import { buildIdentityContext } from "../identity-context.js";

package/src/plugins/defaults/memory/v1/graph/retriever.ts

@@ -10,6 +10,7 @@ import type { ContentBlock, ImageContent } from "@vellumai/plugin-api";
 import {
   getConfiguredProvider,
   resolveMediaSourceData,
+  safeStringSlice,
 } from "@vellumai/plugin-api";
 import { selectedBackendSupportsMultimodal } from "@vellumai/plugin-api";
 
@@ -33,7 +34,6 @@ import type {
   ScoredNode,
 } from "../../graph/types.js";
 import { isCapabilityNode } from "../../graph/types.js";
-import { safeStringSlice } from "../../host-utils.js";
 import { extractToolUse, userMessage } from "../../llm-helpers.js";
 import { getLogger } from "../../logging.js";
 import { searchGraphNodes } from "./graph-search.js";

package/src/plugins/defaults/memory/v2/__tests__/migration.test.ts

@@ -62,7 +62,12 @@ mock.module("../../../../../persistence/jobs-store.js", () => ({
 // provider, but the safety net mock keeps any accidental real-call from
 // reaching the network — and lets us add a "no provider configured" test.
 let providerStub: Provider | null = null;
+// Spread the real module so the memory code under test keeps every other
+// plugin-API export (`safeStringSlice` among them); only the provider lookup
+// is stubbed.
+const realPluginApi = await import("@vellumai/plugin-api");
 mock.module("@vellumai/plugin-api", () => ({
+  ...realPluginApi,
   getConfiguredProvider: async () => providerStub,
 }));
 

package/src/plugins/defaults/memory/v2/__tests__/reranker.test.ts

@@ -10,10 +10,13 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AssistantConfig } from "../../../../../config/types.js";
 
+// Spread the real module: the reranker reaches the plugin API, whose import
+// graph names more of `util/platform` than the two overrides below, and ESM
+// named-import validation rejects a partial mock.
+const realPlatform = await import("../../../../../util/platform.js");
 mock.module("../../../../../util/platform.js", () => ({
+  ...realPlatform,
   getWorkspaceDir: () => "/tmp/test-workspace",
-  // Imported by the real util/logger.js; ESM named-import validation
-  // requires it even though the silent test logger never calls it.
   getLogsDir: () => "/tmp/test-workspace/logs",
 }));
 

package/src/plugins/defaults/memory/v2/reranker.ts

@@ -2,8 +2,9 @@
 
 import { createHash } from "node:crypto";
 
+import { safeStringSlice } from "@vellumai/plugin-api";
+
 import type { AssistantConfig } from "../../../../config/types.js";
-import { safeStringSlice } from "../host-utils.js";
 import { getLogger } from "../logging.js";
 import { getWorkspaceDir } from "../paths.js";
 import { readPage } from "../substrate/page-store.js";

package/src/plugins/defaults/memory/v3/__tests__/injection.test.ts

@@ -462,7 +462,7 @@ describe("memoryV3Injector: frozen net-new sections", () => {
     expect(activeIds("conv-voice")).toEqual(new Set());
   });
 
-  test("live retrieval failure queues a degraded-memory notice", async () => {
+  test("a live orchestration throw queues a degraded-memory notice and no block", async () => {
     liveEnabled = true;
     turnResults.set(
       0,
@@ -484,6 +484,86 @@ describe("memoryV3Injector: frozen net-new sections", () => {
     ]);
   });
 
+  test("a selector failure renders the unjudged stable prefix and queues a core-memories-only notice", async () => {
+    liveEnabled = true;
+    turnResults.set(0, {
+      ...result(["page-a", "page-b"]),
+      selectorRan: false,
+      selectorFailure: new MemoryV3RetrievalUnavailableError(
+        "selector unavailable",
+      ),
+    });
+
+    const block = await produceSections("conv-1", 0);
+
+    expect(block).not.toBeNull();
+    expect(block!.text).toContain("# memory/concepts/page-a.md");
+    expect(block!.text).toContain("# memory/concepts/page-b.md");
+    expect(drainConversationNotices("conv-1")).toEqual([
+      {
+        type: "conversation_notice",
+        conversationId: "conv-1",
+        source: "memory_v3",
+        code: "UNKNOWN",
+        userMessage:
+          "Memory selection is temporarily unavailable, so this response draws only on your core memories. You can retry in a moment.",
+        errorCategory: "memory_v3_degraded",
+      },
+    ]);
+  });
+
+  test("a selector failure whose stable prefix renders nothing queues the no-memory notice", async () => {
+    liveEnabled = true;
+    // The only stable page was deleted between lane construction and this
+    // turn's render, so no block attaches and the notice must not claim the
+    // response drew on core memories.
+    turnResults.set(0, {
+      ...result(["missing-page"]),
+      selectorRan: false,
+      selectorFailure: new MemoryV3RetrievalUnavailableError(
+        "selector unavailable",
+      ),
+    });
+
+    await expect(produceSectionsWithoutCommit("conv-1", 0)).resolves.toBeNull();
+
+    expect(drainConversationNotices("conv-1")).toEqual([
+      {
+        type: "conversation_notice",
+        conversationId: "conv-1",
+        source: "memory_v3",
+        code: "UNKNOWN",
+        userMessage:
+          "Memory is temporarily unavailable, so this response may not use your saved memories. You can retry in a moment.",
+        errorCategory: "memory_v3_degraded",
+      },
+    ]);
+  });
+
+  test("a selector failure carrying a billing notice queues that notice instead", async () => {
+    liveEnabled = true;
+    const billing = {
+      source: "memory_v3" as const,
+      code: "PROVIDER_BILLING" as const,
+      userMessage: "Add credits to keep using memory.",
+      errorCategory: "provider_billing",
+    };
+    turnResults.set(0, {
+      ...result(["page-a"]),
+      selectorRan: false,
+      selectorFailure: new MemoryV3RetrievalUnavailableError(
+        "selector unavailable",
+        { conversationNotice: billing },
+      ),
+    });
+
+    await produceSections("conv-1", 0);
+
+    expect(drainConversationNotices("conv-1")).toEqual([
+      { type: "conversation_notice", conversationId: "conv-1", ...billing },
+    ]);
+  });
+
   test("turn 1 renders matched sections and leads; turn 2 re-selecting the same renders ZERO new sections", async () => {
     liveEnabled = true;
     turnResults.set(0, result(["page-a", "page-b"], [["page-a", alpha]]));

package/src/plugins/defaults/memory/v3/__tests__/orchestrate.test.ts

@@ -148,6 +148,7 @@ const {
   MEMORY_V3_INJECTION_GATE_CHECK_NAME,
   MEMORY_V3_SELECTION_CHECK_NAME,
 } = await import("../orchestrate.js");
+const { MemoryV3RetrievalUnavailableError } = await import("../pool-select.js");
 
 // ---------------------------------------------------------------------------
 // Fixtures: a tiny corpus of pages with bodies + `links:` frontmatter.
@@ -2517,3 +2518,89 @@ describe("orchestrate: rare-term lane", () => {
     expect(result.lanes.finder).toEqual([]);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Selector infrastructure failure: the stable prefix is kept unjudged.
+// ---------------------------------------------------------------------------
+
+describe("selector infrastructure failure", () => {
+  /** A provider whose every send fails, so `selectPool` exhausts its
+   *  re-prompt retries and throws `MemoryV3RetrievalUnavailableError`. */
+  function failingProvider(): Provider {
+    return {
+      name: "stub",
+      sendMessage: async () => {
+        selectCalls++;
+        throw new Error("upstream rejected the request");
+      },
+    };
+  }
+
+  test("keeps the stable prefix unjudged, drops the finder tail, and records selector_ran: false", async () => {
+    const lanes = await buildLanes();
+    providerStub = failingProvider();
+
+    const result = await orchestrate(
+      makeTurn(1, "apple banana"),
+      depsOf(lanes, { coreSlugs: ["topic-c"], hotSlugs: ["topic-d"] }),
+    );
+
+    // The selector was tried (and retried) before the fallback engaged.
+    expect(selectCalls).toBeGreaterThan(1);
+    // The finder lane surfaced topic-a for the query, so the pool held it.
+    expect(result.lanes.finder.map((c) => c.slug)).toContain("topic-a");
+    // Only the stable prefix survives, in cache order, with no sections.
+    expect(result.selections.map((s) => s.slug)).toEqual([
+      "topic-c",
+      "topic-d",
+    ]);
+    expect(result.selections.every((s) => s.sections.length === 0)).toBe(true);
+    expect(result.selectorRan).toBe(false);
+    expect(result.selectorFailure).toBeInstanceOf(
+      MemoryV3RetrievalUnavailableError,
+    );
+    expect(recordedSelectionEvents).toHaveLength(1);
+    expect(recordedSelectionEvents[0]!.detail).toMatchObject({
+      selector_ran: false,
+      selector_failed: true,
+      selector_kept_all: false,
+      selected_count: 2,
+      pool_size: 3,
+    });
+  });
+
+  test("with no stable prefix the turn keeps nothing, and the failure still rides the result", async () => {
+    const lanes = await buildLanes();
+    providerStub = failingProvider();
+
+    const result = await orchestrate(
+      makeTurn(1, "apple banana"),
+      depsOf(lanes),
+    );
+
+    expect(result.selections).toEqual([]);
+    expect(result.selectorRan).toBe(false);
+    expect(result.selectorFailure).toBeInstanceOf(
+      MemoryV3RetrievalUnavailableError,
+    );
+  });
+
+  test("a non-infrastructure throw from the selector still propagates", async () => {
+    const lanes = await buildLanes();
+    providerStub = {
+      name: "stub",
+      sendMessage: async () => {
+        throw new Error("boom");
+      },
+    };
+    // `selectPool` wraps provider throws into its infrastructure error, so a
+    // plain throw reaching the orchestrator means something outside the
+    // selector broke; only a card map hole does that here.
+    await expect(
+      orchestrate(
+        makeTurn(1, "apple"),
+        depsOf(lanes, { coreSlugs: ["topic-c"], prefixCards: new Map() }),
+      ),
+    ).rejects.toThrow("no pre-rendered card");
+  });
+});

package/src/plugins/defaults/memory/v3/__tests__/plugin-schema.test.ts

@@ -25,6 +25,7 @@ import { ensureMemoryV3EverInjectedSchema } from "../../../../../persistence/mig
 import {
   deleteLegacyCardRows,
   ensureMemoryV3InjectedSectionsSchema,
+  ensureMemoryV3PoolInputsSchema,
   ensureMemoryV3PoolsSchema,
   ensureMemoryV3SelectionsSectionKeyOnce,
   ensureOncePerConnection,
@@ -442,6 +443,17 @@ describe("ensureMemoryV3PoolsSchema", () => {
   });
 });
 
+describe("ensureMemoryV3PoolInputsSchema", () => {
+  test("creates the input and text tables, idempotently", () => {
+    ensureMemoryV3PoolInputsSchema(memorySqlite);
+    ensureMemoryV3PoolInputsSchema(memorySqlite);
+
+    expect(objectNames(memorySqlite, "table")).toEqual(
+      expect.arrayContaining(["memory_v3_pool_inputs", "memory_v3_pool_texts"]),
+    );
+  });
+});
+
 describe("ensureMemoryV3SelectionsSectionKeyOnce", () => {
   test("adds section_key to the table migration 338 creates, keeping its rows", () => {
     ensureMemoryV3SelectionsSchema(memorySqlite);