@vellumai/assistant 0.8.12 → 0.9.0-staging.2

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

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  DEFAULT_IMAGE_MODEL,
+  describeImageModels,
+  IMAGE_MODELS,
+  resolveImageModel,
+} from "../image-models.js";
+import { providerForModel } from "../image-service.js";
+
+describe("image model registry", () => {
+  test("aliases resolve to concrete model IDs", () => {
+    expect(resolveImageModel("fast")?.id).toBe(
+      "gemini-3.1-flash-image-preview",
+    );
+    expect(resolveImageModel("quality")?.id).toBe("gemini-3-pro-image-preview");
+    expect(resolveImageModel("openai")?.id).toBe("gpt-image-2");
+  });
+
+  test("concrete IDs resolve to themselves", () => {
+    for (const entry of IMAGE_MODELS) {
+      expect(resolveImageModel(entry.id)?.id).toBe(entry.id);
+    }
+  });
+
+  test("unknown values return undefined", () => {
+    expect(resolveImageModel("gpt-image-3")).toBeUndefined();
+    expect(resolveImageModel("")).toBeUndefined();
+  });
+
+  test("aliases are unique and never collide with model IDs", () => {
+    const aliases = IMAGE_MODELS.map((m) => m.alias);
+    expect(new Set(aliases).size).toBe(aliases.length);
+    const ids = new Set(IMAGE_MODELS.map((m) => m.id));
+    for (const alias of aliases) {
+      expect(ids.has(alias)).toBe(false);
+    }
+  });
+
+  test("default model is the first registry entry", () => {
+    expect(DEFAULT_IMAGE_MODEL).toBe(IMAGE_MODELS[0].id);
+  });
+
+  test("every registry entry routes to its own provider via prefix dispatch", () => {
+    for (const entry of IMAGE_MODELS) {
+      expect(providerForModel(entry.id, "gemini")).toBe(entry.provider);
+    }
+  });
+
+  test("describeImageModels lists every alias and ID", () => {
+    const text = describeImageModels();
+    for (const entry of IMAGE_MODELS) {
+      expect(text).toContain(entry.alias);
+      expect(text).toContain(entry.id);
+    }
+  });
+});

package/src/media/image-models.ts

@@ -0,0 +1,66 @@
+/**
+ * Single source of truth for the image generation model catalog.
+ *
+ * Concrete model IDs change as providers ship new versions. Everything that
+ * needs a model name (config schema default, skill executor, CLI help text)
+ * imports from here so a version bump is a one-line change. User-facing
+ * surfaces (SKILL.md, tool descriptions) reference the stable tier aliases
+ * instead of concrete IDs.
+ *
+ * This module is intentionally dependency-free so the config schema layer
+ * can import it without cycles.
+ */
+
+export type ImageModelProvider = "gemini" | "openai";
+
+export interface ImageModelEntry {
+  /** Concrete provider model ID sent on the API request. */
+  id: string;
+  provider: ImageModelProvider;
+  /** Stable tier alias referenced by SKILL.md and tool callers. */
+  alias: string;
+  /** Human-readable label for help text and error messages. */
+  label: string;
+}
+
+export const IMAGE_MODELS: readonly ImageModelEntry[] = [
+  {
+    id: "gemini-3.1-flash-image-preview",
+    provider: "gemini",
+    alias: "fast",
+    label: "Nano Banana 2",
+  },
+  {
+    id: "gemini-3-pro-image-preview",
+    provider: "gemini",
+    alias: "quality",
+    label: "Nano Banana Pro",
+  },
+  {
+    id: "gpt-image-2",
+    provider: "openai",
+    alias: "openai",
+    label: "GPT Image 2",
+  },
+] as const;
+
+export const DEFAULT_IMAGE_MODEL = IMAGE_MODELS[0].id;
+
+/**
+ * Resolve a model input (tier alias or concrete ID) to a registry entry.
+ * Returns undefined for unknown values so callers can produce an error that
+ * lists the currently available models.
+ */
+export function resolveImageModel(model: string): ImageModelEntry | undefined {
+  return IMAGE_MODELS.find((m) => m.alias === model || m.id === model);
+}
+
+/**
+ * One line per model: "alias -> id (label)". Used in CLI help text and in
+ * unknown-model error messages so the available set is always current.
+ */
+export function describeImageModels(): string {
+  return IMAGE_MODELS.map((m) => `  ${m.alias} -> ${m.id} (${m.label})`).join(
+    "\n",
+  );
+}

package/src/memory/__tests__/auto-analysis-enqueue.test.ts

