@vellumai/assistant 0.10.6-staging.1 → 0.10.6

package/src/__tests__/config-loader-backfill.test.ts

@@ -596,9 +596,7 @@ describe("loadConfig startup behavior", () => {
     expect(config.llm.profiles.balanced?.model).toBe(
       "accounts/fireworks/models/glm-5p2",
     );
-    expect(config.llm.profiles.balanced?.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    expect(config.llm.profiles.balanced?.provider_connection).toBe("vellum");
 
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
     expect(raw.llm.default).toEqual({
@@ -639,9 +637,7 @@ describe("loadConfig startup behavior", () => {
     expect(config.llm.profiles.balanced?.model).toBe(
       "accounts/fireworks/models/glm-5p2",
     );
-    expect(config.llm.profiles.balanced?.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    expect(config.llm.profiles.balanced?.provider_connection).toBe("vellum");
     // No user profiles created on platform.
     expect(config.llm.profiles["custom-balanced"]).toBeUndefined();
   });
@@ -684,9 +680,7 @@ describe("loadConfig startup behavior", () => {
     );
     // Managed balanced profile is seeded for fireworks-managed (GLM 5.2).
     expect(raw.llm.profiles.balanced.provider).toBe("fireworks");
-    expect(raw.llm.profiles.balanced.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    expect(raw.llm.profiles.balanced.provider_connection).toBe("vellum");
   });
 
   test("on-platform re-hatch resets active profile to balanced", () => {
@@ -720,9 +714,7 @@ describe("loadConfig startup behavior", () => {
     // On-platform: no user profiles created, active resets to managed balanced.
     expect(raw.llm.activeProfile).toBe("balanced");
     expect(raw.llm.profiles.balanced.provider).toBe("fireworks");
-    expect(raw.llm.profiles.balanced.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    expect(raw.llm.profiles.balanced.provider_connection).toBe("vellum");
     // The old custom-balanced is preserved on disk but no longer active.
     expect(raw.llm.profiles["custom-balanced"].provider).toBe("openai");
   });
@@ -848,9 +840,7 @@ describe("loadConfig startup behavior", () => {
     // Managed profiles are also seeded. Balanced now serves GLM 5.2 on
     // Fireworks (the model Quality used to carry).
     expect(raw.llm.profiles.balanced.provider).toBe("fireworks");
-    expect(raw.llm.profiles.balanced.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    expect(raw.llm.profiles.balanced.provider_connection).toBe("vellum");
     expect(raw.llm.profiles.balanced.model).toBe(
       "accounts/fireworks/models/glm-5p2",
     );
@@ -890,9 +880,7 @@ describe("loadConfig startup behavior", () => {
     expect(raw.llm.profiles.balanced.model).toBe(
       "accounts/fireworks/models/glm-5p2",
     );
-    expect(raw.llm.profiles.balanced.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    expect(raw.llm.profiles.balanced.provider_connection).toBe("vellum");
     expect(raw.llm.activeProfile).toBe("balanced");
   });
 
@@ -961,9 +949,7 @@ describe("loadConfig startup behavior", () => {
     // The template carries no topP, and the previous entry had none, so the
     // reconciled profile has no topP override.
     expect("topP" in raw.llm.profiles.balanced).toBe(false);
-    expect(raw.llm.profiles.balanced.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    expect(raw.llm.profiles.balanced.provider_connection).toBe("vellum");
     expect(raw.llm.activeProfile).toBe("balanced");
   });
 
@@ -1234,7 +1220,7 @@ describe("loadConfig startup behavior", () => {
     expect(afterRestart.llm.activeProfile).toBe("balanced");
     expect(afterRestart.llm.profiles.balanced.provider).toBe("fireworks");
     expect(afterRestart.llm.profiles.balanced.provider_connection).toBe(
-      "fireworks-managed",
+      "vellum",
     );
     expect(afterRestart.llm.profiles.balanced.model).toBe(
       "accounts/fireworks/models/glm-5p2",
@@ -1574,19 +1560,13 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
 
     expect(raw.llm.activeProfile).toBe("balanced");
-    // Balanced lives on `fireworks-managed`; `quality-optimized` (Fable on
-    // `anthropic-managed`) is on a different connection, so selecting balanced at
-    // hatch disables it. The default advisor falls to the only active managed
-    // profile, `balanced`.
-    expect(raw.llm.advisorProfile).toBe("balanced");
-    expect(raw.llm.profiles.balanced.provider_connection).toBe(
-      "fireworks-managed",
-    );
+    // All managed profiles now share the single `vellum` connection, so
+    // selecting `balanced` at hatch activates that connection for every managed
+    // profile — none are disabled. The default advisor falls to the strongest
+    // active managed profile, `quality-optimized`.
+    expect(raw.llm.advisorProfile).toBe("quality-optimized");
+    expect(raw.llm.profiles.balanced.provider_connection).toBe("vellum");
     expect("status" in raw.llm.profiles.balanced).toBe(false);
-    // Connections exist (status is no longer a connection-level concept).
-    expect(getConnection(db, "anthropic-managed")).not.toBeNull();
-    expect(getConnection(db, "openai-managed")).not.toBeNull();
-    expect(getConnection(db, "gemini-managed")).not.toBeNull();
   });
 
   test("off-platform managed-inference hatch respects explicit non-managed active connection", () => {
@@ -1883,11 +1863,11 @@ describe("OS Beta managed profile template", () => {
     const entry = materializeProfile(
       OS_BETA_PROFILE_TEMPLATE,
       "together",
-      "together-managed",
+      "vellum",
     );
 
     expect(entry.model).toBe("MiniMaxAI/MiniMax-M3");
-    expect(entry.provider_connection).toBe("together-managed");
+    expect(entry.provider_connection).toBe("vellum");
     expect(entry.provider).toBe("together");
     expect(entry.label).toBe("OS Beta");
     expect(entry.source).toBe("managed");

package/src/__tests__/image-source-path-reinject.test.ts

@@ -1,14 +1,21 @@
 import { describe, expect, test } from "bun:test";
 
-import { reinjectImageSourcePaths } from "../daemon/conversation-lifecycle.js";
+import { enrichMessageWithSourcePaths } from "../agent/attachments.js";
+import { createUserMessage } from "../agent/message-types.js";
+import { reinjectAttachmentPathAnnotations } from "../daemon/conversation-lifecycle.js";
+import {
+  extractAttachmentStoredPaths,
+  extractImageSourcePaths,
+} from "../persistence/conversation-crud.js";
 import type { ContentBlock } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
-// reinjectImageSourcePaths — re-inject [Attached image source: /path]
-// annotations when loading conversation history from DB
+// reinjectAttachmentPathAnnotations — re-inject attachment path annotations
+// (image source paths + resolved stored paths) when loading conversation
+// history from DB
 // ---------------------------------------------------------------------------
 
-describe("reinjectImageSourcePaths", () => {
+describe("reinjectAttachmentPathAnnotations", () => {
   const baseContent: ContentBlock[] = [
     { type: "text", text: "what is this?" },
     {
@@ -21,7 +28,11 @@ describe("reinjectImageSourcePaths", () => {
     const metadata = JSON.stringify({
       imageSourcePaths: { "photo.jpg": "/Users/me/Desktop/photo.jpg" },
     });
-    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
 
     expect(result).toHaveLength(3);
     const annotation = result[2] as { type: "text"; text: string };
@@ -35,7 +46,11 @@ describe("reinjectImageSourcePaths", () => {
     const metadata = JSON.stringify({
       imageSourcePaths: { "photo.jpg": "/Users/me/Desktop/photo.jpg" },
     });
-    const result = reinjectImageSourcePaths(baseContent, "assistant", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "assistant",
+      metadata,
+    );
 
     // Should return the original content unchanged
     expect(result).toBe(baseContent);
@@ -43,7 +58,7 @@ describe("reinjectImageSourcePaths", () => {
   });
 
   test("returns content unchanged when metadata is null", () => {
-    const result = reinjectImageSourcePaths(baseContent, "user", null);
+    const result = reinjectAttachmentPathAnnotations(baseContent, "user", null);
     expect(result).toBe(baseContent);
     expect(result).toHaveLength(2);
   });
@@ -52,7 +67,11 @@ describe("reinjectImageSourcePaths", () => {
     const metadata = JSON.stringify({
       userMessageChannel: "desktop",
     });
-    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
     expect(result).toBe(baseContent);
     expect(result).toHaveLength(2);
   });
@@ -61,7 +80,11 @@ describe("reinjectImageSourcePaths", () => {
     const metadata = JSON.stringify({
       imageSourcePaths: {},
     });
-    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
     expect(result).toBe(baseContent);
     expect(result).toHaveLength(2);
   });
@@ -73,7 +96,11 @@ describe("reinjectImageSourcePaths", () => {
         "b.png": "/path/to/b.png",
       },
     });
-    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
 
     expect(result).toHaveLength(3);
     const annotation = result[2] as { type: "text"; text: string };
@@ -84,7 +111,7 @@ describe("reinjectImageSourcePaths", () => {
   });
 
   test("gracefully handles malformed metadata JSON", () => {
-    const result = reinjectImageSourcePaths(
+    const result = reinjectAttachmentPathAnnotations(
       baseContent,
       "user",
       "not-valid-json{{{",
@@ -102,7 +129,11 @@ describe("reinjectImageSourcePaths", () => {
         "also_bad.jpg": null,
       },
     });
-    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
 
     expect(result).toHaveLength(3);
     const annotation = result[2] as { type: "text"; text: string };
@@ -118,7 +149,11 @@ describe("reinjectImageSourcePaths", () => {
         "also_bad.jpg": null,
       },
     });
-    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
     expect(result).toBe(baseContent);
     expect(result).toHaveLength(2);
   });
@@ -127,10 +162,116 @@ describe("reinjectImageSourcePaths", () => {
     const metadata = JSON.stringify({
       imageSourcePaths: { "photo.jpg": "/path/photo.jpg" },
     });
-    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
 
     // First two blocks should be identical to the originals
     expect(result[0]).toEqual(baseContent[0]);
     expect(result[1]).toEqual(baseContent[1]);
   });
+
+  test("adds stored path annotations from attachmentStoredPaths", () => {
+    const metadata = JSON.stringify({
+      attachmentStoredPaths: {
+        "0:report.pdf": "/conv/attachments/report-2.pdf",
+      },
+    });
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
+
+    expect(result).toHaveLength(3);
+    const annotation = result[2] as { type: "text"; text: string };
+    expect(annotation.text).toBe(
+      '[Attachment "report.pdf" is stored at: /conv/attachments/report-2.pdf]',
+    );
+  });
+
+  test("recovers filenames containing colons from stored path keys", () => {
+    const metadata = JSON.stringify({
+      attachmentStoredPaths: {
+        "0:notes: draft.txt": "/conv/attachments/notes: draft.txt",
+      },
+    });
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
+
+    const annotation = result[2] as { type: "text"; text: string };
+    expect(annotation.text).toBe(
+      '[Attachment "notes: draft.txt" is stored at: /conv/attachments/notes: draft.txt]',
+    );
+  });
+
+  test("emits image source lines before stored path lines in one block", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: { "1:photo.jpg": "/Users/me/Desktop/photo.jpg" },
+      attachmentStoredPaths: {
+        "0:data.csv": "/conv/attachments/data-2.csv",
+        "1:photo.jpg": "/conv/attachments/photo.jpg",
+      },
+    });
+    const result = reinjectAttachmentPathAnnotations(
+      baseContent,
+      "user",
+      metadata,
+    );
+
+    expect(result).toHaveLength(3);
+    const annotation = result[2] as { type: "text"; text: string };
+    expect(annotation.text).toBe(
+      "[Attached image source: /Users/me/Desktop/photo.jpg]\n" +
+        '[Attachment "data.csv" is stored at: /conv/attachments/data-2.csv]\n' +
+        '[Attachment "photo.jpg" is stored at: /conv/attachments/photo.jpg]',
+    );
+  });
+
+  test("rebuilds the exact annotation block enrichMessageWithSourcePaths appends", () => {
+    // Prefix-cache parity tripwire: the block appended at persist time (from
+    // live attachment inputs) and the block rebuilt on history reload (from
+    // persisted metadata) must be byte-identical.
+    const attachments = [
+      {
+        filename: "data.csv",
+        mimeType: "text/csv",
+        data: "csvdata",
+        storedPath: "/conv/attachments/data-2.csv",
+      },
+      {
+        filename: "photo.jpg",
+        mimeType: "image/jpeg",
+        data: "img",
+        filePath: "/Users/me/Desktop/photo.jpg",
+        storedPath: "/conv/attachments/photo.jpg",
+      },
+    ];
+    const enriched = enrichMessageWithSourcePaths(
+      createUserMessage("compare", attachments),
+      attachments,
+    );
+    const liveBlock = enriched.content.at(-1) as {
+      type: "text";
+      text: string;
+    };
+
+    const metadata = JSON.stringify({
+      imageSourcePaths: extractImageSourcePaths(attachments),
+      attachmentStoredPaths: extractAttachmentStoredPaths(attachments),
+    });
+    const rebuilt = reinjectAttachmentPathAnnotations(
+      [{ type: "text", text: "compare" }],
+      "user",
+      metadata,
+    );
+    const rebuiltBlock = rebuilt.at(-1) as { type: "text"; text: string };
+
+    expect(rebuiltBlock.text).toBe(liveBlock.text);
+  });
 });

package/src/__tests__/managed-profile-guard.test.ts

@@ -120,6 +120,8 @@ mock.module("../persistence/embeddings/embedding-backend.js", () => ({
 mock.module("../providers/inference/connections.js", () => ({
   listConnections: () => [],
   createConnection: () => ({ ok: false, error: { code: "already_exists" } }),
+  getConnection: () => null,
+  VELLUM_MANAGED_CONNECTION_NAME: "vellum",
   PROVIDERS_REQUIRING_BASE_URL_AND_MODELS: new Set(["openai-compatible"]),
 }));