@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -1,7 +1,8 @@
-import { utimesSync, writeFileSync } from "node:fs";
+import { readFileSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { waitFor } from "../../../__tests__/helpers/wait-for.js";
 import {
   sampleConcepts as sharedSampleConcepts,
   sampleConfig,
@@ -50,11 +51,14 @@ mock.module("../../../persistence/embeddings/embedding-backend.js", () => ({
   },
 }));
 
+import type { AssistantEventEnvelope } from "../../../api/index.js";
 import { BACKUP_PROFILE_KEYS } from "../../../config/default-profile-names.js";
 import {
   getConfig,
+  invalidateConfigCache,
   loadConfig,
   loadRawConfig,
+  setNestedValue,
 } from "../../../config/loader.js";
 import { AssistantConfigSchema } from "../../../config/schema.js";
 import { LLMConfigBase } from "../../../config/schemas/llm.js";
@@ -82,7 +86,8 @@ import {
   createConnection,
   getConnection,
 } from "../../../providers/inference/connections.js";
-import { ROUTES } from "../conversation-query-routes.js";
+import { assistantEventHub } from "../../assistant-event-hub.js";
+import { commitConfigWrite, ROUTES } from "../conversation-query-routes.js";
 
 // Local subset: this test only exercises a single concept row.
 const sampleConcepts: MemoryV2ConceptRowRecord[] = sharedSampleConcepts.slice(
@@ -2047,3 +2052,371 @@ describe("config writes to a per-agent acp entry", () => {
     expect(loadConfig().acp.agents.claude?.model).toBe("sonnet");
   });
 });
