@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/plugins/defaults/history-repair/hooks/user-prompt-submit.ts

@@ -10,13 +10,13 @@
  */
 
 import type {
-  PluginHookFn,
+  HookFunction,
   UserPromptSubmitContext,
 } from "@vellumai/plugin-api";
 
 import { repairHistory } from "../terminal.js";
 
-const userPromptSubmit: PluginHookFn<UserPromptSubmitContext> = async (ctx) => {
+const userPromptSubmit: HookFunction<UserPromptSubmitContext> = async (ctx) => {
   const { messages, stats } = repairHistory(ctx.latestMessages);
   ctx.latestMessages = messages;
   if (

package/src/plugins/defaults/image-fallback/__tests__/image-fallback.test.ts

@@ -12,8 +12,11 @@ import type {
 
 // ─── Mocks ──────────────────────────────────────────────────────────────────
 
-// Control doesSupportVision per-profile from the test.
+// Control doesSupportVision from the test: by profile key for the
+// user-prompt-submit path (ModelProfileInfo) and by model id for the
+// post-tool-use path (bare string).
 let visionProfiles: Set<string>;
+let visionModels: Set<string>;
 let mockProfiles: ModelProfileInfo[];
 let sendMessageResponse = {
   content: [{ type: "text", text: "A red chart showing Q3 revenue." }],
@@ -30,8 +33,10 @@ const fakeProvider = {
 // Mock @vellumai/plugin-api — only the runtime handles the plugin imports.
 // `extractAllText` stays real (imported from the relative path, not plugin-api).
 mock.module("@vellumai/plugin-api", () => ({
-  doesSupportVision: (profile: ModelProfileInfo) =>
-    visionProfiles.has(profile.key),
+  doesSupportVision: (arg: ModelProfileInfo | string) =>
+    typeof arg === "string"
+      ? visionModels.has(arg)
+      : visionProfiles.has(arg.key),
   getModelProfiles: () => mockProfiles,
   getConfiguredProvider: async () => (providerResolves ? fakeProvider : null),
 }));
@@ -136,6 +141,9 @@ function makeToolCtx(
 
 beforeEach(() => {
   visionProfiles = new Set<string>(["vision-profile"]);
+  // "text-only-model" (the default post-tool-use ctx.model) is absent, so it
+  // reads as text-only; a vision model id is added per-test.
+  visionModels = new Set<string>();
   mockProfiles = [
     profile("text-only", { label: "Text Only", isActive: true }),
     profile("vision-profile", { label: "Vision" }),
@@ -255,7 +263,10 @@ describe("image-fallback user-prompt-submit hook", () => {
     };
     // Override the mock to track calls.
     mock.module("@vellumai/plugin-api", () => ({
-      doesSupportVision: (p: ModelProfileInfo) => visionProfiles.has(p.key),
+      doesSupportVision: (arg: ModelProfileInfo | string) =>
+        typeof arg === "string"
+          ? visionModels.has(arg)
+          : visionProfiles.has(arg.key),
       getModelProfiles: () => mockProfiles,
       getConfiguredProvider: async () => trackingProvider,
     }));
@@ -273,7 +284,10 @@ describe("image-fallback user-prompt-submit hook", () => {
 
     // Restore the original mock for other tests.
     mock.module("@vellumai/plugin-api", () => ({
-      doesSupportVision: (p: ModelProfileInfo) => visionProfiles.has(p.key),
+      doesSupportVision: (arg: ModelProfileInfo | string) =>
+        typeof arg === "string"
+          ? visionModels.has(arg)
+          : visionProfiles.has(arg.key),
       getModelProfiles: () => mockProfiles,
       getConfiguredProvider: async () =>
         providerResolves ? fakeProvider : null,
@@ -346,9 +360,10 @@ describe("image-fallback post-tool-use hook", () => {
     );
   });
 
-  test("is a no-op when the active model supports vision", async () => {
-    visionProfiles = new Set(["text-only"]); // active profile supports vision
+  test("is a no-op when the model that ran supports vision", async () => {
+    visionModels = new Set(["vision-model"]);
     const ctx = makeToolCtx({
+      model: "vision-model",
       toolResponse: toolResult([imageBlock("shot1")]),
     });
     await postToolUse(ctx);
@@ -398,4 +413,29 @@ describe("image-fallback post-tool-use hook", () => {
     const text = (ctx.toolResponse.contentBlocks![0] as { text: string }).text;
     expect(text).not.toContain("saved to");
   });
+
+  test("is a no-op when contentBlocks carry no image", async () => {
+    const textBlock = { type: "text" as const, text: "just text" };
+    const ctx = makeToolCtx({ toolResponse: toolResult([textBlock]) });
+    await postToolUse(ctx);
+    expect(ctx.toolResponse.contentBlocks![0]).toEqual(textBlock);
+  });
+
+  test("gates on ctx.model, not the workspace active profile", async () => {
+    // The active profile is vision-capable, but the model that actually ran
+    // (ctx.model) is text-only — the model that ran must win, so the image is
+    // captioned.
+    mockProfiles = [
+      profile("vision-active", { isActive: true }),
+      profile("vision-profile", {}),
+    ];
+    visionProfiles = new Set(["vision-active", "vision-profile"]);
+    visionModels = new Set<string>(); // "text-only-model" is text-only
+    const ctx = makeToolCtx({
+      model: "text-only-model",
+      toolResponse: toolResult([imageBlock("shot1")]),
+    });
+    await postToolUse(ctx);
+    expect(ctx.toolResponse.contentBlocks![0].type).toBe("text");
+  });
 });

package/src/plugins/defaults/image-fallback/hooks/post-tool-use.ts

@@ -1,5 +1,5 @@
 /**
- * Default `post-tool-use` hook: when the active model is text-only, captions
+ * Default `post-tool-use` hook: when the turn's model is text-only, captions
  * the image blocks a tool returns (e.g. a `browser_screenshot`) and
  * substitutes the caption as a text block so the result stays sendable to a
  * provider that would otherwise reject the raw image.
@@ -9,30 +9,29 @@
  * rather than the top-level message content the `user-prompt-submit` hook
  * handles. Both share {@link captionImageBlocks}.
  *
- * The active model is resolved from the workspace's active profile — the
- * post-tool-use context carries the running model, and the active profile is
- * what the loop is executing this turn. If that profile supports vision, the
- * hook is a no-op and the image reaches the model untouched.
+ * Capability is read straight off `ctx.model` — the provider-reported model id
+ * for the turn that issued this tool call — so the decision tracks the model
+ * that actually ran, including a text-only override. The substitution is in
+ * place, so the persisted/displayed tool result carries the caption too.
  */
 
 import {
   doesSupportVision,
-  getModelProfiles,
-  type PluginHookFn,
+  type HookFunction,
   type PostToolUseContext,
 } from "@vellumai/plugin-api";
 
 import { captionImageBlocks } from "../src/caption-blocks.js";
 import { findVisionProfile } from "../src/vision-caption.js";
 
-const postToolUse: PluginHookFn<PostToolUseContext> = async (ctx) => {
+const postToolUse: HookFunction<PostToolUseContext> = async (ctx) => {
+  // Cheapest gate first: bail unless the tool actually returned an image,
+  // before touching the model catalog or resolving a vision profile.
   const blocks = ctx.toolResponse.contentBlocks;
-  if (blocks == null || blocks.length === 0) return;
+  if (blocks == null || !blocks.some((b) => b.type === "image")) return;
 
-  // If the active model already supports vision, leave the image in place.
-  const activeProfile = getModelProfiles().find((p) => p.isActive);
-  if (activeProfile == null) return;
-  if (doesSupportVision(activeProfile)) return;
+  // If the model that ran already supports vision, leave the image in place.
+  if (doesSupportVision(ctx.model)) return;
 
   // Find a vision-capable profile for captioning.
   const visionProfileKey = findVisionProfile();

package/src/plugins/defaults/image-fallback/hooks/user-prompt-submit.ts

@@ -1,5 +1,5 @@
 /**
- * Default `user-prompt-submit` hook: when the active model is text-only,
+ * Default `user-prompt-submit` hook: when the turn's model is text-only,
  * captions image blocks via a vision-capable profile and substitutes the
  * caption as a text block so the model can still reason about the image's
  * content.
@@ -7,13 +7,14 @@
  * The hook runs once per user turn, after the assistant assembles
  * `latestMessages` and before they flow into `agentLoop.run()`. It:
  *
- * 1. Resolves the active profile from `modelProfileKey` (or the workspace's
- *    active profile when the key is `null`) and checks `doesSupportVision`.
- *    If the model already handles images, the hook is a no-op.
+ * 1. Checks whether the turn's model needs image→text fallback via
+ *    {@link needsImageFallback} (resolving the turn's `modelProfileKey`, or the
+ *    workspace's active profile when the key is `null`). If the model handles
+ *    images, the hook is a no-op.
  * 2. Finds a vision-capable profile for captioning via `findVisionProfile`.
  *    If none exists, images are replaced with a fail-open placeholder so the
  *    model at least knows an image was present.
- * 3. Replaces each `ImageContent` block with a `[Image …]` text caption via
+ * 3. Replaces each image block with a `[Image …]` text caption via
  *    {@link captionImageBlocks} (which also persists the original and caches
  *    captions across turns).
  *
@@ -22,28 +23,19 @@
  */
 
 import {
-  doesSupportVision,
-  getModelProfiles,
-  type PluginHookFn,
+  type HookFunction,
   type UserPromptSubmitContext,
 } from "@vellumai/plugin-api";
 
-import { captionImageBlocks } from "../src/caption-blocks.js";
+import {
+  captionImageBlocks,
+  needsImageFallback,
+} from "../src/caption-blocks.js";
 import { findVisionProfile } from "../src/vision-caption.js";
 
-const userPromptSubmit: PluginHookFn<UserPromptSubmitContext> = async (ctx) => {
-  // Resolve the active profile from modelProfileKey, falling back to the
-  // workspace's active profile when the key is null (profile unchanged since
-  // the last notified turn).
-  const profiles = getModelProfiles();
-  const activeProfile =
-    ctx.modelProfileKey != null
-      ? profiles.find((p) => p.key === ctx.modelProfileKey)
-      : profiles.find((p) => p.isActive);
-  if (activeProfile == null) return;
-
-  // If the active model already supports vision, nothing to do.
-  if (doesSupportVision(activeProfile)) return;
+const userPromptSubmit: HookFunction<UserPromptSubmitContext> = async (ctx) => {
+  // If the turn's model already supports vision, nothing to do.
+  if (!needsImageFallback(ctx.modelProfileKey)) return;
 
   // Find a vision-capable profile for captioning.
   const visionProfileKey = findVisionProfile();

package/src/plugins/defaults/image-fallback/src/caption-blocks.ts

@@ -1,31 +1,62 @@
 /**
  * Shared image→text substitution for the image-fallback plugin's hooks.
  *
- * Two hooks replace `image` content blocks with a text caption when the active
+ * Two hooks replace `image` content blocks with a text caption when the turn's
  * model can't process images: `user-prompt-submit` handles user-attached
  * images, and `post-tool-use` handles images a tool returns (e.g. a browser
- * screenshot). This module holds the per-block substitution they share —
- * persist the original image to a known location, caption it via a
- * vision-capable profile, and swap in a `[Image …]` text block.
+ * screenshot). This module holds what they share — deciding whether a profile
+ * needs the fallback ({@link needsImageFallback}) and the per-block
+ * substitution ({@link captionImageBlocks}): persist the original image to a
+ * known location, caption it via a vision-capable profile, and swap in a
+ * `[Image …]` text block.
  *
- * The caption text states up front that the active model can't view images and
- * the image was auto-described to text, so the model treats the block as a
- * derived description rather than a verbatim transcript.
+ * The substitution mutates the blocks in place, so the caption replaces the
+ * image everywhere the block is referenced (the provider-bound history and the
+ * persisted/displayed copy alike) — a text-only turn does not keep the raw
+ * image around.
+ *
+ * The caption text states up front that the model can't view images and the
+ * image was auto-described to text, so the model treats the block as a derived
+ * description rather than a verbatim transcript.
  *
  * Fail-open is the dominant error mode: a captioning failure leaves a
  * placeholder text block rather than the raw image (which a text-only provider
  * would reject) or nothing (which would lose information).
  */
 
-import type {
-  ContentBlock,
-  ImageContent,
-  PluginLogger,
+import {
+  type ContentBlock,
+  doesSupportVision,
+  getModelProfiles,
+  type ImageContent,
+  type PluginLogger,
 } from "@vellumai/plugin-api";
 
 import { persistImage } from "./image-persist.js";
 import { captionImage } from "./vision-caption.js";
 
+/**
+ * Whether the profile a turn runs needs image→text fallback (i.e. it can't
+ * process images itself).
+ *
+ * Used by `user-prompt-submit`, whose context carries the profile key rather
+ * than the resolved model id: prefer the turn's `modelProfileKey` — which
+ * carries a text-only override even when the workspace's active profile is
+ * vision-capable — and fall back to the active profile only when the key is
+ * `null` (profile unchanged since the last notified turn). Returns `false` when
+ * no profile resolves or the resolved model already supports vision, in which
+ * case the image reaches the model untouched.
+ */
+export function needsImageFallback(modelProfileKey: string | null): boolean {
+  const profiles = getModelProfiles();
+  const activeProfile =
+    modelProfileKey != null
+      ? profiles.find((p) => p.key === modelProfileKey)
+      : profiles.find((p) => p.isActive);
+  if (activeProfile == null) return false;
+  return !doesSupportVision(activeProfile);
+}
+
 /**
  * Replace every `image` block in `blocks` (in place) with a text caption so a
  * text-only model can still reason about the image's content. Returns the

package/src/plugins/defaults/image-recovery/hooks/post-model-call.ts

@@ -24,7 +24,7 @@
  * empty-response hook; only a provider rejection is this hook's to act on.
  */
 
-import type { PluginHookFn, PostModelCallContext } from "@vellumai/plugin-api";
+import type { HookFunction, PostModelCallContext } from "@vellumai/plugin-api";
 
 import { isImageDimensionsTooLargeError } from "../detect.js";
 import {
@@ -36,7 +36,7 @@ import {
   recoverOversizedImages,
 } from "../recover.js";
 
-const postModelCall: PluginHookFn<PostModelCallContext> = async (ctx) => {
+const postModelCall: HookFunction<PostModelCallContext> = async (ctx) => {
   if (
     ctx.error &&
     isImageDimensionsTooLargeError(ctx.error.message) &&

package/src/plugins/defaults/image-recovery/hooks/stop.ts

@@ -11,11 +11,11 @@
  * retry the loop's per-run backstop refused).
  */
 
-import type { PluginHookFn, StopContext } from "@vellumai/plugin-api";
+import type { HookFunction, StopContext } from "@vellumai/plugin-api";
 
 import { clearImageRecoveryAttempted } from "../image-recovery-state-store.js";
 
-const stop: PluginHookFn<StopContext> = async (ctx) => {
+const stop: HookFunction<StopContext> = async (ctx) => {
   clearImageRecoveryAttempted(ctx.conversationId);
 };
 

package/src/plugins/defaults/index.ts

@@ -24,15 +24,8 @@
  * {@link registerDefaultPlugins} at call time.
  */
 
-import { finalizeTool } from "../../tools/tool-defaults.js";
 import { registerPlugin, resetPluginRegistryForTests } from "../registry.js";
 import { type Plugin, PluginExecutionError } from "../types.js";
-import { resetAdvisorStateForTests } from "./advisor/advisor-state-store.js";
-import advisorPostModelCall from "./advisor/hooks/post-model-call.js";
-import advisorPreModelCall from "./advisor/hooks/pre-model-call.js";
-import advisorUserPromptSubmit from "./advisor/hooks/user-prompt-submit.js";
-import advisorPkg from "./advisor/package.json" with { type: "json" };
-import advisorTool from "./advisor/tools/advisor.js";
 import compactionPkg from "./compaction/package.json" with { type: "json" };
 import emptyResponsePostModelCall from "./empty-response/hooks/post-model-call.js";
 import emptyResponseStop from "./empty-response/hooks/stop.js";
@@ -329,30 +322,6 @@ export const defaultToolResultTruncatePlugin: Plugin = {
   },
 };
 
-/**
- * `advisor` — adds the model-visible `advisor` tool: a no-argument tool the
- * model calls to consult a stronger inference profile (the `inference` call
- * site with a `quality-optimized` override) on the full transcript, routed
- * through the assistant's own inference. Three hooks feed it: `user-prompt-submit`
- * seeds the capture, `pre-model-call` records the executor's system prompt and
- * injects the steering that nudges the model to consult, and `post-model-call`
- * snapshots the transcript the tool reads. `finalizeTool` fills the tool's
- * defaults so it satisfies `Tool`, and `bootstrapPlugins` registers it into the
- * catalog.
- */
-export const defaultAdvisorPlugin: Plugin = {
-  manifest: {
-    name: advisorPkg.name,
-    version: advisorPkg.version,
-  },
-  hooks: {
-    "user-prompt-submit": advisorUserPromptSubmit,
-    "pre-model-call": advisorPreModelCall,
-    "post-model-call": advisorPostModelCall,
-  },
-  tools: [finalizeTool(advisorTool, "advisor")],
-};
-
 /**
  * Full set of first-party default plugins. Used by
  * {@link registerDefaultPlugins} to drive the registration loop; the array
@@ -375,9 +344,6 @@ function getAllDefaultPlugins(): readonly Plugin[] {
     defaultCompactionPlugin,
     defaultTitleGeneratePlugin,
     memoryV3ShadowPlugin,
-    // Registered last so its capture hooks observe the fully-processed turn
-    // (memory injections, history repair) that the executor actually sees.
-    defaultAdvisorPlugin,
   ];
 }
 
@@ -424,7 +390,6 @@ export function resetPluginRegistryAndRegisterDefaults(): void {
   resetExplorationDriftStateForTests();
   resetTaskProgressNudgeStateForTests();
   resetSurfaceCompletionNudgeStoreForTests();
-  resetAdvisorStateForTests();
   resetCaptionCacheForTests();
   registerDefaultPlugins();
 }

package/src/plugins/defaults/max-tokens-continue/hooks/post-model-call.ts

@@ -30,7 +30,7 @@
  *   reject.
  */
 
-import type { PluginHookFn, PostModelCallContext } from "@vellumai/plugin-api";
+import type { HookFunction, PostModelCallContext } from "@vellumai/plugin-api";
 
 import { isMaxTokensStopReason } from "../../../../agent/loop.js";
 import {
@@ -45,7 +45,7 @@ import {
 export const MAX_TOKENS_CONTINUE_NUDGE_TEXT =
   "<system_notice>Your previous response was cut off because it reached the maximum output length. Continue exactly where you stopped — do not repeat content you already sent and do not start over.</system_notice>";
 
-const postModelCall: PluginHookFn<PostModelCallContext> = async (ctx) => {
+const postModelCall: HookFunction<PostModelCallContext> = async (ctx) => {
   if (ctx.error) return;
   if (!isMaxTokensStopReason(ctx.stopReason)) return;
   if (ctx.callSite !== "mainAgent") return;

package/src/plugins/defaults/max-tokens-continue/hooks/stop.ts

@@ -9,11 +9,11 @@
  * budget, no matter how the turn ended.
  */
 
-import type { PluginHookFn, StopContext } from "@vellumai/plugin-api";
+import type { HookFunction, StopContext } from "@vellumai/plugin-api";
 
 import { clearMaxTokensContinueBudget } from "../continue-state-store.js";
 
-const stop: PluginHookFn<StopContext> = async (ctx) => {
+const stop: HookFunction<StopContext> = async (ctx) => {
   clearMaxTokensContinueBudget(ctx.conversationId);
 };
 

package/src/plugins/defaults/memory-retrieval/hooks/post-compact.ts

@@ -38,7 +38,7 @@
  * {@link PostCompactContext}.
  */
 
-import type { PluginHookFn, PostCompactContext } from "@vellumai/plugin-api";
+import type { HookFunction, PostCompactContext } from "@vellumai/plugin-api";
 
 import { getConfig } from "../../../../config/loader.js";
 import { findConversationOrSubagent } from "../../../../daemon/conversation-registry.js";
@@ -53,7 +53,7 @@ import {
 import { getLiveGraphMemory } from "../../../../memory/graph/conversation-graph-memory.js";
 import { stripTailInjectionsForReinjection } from "../tail-reinjection-strip.js";
 
-const postCompact: PluginHookFn<PostCompactContext> = async (ctx) => {
+const postCompact: HookFunction<PostCompactContext> = async (ctx) => {
   const {
     history,
     requestId,

package/src/plugins/defaults/memory-retrieval/hooks/user-prompt-submit.ts

@@ -28,7 +28,7 @@
  */
 
 import type {
-  PluginHookFn,
+  HookFunction,
   UserPromptSubmitContext,
 } from "@vellumai/plugin-api";
 
@@ -264,7 +264,7 @@ function persistInjectionBlocks(
  * slower turn. Cancellation still works via `ctx.signal`, which is threaded
  * into `prepareMemory`.
  */
-const userPromptSubmitMemoryRetrieval: PluginHookFn<
+const userPromptSubmitMemoryRetrieval: HookFunction<
   UserPromptSubmitContext
 > = async (ctx) => {
   // The conversation-scoped retrieval state — graph handle, abort signal, and

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

@@ -67,13 +67,17 @@ let pruneConfig: {
   maxResidentBytes: number;
   targetResidentBytes: number;
 } | null = null;
-/** Canned orchestrate result per turnIndex; `null` simulates a failed turn. */
-let turnResults = new Map<number, OrchestrateResult | null>();
+/** Canned orchestrate result per turnIndex; `null` simulates an ordinary miss. */
+let turnResults = new Map<number, OrchestrateResult | null | Error>();
 const observeTurnSpy = mock(
   async (
     _conversationId: string,
     turnIndex: number,
-  ): Promise<OrchestrateResult | null> => turnResults.get(turnIndex) ?? null,
+  ): Promise<OrchestrateResult | null> => {
+    const value = turnResults.get(turnIndex) ?? null;
+    if (value instanceof Error) throw value;
+    return value;
+  },
 );
 
 const logCalls: Array<{ data: unknown; msg: string }> = [];
@@ -199,6 +203,9 @@ const {
 } = await import("../ever-injected-store.js");
 const { V3_CARDS_INJECTION_HEADER } = await import("../render-injection.js");
 const { flushPruneValveForTests } = await import("../prune.js");
+const { drainConversationNotices, resetConversationNoticesForTests } =
+  await import("../../../../daemon/conversation-notices.js");
+const { MemoryV3RetrievalUnavailableError } = await import("../pool-select.js");
 
 // ─── helpers ────────────────────────────────────────────────────────────────
 
@@ -313,6 +320,7 @@ beforeEach(async () => {
   logCalls.length = 0;
   testDb = makeDb();
   resetMemoryV3InjectorStateForTests();
+  resetConversationNoticesForTests();
 });
 
 afterAll(async () => {
@@ -335,6 +343,28 @@ describe("memoryV3Injector — frozen net-new cards", () => {
     expect(getActiveSlugs("conv-1")).toEqual(new Set());
   });
 
+  test("live retrieval failure queues a degraded-memory notice", async () => {
+    liveEnabled = true;
+    turnResults.set(
+      0,
+      new MemoryV3RetrievalUnavailableError("selector unavailable"),
+    );
+
+    await expect(produceCardsWithoutCommit("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("turn 1 renders cards; turn 2 re-selecting the same pages renders ZERO new cards", async () => {
     liveEnabled = true;
     turnResults.set(0, result(["page-a", "page-b"]));

package/src/plugins/defaults/memory-v3-shadow/__tests__/pool-select.test.ts

@@ -26,6 +26,7 @@
  * The provider is stubbed so no network calls fire; mirrors selector.test.ts.
  */
 
+import { createRequire } from "node:module";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
@@ -35,6 +36,7 @@ import type {
   SendMessageOptions,
   ToolUseContent,
 } from "../../../../providers/types.js";
+import { ProviderError } from "../../../../util/errors.js";
 import type { MemoryRoutingTurn } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -43,6 +45,11 @@ import type { MemoryRoutingTurn } from "../types.js";
 // ---------------------------------------------------------------------------
 
 let providerStub: Provider | null = null;
+const registryReal = {
+  ...(createRequire(import.meta.url)(
+    "../../../../providers/registry.js",
+  ) as Record<string, unknown>),
+};
 
 interface ProviderCall {
   messages: Message[];
@@ -57,6 +64,12 @@ mock.module("../../../../providers/provider-send-message.js", () => ({
     response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
 }));
 
+mock.module("../../../../providers/registry.js", () => ({
+  ...registryReal,
+  getProviderRoutingSource: (providerName: string) =>
+    providerName === "managed" ? "managed-proxy" : "user-key",
+}));
+
 mock.module("../../../../util/logger.js", () => ({
   getLogger: () => ({
     warn: (...args: unknown[]) => warnCalls.push({ args }),
@@ -253,10 +266,9 @@ describe("selectPool — id mapping", () => {
 });
 
 // ---------------------------------------------------------------------------
-// selectPool — infrastructure failures THROW (no silent degradation). A
-// deliberate empty selection and an empty pool (covered above) still return
-// normally; only a genuine infra failure throws so the LIVE injector can
-// hard-fail the turn instead of shipping it with no memory.
+// selectPool — infrastructure failures THROW. A deliberate empty selection and
+// an empty pool (covered above) still return normally; only a genuine infra
+// failure throws so callers can log it distinctly from an empty selection.
 // ---------------------------------------------------------------------------
 
 describe("selectPool — infrastructure failures throw", () => {
@@ -371,6 +383,38 @@ describe("selectPool — infrastructure failures throw", () => {
     ]);
   });
 
+  test("managed provider 402 attaches a non-terminal credits notice", async () => {
+    providerStub = {
+      name: "managed",
+      sendMessage: async (messages, options) => {
+        providerCalls.push({ messages, options });
+        throw new ProviderError(
+          "Together AI API error (402): 402 status code (no body)",
+          "managed",
+          402,
+        );
+      },
+    };
+    let caught: unknown;
+    try {
+      await selectPool(makePool(), makeTurn("x"));
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
+    const notice = (
+      caught as InstanceType<typeof MemoryV3RetrievalUnavailableError>
+    ).conversationNotice;
+    expect(notice).toEqual({
+      source: "memory_v3",
+      code: "PROVIDER_BILLING",
+      userMessage:
+        "You've run out of credits. Add funds to continue using the assistant.",
+      errorCategory: "credits_exhausted",
+    });
+  });
+
   test("provider throw redacts sensitive message details in diagnostics", async () => {
     const providerSecret = ["sk-proj-", "a".repeat(40)].join("");
     const message = `provider rejected Authorization: Bearer ${providerSecret}`;