@@ -13,6 +13,7 @@ mock.module("../../util/logger.js", () => ({
 
 let flagEnabled = true;
 let isAuto = false;
+let isRetrospective = false;
 let configValue: { analysis?: { idleTimeoutMs?: number } } = {
   analysis: { idleTimeoutMs: 600_000 },
 };
@@ -46,6 +47,11 @@ mock.module("../auto-analysis-guard.js", () => ({
   isAutoAnalysisConversation: (_conversationId: string) => isAuto,
 }));
 
+mock.module("../memory-retrospective-enqueue.js", () => ({
+  isMemoryRetrospectiveConversation: (_conversationId: string) =>
+    isRetrospective,
+}));
+
 mock.module("../jobs-store.js", () => ({
   enqueueMemoryJob: (
     type: string,
@@ -90,6 +96,7 @@ describe("enqueueAutoAnalysisIfEnabled", () => {
   beforeEach(() => {
     flagEnabled = true;
     isAuto = false;
+    isRetrospective = false;
     getConfigThrows = false;
     configValue = { analysis: { idleTimeoutMs: 600_000 } };
     enqueueCalls.length = 0;
@@ -191,6 +198,27 @@ describe("enqueueAutoAnalysisIfEnabled", () => {
     expect(debouncedCalls).toHaveLength(0);
   });
 
+  test("flag on, source is a memory-retrospective conversation — no job is enqueued", () => {
+    // Fork-kind retrospective conversations carry a full copy of the source
+    // conversation's history; auto-analyzing one would re-process the entire
+    // source conversation and double-write memory.
+    isRetrospective = true;
+
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "batch" });
+    enqueueAutoAnalysisIfEnabled({ conversationId: "c1", trigger: "idle" });
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "lifecycle",
+    });
+    enqueueAutoAnalysisIfEnabled({
+      conversationId: "c1",
+      trigger: "compaction",
+    });
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
+
   test("getConfig throws — skips silently without enqueueing", () => {
     getConfigThrows = true;
 
@@ -262,6 +290,7 @@ describe("enqueueAutoAnalysisOnCompaction", () => {
   beforeEach(() => {
     flagEnabled = true;
     isAuto = false;
+    isRetrospective = false;
     getConfigThrows = false;
     configValue = { analysis: { idleTimeoutMs: 600_000 } };
     enqueueCalls.length = 0;
@@ -329,4 +358,13 @@ describe("enqueueAutoAnalysisOnCompaction", () => {
     expect(enqueueCalls).toHaveLength(0);
     expect(debouncedCalls).toHaveLength(0);
   });
+
+  test("guardian trust but source is a memory-retrospective conversation — helper skips", () => {
+    isRetrospective = true;
+
+    enqueueAutoAnalysisOnCompaction("c1", "guardian");
+
+    expect(enqueueCalls).toHaveLength(0);
+    expect(debouncedCalls).toHaveLength(0);
+  });
 });

package/src/memory/__tests__/find-most-recent-retrospective-for.test.ts

@@ -66,7 +66,10 @@ describe("findMostRecentRetrospectiveFor", () => {
     const conv = createConversation("conv");
     const retro = createRetro(conv.id, 1_000);
 
-    expect(findMostRecentRetrospectiveFor(conv.id)).toEqual({ id: retro.id });
+    expect(findMostRecentRetrospectiveFor(conv.id)).toEqual({
+      id: retro.id,
+      forkParentConversationId: conv.id,
+    });
   });
 
   test("returns the most recently created retrospective when multiple exist at the same level", () => {
@@ -75,7 +78,10 @@ describe("findMostRecentRetrospectiveFor", () => {
     const newer = createRetro(conv.id, 2_000);
     createRetro(conv.id, 500);
 
-    expect(findMostRecentRetrospectiveFor(conv.id)).toEqual({ id: newer.id });
+    expect(findMostRecentRetrospectiveFor(conv.id)).toEqual({
+      id: newer.id,
+      forkParentConversationId: conv.id,
+    });
   });
 
   test("walks up the fork chain when the current conversation has no retros", () => {
@@ -87,6 +93,8 @@ describe("findMostRecentRetrospectiveFor", () => {
 
     expect(findMostRecentRetrospectiveFor(fork.id)).toEqual({
       id: parentRetro.id,
+      // Owned by the PARENT — callers must not GC it on the fork's behalf.
+      forkParentConversationId: parent.id,
     });
   });
 
@@ -100,6 +108,7 @@ describe("findMostRecentRetrospectiveFor", () => {
 
     expect(findMostRecentRetrospectiveFor(fork.id)).toEqual({
       id: forkRetro.id,
+      forkParentConversationId: fork.id,
     });
   });
 
@@ -115,6 +124,7 @@ describe("findMostRecentRetrospectiveFor", () => {
 
     expect(findMostRecentRetrospectiveFor(fork.id)).toEqual({
       id: grandparentRetro.id,
+      forkParentConversationId: grandparent.id,
     });
   });