+
+describe("persisted chat settings", () => {
+  const getRoute = ROUTES.find((r) => r.operationId === "config_get")!;
+  const patchRoute = ROUTES.find((r) => r.operationId === "config_patch")!;
+  const setRoute = ROUTES.find((r) => r.operationId === "config_set")!;
+
+  beforeEach(() => {
+    initializeProvidersCalls = 0;
+    clearEmbeddingBackendCacheCalls = 0;
+    rawConfigFixture = {
+      conversations: {
+        skipAutoRetitling: true,
+        autoArchive: { enabled: true, afterDays: 14, futureOption: "keep" },
+      },
+      notifications: { newMessageEnabled: false, futureOption: "keep" },
+      maxStepsPerSession: 75,
+    };
+    seedRawConfig();
+    invalidateConfigCache();
+  });
+
+  const writers = ["PATCH", "SET", "canonical"] as const;
+  async function writeSetting(
+    writer: (typeof writers)[number],
+    path: string,
+    value: unknown,
+  ): Promise<unknown> {
+    if (writer === "SET") {
+      return setRoute.handler({ body: { path, value } });
+    }
+    const raw = writer === "canonical" ? loadRawConfig() : {};
+    setNestedValue(raw, path, value);
+    return writer === "PATCH"
+      ? patchRoute.handler({ body: raw })
+      : commitConfigWrite(raw, "test");
+  }
+
+  for (const writer of writers) {
+    test.each([
+      { conversations: false },
+      { conversations: [] },
+      { conversations: null },
+      { conversations: { autoArchive: "legacy" } },
+      { conversations: { autoArchive: [] } },
+      { conversations: { autoArchive: null } },
+      { conversations: { autoArchive: { enabled: "true", afterDays: 2 } } },
+      { conversations: { autoArchive: { enabled: null, afterDays: null } } },
+      { notifications: "legacy" },
+      { notifications: [] },
+      { notifications: null },
+      { notifications: { newMessageEnabled: "false" } },
+      { notifications: { newMessageEnabled: null } },
+    ])(
+      `${writer} unrelated writes preserve untouched legacy values: %j`,
+      async (legacy) => {
+        rawConfigFixture = { ...legacy, maxStepsPerSession: 75 };
+        seedRawConfig();
+        invalidateConfigCache();
+
+        await writeSetting(writer, "maxStepsPerSession", 100);
+
+        expect(loadRawConfig()).toEqual({
+          ...rawConfigFixture,
+          maxStepsPerSession: 100,
+        });
+        expect(initializeProvidersCalls).toBe(1);
+        expect(clearEmbeddingBackendCacheCalls).toBe(1);
+      },
+    );
+
+    test(`${writer} can repair one leaf without changing other legacy values`, async () => {
+      rawConfigFixture = {
+        conversations: { autoArchive: { enabled: "true", afterDays: 2 } },
+        notifications: null,
+      };
+      seedRawConfig();
+      invalidateConfigCache();
+
+      await writeSetting(writer, "conversations.autoArchive.enabled", true);
+
+      expect(loadRawConfig()).toEqual({
+        conversations: { autoArchive: { enabled: true, afterDays: 2 } },
+        notifications: null,
+      });
+    });
+
+    test(`${writer} rejects an invalid leaf change beside an unchanged invalid sibling`, async () => {
+      rawConfigFixture = {
+        conversations: { autoArchive: { enabled: "true", afterDays: 2 } },
+      };
+      seedRawConfig();
+      invalidateConfigCache();
+      const configPath = join(process.env.VELLUM_WORKSPACE_DIR!, "config.json");
+      const originalBytes = readFileSync(configPath, "utf-8");
+
+      await expect(
+        writeSetting(writer, "conversations.autoArchive.afterDays", 3),
+      ).rejects.toMatchObject({ statusCode: 400 });
+
+      expect(readFileSync(configPath, "utf-8")).toBe(originalBytes);
+      expect(initializeProvidersCalls).toBe(0);
+    });
+
+    test.each([
+      ["conversations", []],
+      ["conversations.autoArchive", { enabled: "true" }],
+      ["conversations.autoArchive", { afterDays: 2 }],
+      ["notifications.newMessageEnabled", "true"],
+      ["notifications.newMessageEnabled", 1],
+    ])(
+      `${writer} rejects changed invalid settings at %s over legacy config`,
+      async (path, value) => {
+        rawConfigFixture = {
+          conversations: false,
+          notifications: { newMessageEnabled: "false" },
+          maxStepsPerSession: 75,
+        };
+        seedRawConfig();
+        invalidateConfigCache();
+        const configPath = join(
+          process.env.VELLUM_WORKSPACE_DIR!,
+          "config.json",
+        );
+        const originalBytes = readFileSync(configPath, "utf-8");
+
+        await expect(
+          writeSetting(writer, path as string, value),
+        ).rejects.toMatchObject({
+          statusCode: 400,
+        });
+
+        expect(readFileSync(configPath, "utf-8")).toBe(originalBytes);
+        expect(initializeProvidersCalls).toBe(0);
+        expect(clearEmbeddingBackendCacheCalls).toBe(0);
+      },
+    );
+  }
+
+  test("PATCH resets only the explicitly nulled legacy leaf", async () => {
+    rawConfigFixture = {
+      conversations: { autoArchive: { enabled: null, afterDays: null } },
+      notifications: { newMessageEnabled: null },
+    };
+    seedRawConfig();
+    invalidateConfigCache();
+
+    await patchRoute.handler({
+      body: { conversations: { autoArchive: { enabled: null } } },
+    });
+
+    expect(loadRawConfig()).toEqual({
+      conversations: { autoArchive: { afterDays: null } },
+      notifications: { newMessageEnabled: null },
+    });
+  });
+
+  test("sparse GET exposes effective defaults without materializing unrelated fields", async () => {
+    rawConfigFixture = {};
+    seedRawConfig();
+    invalidateConfigCache();
+    const result = await getRoute.handler({});
+    expect(result).toMatchObject({
+      conversations: { autoArchive: { enabled: false, afterDays: 7 } },
+      notifications: { newMessageEnabled: true },
+    });
+    expect(result).not.toHaveProperty("conversations.skipAutoRetitling");
+    expect(loadRawConfig()).not.toHaveProperty("conversations");
+    expect(loadRawConfig()).not.toHaveProperty("notifications");
+  });
+
+  test("partial PATCH persists, reloads, and publishes config invalidation", async () => {
+    const received: AssistantEventEnvelope[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+    try {
+      const result = await patchRoute.handler({
+        body: { conversations: { autoArchive: { afterDays: 30 } } },
+      });
+      expect(result).toMatchObject({
+        conversations: {
+          skipAutoRetitling: true,
+          autoArchive: { enabled: true, afterDays: 30, futureOption: "keep" },
+        },
+        notifications: { newMessageEnabled: false, futureOption: "keep" },
+        maxStepsPerSession: 75,
+      });
+      expect(loadRawConfig()).toEqual({
+        ...rawConfigFixture,
+        conversations: {
+          skipAutoRetitling: true,
+          autoArchive: { enabled: true, afterDays: 30, futureOption: "keep" },
+        },
+      });
+      invalidateConfigCache();
+      expect(loadConfig().conversations.autoArchive).toEqual({
+        enabled: true,
+        afterDays: 30,
+      });
+      expect(loadConfig().notifications.newMessageEnabled).toBe(false);
+      expect(await getRoute.handler({})).toEqual(result);
+      expect(initializeProvidersCalls).toBe(1);
+      expect(clearEmbeddingBackendCacheCalls).toBe(1);
+      await waitFor(() =>
+        received.some((event) => event.message.type === "sync_changed"),
+      );
+      expect(received.map((event) => event.message)).toContainEqual({
+        type: "sync_changed",
+        tags: ["assistant:self:config"],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("PATCH null leaves restore defaults and preserve sibling values", async () => {
+    const result = await patchRoute.handler({
+      body: {
+        conversations: { autoArchive: { enabled: null, afterDays: null } },
+        notifications: { newMessageEnabled: null },
+      },
+    });
+    expect(result).toMatchObject({
+      conversations: {
+        skipAutoRetitling: true,
+        autoArchive: { enabled: false, afterDays: 7, futureOption: "keep" },
+      },
+      notifications: { newMessageEnabled: true, futureOption: "keep" },
+    });
+    expect(loadRawConfig()).toMatchObject({
+      conversations: { autoArchive: { futureOption: "keep" } },
+      notifications: { futureOption: "keep" },
+    });
+    expect(loadRawConfig()).not.toHaveProperty(
+      "conversations.autoArchive.enabled",
+    );
+    expect(loadRawConfig()).not.toHaveProperty(
+      "notifications.newMessageEnabled",
+    );
+  });
+
+  test.each([
+    { conversations: { autoArchive: null }, notifications: null },
+    { conversations: null, notifications: null },
+  ])("PATCH null subtrees restore defaults: %j", async (body) => {
+    const result = await patchRoute.handler({ body });
+    expect(result).toMatchObject({
+      conversations: { autoArchive: { enabled: false, afterDays: 7 } },
+      notifications: { newMessageEnabled: true },
+    });
+    expect(loadRawConfig()).not.toHaveProperty("conversations.autoArchive");
+    expect(loadRawConfig()).not.toHaveProperty("notifications");
+  });
+
+  test.each([
+    { conversations: false },
+    { conversations: { autoArchive: [] } },
+    { conversations: { autoArchive: { enabled: "true" } } },
+    { conversations: { autoArchive: { afterDays: 5 } } },
+    { notifications: "off" },
+    { notifications: { newMessageEnabled: 0 } },
+  ])(
+    "invalid PATCH leaves saved config and runtime unchanged: %j",
+    async (body) => {
+      const original = loadRawConfig();
+      await expect(patchRoute.handler({ body })).rejects.toMatchObject({
+        statusCode: 400,
+      });
+      expect(loadRawConfig()).toEqual(original);
+      expect(initializeProvidersCalls).toBe(0);
+      expect(clearEmbeddingBackendCacheCalls).toBe(0);
+    },
+  );
+
+  test.each([false, "legacy", [], null])(
+    "PATCH null resets a malformed stored autoArchive subtree: %j",
+    async (autoArchive) => {
+      rawConfigFixture = {
+        conversations: { skipAutoRetitling: true, autoArchive },
+        notifications: { newMessageEnabled: false },
+        maxStepsPerSession: 75,
+      };
+      seedRawConfig();
+      invalidateConfigCache();
+
+      const result = await patchRoute.handler({
+        body: { conversations: { autoArchive: null } },
+      });
+
+      expect(result).toMatchObject({
+        conversations: {
+          skipAutoRetitling: true,
+          autoArchive: { enabled: false, afterDays: 7 },
+        },
+        notifications: { newMessageEnabled: false },
+      });
+      expect(loadRawConfig()).toEqual({
+        conversations: { skipAutoRetitling: true },
+        notifications: { newMessageEnabled: false },
+        maxStepsPerSession: 75,
+      });
+    },
+  );
+
+  test.each([false, "legacy", [], null])(
+    "PATCH null resets malformed stored settings sections: %j",
+    async (value) => {
+      rawConfigFixture = {
+        conversations: value,
+        notifications: value,
+        maxStepsPerSession: 75,
+      };
+      seedRawConfig();
+      invalidateConfigCache();
+
+      const result = await patchRoute.handler({
+        body: { conversations: null, notifications: null },
+      });
+
+      expect(result).toMatchObject({
+        conversations: { autoArchive: { enabled: false, afterDays: 7 } },
+        notifications: { newMessageEnabled: true },
+      });
+      expect(loadRawConfig()).toEqual({ maxStepsPerSession: 75 });
+    },
+  );
+
+  test("SET persists valid preferences through the same writer", async () => {
+    await setRoute.handler({
+      body: { path: "notifications.newMessageEnabled", value: true },
+    });
+    expect(loadConfig().notifications.newMessageEnabled).toBe(true);
+    expect(loadRawConfig()).toHaveProperty(
+      "notifications.futureOption",
+      "keep",
+    );
+  });
+
+  test.each([
+    ["conversations.autoArchive.afterDays", 2],
+    ["conversations.autoArchive.enabled", null],
+    ["conversations.autoArchive", []],
+    ["notifications.newMessageEnabled", "false"],
+    ["notifications", null],
+  ])("invalid SET %s is rejected before saving", async (path, value) => {
+    const original = loadRawConfig();
+    await expect(
+      setRoute.handler({ body: { path, value } }),
+    ).rejects.toMatchObject({ statusCode: 400 });
+    expect(loadRawConfig()).toEqual(original);
+    expect(initializeProvidersCalls).toBe(0);
+  });
+
+  test("canonical config writes reject invalid settings", async () => {
+    const original = loadRawConfig();
+    await expect(
+      commitConfigWrite(
+        { ...original, notifications: { newMessageEnabled: null } },
+        "test",
+      ),
+    ).rejects.toMatchObject({ statusCode: 400 });
+    expect(loadRawConfig()).toEqual(original);
+    expect(initializeProvidersCalls).toBe(0);
+  });
+});

package/src/runtime/routes/__tests__/inference-send-routes.test.ts

@@ -252,7 +252,7 @@ describe("inference_send profile usability", () => {
     const err = await rejection({ ...hermes, status: "disabled" });
     expect(err).toBeInstanceOf(BadRequestError);
     expect(err.message).toContain("disabled");
-    expect(err.message).toContain("deepseek-v4-flash");
+    expect(err.message).toContain("deepseek-v4p1-flash");
   });
 
   test("rejects a profile that lost its provider", async () => {

package/src/runtime/routes/__tests__/user-route-dispatcher.test.ts

@@ -106,6 +106,18 @@ describe("path traversal", () => {
     );
     expect(res.status).toBe(400);
   });
+
+  test("rejects backslashes in the route path", async () => {
+    // Some URL normalizers treat a backslash as a separator, so a
+    // backslash-carrying routePath is refused outright regardless of dots.
+    const dispatcher = makeDispatcher();
+    for (const routePath of ["..\\config", "foo\\bar", "x\\..\\config"]) {
+      const res = await dispatcher.dispatch(routePath, makeRequest("GET"));
+      expect(res.status).toBe(400);
+      const body = await readErrorBody(res);
+      expect(body.error.message).toContain("Path traversal");
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/runtime/routes/contact-routes.ts

@@ -393,8 +393,8 @@ export async function handleListContacts(queryParams: Record<string, string>) {
 export async function handleGetContact(contactId: string) {
   try {
     const result = await ipcCallPersistent("contacts_get_rich", { contactId });
-    // The gateway returns null (no `contact`) on a clean not-found.
-    if (!result || (result as { contact?: unknown }).contact === undefined) {
+    // The gateway returns null on a clean not-found.
+    if (result == null) {
       throw new NotFoundError(`Contact "${contactId}" not found`);
     }
     const { contact, assistantMetadata } =

package/src/runtime/routes/conversation-list-routes.ts

@@ -150,6 +150,13 @@ const listConversationsResponseSchema = z.object({
   nextOffset: z.number(),
   hasMore: z.boolean(),
   groups: z.array(groupSummarySchema).optional(),
+  /**
+   * The key the rows are ordered on: last activity, the later of a row's
+   * last message and the time it was marked done. Stated so a client that
+   * pages a list including done rows can tell this order from message
+   * recency, which an assistant that omits the field pages by.
+   */
+  orderedBy: z.literal("lastActivity"),
 });
 
 const conversationDetailResponseSchema = z.object({
@@ -376,6 +383,7 @@ function handleListConversations({
     ),
     nextOffset,
     hasMore: nextOffset < totalCount,
+    orderedBy: "lastActivity",
   };
 
   // Include groups array on first page only
@@ -632,7 +640,7 @@ export const ROUTES: RouteDefinition[] = [
         type: "string",
         required: false,
         description:
-          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with archiveStatus=all for a whole-history read; rows are recency-ordered (COALESCE(last_message_at, updated_at) descending) like every other list read, and pinned rows are never appended to it.',
+          'Filter by conversation type. Pass "background" to list background and scheduled conversations together (the back-compat umbrella), "scheduled" to list only scheduled conversations, or "all" for the union of the standard listing and that umbrella, so one paginated cursor spans every type. Combine "all" with archiveStatus=all for a whole-history read; rows are ordered by last activity (the later of the last message and the time the row was marked done, descending) like every other list read, and pinned rows are never appended to it.',
         schema: {
           type: "string",
           enum: ["background", "scheduled", "all"],
@@ -662,7 +670,7 @@ export const ROUTES: RouteDefinition[] = [
         type: "string",
         required: false,
         description:
-          'Filter to a single group, so each sidebar section can load independently of the paginated list. Pass "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A group-scoped request is recency-ordered like every list read (COALESCE(last_message_at, updated_at) descending) and never has pinned rows appended to it. Omit to span every group.',
+          'Filter to a single group, so each sidebar section can load independently of the paginated list. Pass "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A group-scoped request is ordered by last activity like every list read (the later of the last message and the time the row was marked done, descending) and never has pinned rows appended to it. Omit to span every group.',
       },
       {
         name: "needsAttention",

package/src/runtime/routes/conversation-query-routes.ts

@@ -30,6 +30,11 @@ import {
   LLMRequestLogEntrySchema,
 } from "../../api/responses/llm-request-log-entry.js";
 import { scrubNulledAcpAgentLeaves } from "../../config/acp-agent-write.js";
+import {
+  ChatSettingsPatchSchema,
+  scrubNulledChatSettings,
+  validateChatSettingsWrite,
+} from "../../config/chat-settings.js";
 import {
   catalogEntryFor,
   type InputModalities,
@@ -54,6 +59,7 @@ import {
 } from "../../config/profile-materialization.js";
 import { AssistantConfigSchema } from "../../config/schema.js";
 import { getSchemaAtPath } from "../../config/schema-utils.js";
+import { AutoArchiveConfigSchema } from "../../config/schemas/conversations.js";
 import {
   collectFallbackProfileIssues,
   DefaultProviderSchema,
@@ -64,6 +70,7 @@ import {
   unknownLlmProviderIssue,
 } from "../../config/schemas/llm.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
+import { NotificationsConfigSchema } from "../../config/schemas/notifications.js";
 import { ServiceModeSchema } from "../../config/schemas/services.js";
 import { isSidebarDoneEnabled } from "../../config/sidebar-done-gate.js";
 import {
@@ -746,14 +753,19 @@ const MemoryWireConfigSchema = z
  * Response schema for `GET /v1/config`.
  *
  * Describes the wire shape of the raw `settings.json` response after
- * context-default filling and vision-flag enrichment. All top-level fields
- * are optional because the on-disk config may be sparse. Additional
- * top-level config sections beyond what's typed here are preserved via
- * passthrough — this schema types the fields that web/macOS clients consume
+ * context-default filling and vision-flag enrichment. Chat settings include
+ * effective defaults. Fields remain optional for older assistants and sparse
+ * on-disk config. Additional top-level sections are preserved via
+ * passthrough. This schema types the fields that web/macOS clients consume
  * without restricting the full config surface.
  */
 const ConfigGetResponseSchema = z
   .object({
+    conversations: z
+      .object({ autoArchive: AutoArchiveConfigSchema.passthrough() })
+      .passthrough()
+      .optional(),
+    notifications: NotificationsConfigSchema.passthrough().optional(),
     llm: z
       .object({
         default: LLMConfigFragment.extend({
@@ -859,6 +871,7 @@ const CallSiteOverrideDraftSchema = nullablePartial(
  */
 const ConfigPatchRequestSchema = z
   .object({
+    ...ChatSettingsPatchSchema.shape,
     llm: z
       .object({
         default: nullablePartial(
@@ -932,6 +945,7 @@ function handleGetConfig() {
     sanitizeMcpTransportHeadersForSettingsRead(config);
     overlayEffectiveProfilesForWire(config);
     enrichProfilesForWire(config);
+    overlayChatSettingsForWire(config);
     return config;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -939,6 +953,26 @@ function handleGetConfig() {
   }
 }
 
+function overlayChatSettingsForWire(config: unknown): void {
+  const root = readPlainObject(config);
+  if (!root) {
+    return;
+  }
+  const effective = getConfig();
+  const conversations = readPlainObject(root.conversations);
+  root.conversations = {
+    ...conversations,
+    autoArchive: {
+      ...readPlainObject(conversations?.autoArchive),
+      ...effective.conversations.autoArchive,
+    },
+  };
+  root.notifications = {
+    ...readPlainObject(root.notifications),
+    newMessageEnabled: effective.notifications.newMessageEnabled,
+  };
+}
+
 /**
  * Replace `llm.profiles` in an outgoing config response with the effective
  * profile view (code-catalog default bodies + workspace overlays). Default
@@ -1513,6 +1547,10 @@ export async function commitConfigWrite(
   // false diffs. Runs before the watcher-suppress/save sequence so a
   // rejection needs no suppress-flag or cache cleanup.
   const preWrite = loadRawConfig();
+  const chatSettings = validateChatSettingsWrite(preWrite, raw);
+  if (!chatSettings.success) {
+    throw new BadRequestError(chatSettings.error.message);
+  }
   completeChangedCustomProfiles(preWrite, raw);
   assertInvariantProfilesPreserved(preWrite, raw);
   assertRoutableIdentityEntries(preWrite, raw);
@@ -1626,6 +1664,10 @@ async function handlePatchConfig({ body }: RouteHandlerArgs) {
   ) {
     throw new BadRequestError("Body must be a non-empty JSON object");
   }
+  const chatSettings = ChatSettingsPatchSchema.safeParse(body);
+  if (!chatSettings.success) {
+    throw new BadRequestError(chatSettings.error.message);
+  }
   stripWireOnlyProfileKeys(body);
   normalizeManagedProfileWrites(body);
   rejectManagedProfileDeletion(body as Record<string, unknown>);
@@ -1641,16 +1683,12 @@ async function handlePatchConfig({ body }: RouteHandlerArgs) {
   deepMergeOverwrite(raw, patch);
   scrubRemovedServiceModes(raw);
   scrubNulledAcpAgentLeaves(raw);
+  scrubNulledChatSettings(raw, patch);
   seedSttProviderForSparseBlock(raw);
 
   await commitConfigWrite(raw, "patch");
 
-  const merged = applyContextDefaultsToRawConfig(loadRawConfig());
-  overlayWorkspaceMcpForConfigRead(merged);
-  sanitizeMcpTransportHeadersForSettingsRead(merged);
-  overlayEffectiveProfilesForWire(merged);
-  enrichProfilesForWire(merged);
-  return merged;
+  return handleGetConfig();
 }
 
 /**

package/src/runtime/routes/conversation-routes.ts

@@ -101,6 +101,7 @@ import {
   writeOnboardingSidecar,
   writeRelationshipState,
 } from "../../home/relationship-state-writer.js";
+import { localeFromAcceptLanguage } from "../../i18n/index.js";
 import { ipcCall } from "../../ipc/gateway-client.js";
 import { buildSlackMessageDeepLinks } from "../../messaging/providers/slack/deep-link.js";
 import {
@@ -915,7 +916,9 @@ function parseRequestedModeSessionIds(raw: unknown): string[] {
 
 export async function handleListMessages({
   queryParams,
+  headers,
 }: RouteHandlerArgs): Promise<Record<string, unknown>> {
+  const locale = localeFromAcceptLanguage(headers?.["accept-language"]);
   const conversationId = queryParams?.conversationId;
   const conversationKey = queryParams?.conversationKey;
 
@@ -1338,6 +1341,7 @@ export async function handleListMessages({
         attachmentBlocks,
         m.id ?? undefined,
         m.rowMetadata,
+        m.role === "assistant" ? locale : undefined,
       );
 
       const toolCalls = enrichToolCallsWithQuestion(
@@ -1735,6 +1739,7 @@ export async function handleSendMessage(
   const principalType = headers?.["x-vellum-principal-type"];
   const originClientId = headers?.["x-vellum-client-id"]?.trim() || undefined;
   const clientMetadata = readClientMetadataHeaders(headers);
+  const locale = localeFromAcceptLanguage(headers?.["accept-language"]);
 
   const { conversationKey, content, attachmentIds } = body;
   const inboundConversationId =
@@ -2475,6 +2480,7 @@ export async function handleSendMessage(
         clientMetadata,
       ),
       isInteractive,
+      locale,
       sourceActorPrincipalId,
       transport,
       clientMessageId,
@@ -3159,6 +3165,7 @@ export async function handleSendMessage(
           onEvent: broadcastMessage,
           isInteractive,
           isUserMessage: true,
+          locale,
           turnTrustContext,
           ...(body.hidden === true ? { isHiddenPrompt: true } : {}),
         })