@vellumai/assistant 0.12.5-dev.202609281715.b73f696 → 0.12.5-dev.202609281822.fb70dee

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609281715.b73f696",
+  "version": "0.12.5-dev.202609281822.fb70dee",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/config-get-vision-flag.test.ts

@@ -40,7 +40,7 @@ describe("GET /v1/config profile vision enrichment", () => {
     seedProfiles({
       "test-no-vision": {
         provider: "fireworks",
-        model: "accounts/fireworks/models/glm-5p2",
+        model: "accounts/fireworks/models/glm-5p3",
       },
     });
 

package/src/__tests__/config-loader-validation-reset-notice.test.ts

@@ -171,7 +171,7 @@ describe("config-validation-reset notice sentinel", () => {
             profiles: {
               "glm-default": {
                 provider: "vellum",
-                model: "accounts/fireworks/models/glm-5p2",
+                model: "accounts/fireworks/models/glm-5p3",
               },
             },
             activeProfile: "glm-default",
@@ -193,7 +193,7 @@ describe("config-validation-reset notice sentinel", () => {
     expect(config.llm.activeProfile).toBe("glm-default");
     expect(config.llm.callSites.mainAgent?.profile).toBe("glm-default");
     expect(config.llm.profiles["glm-default"]?.model).toBe(
-      "accounts/fireworks/models/glm-5p2",
+      "accounts/fireworks/models/glm-5p3",
     );
   });
 

package/src/__tests__/conversation-pairing.test.ts

@@ -116,6 +116,7 @@ mock.module("../config/assistant-initiated-threads-gate.js", () => ({
   isAssistantInitiatedThreadsEnabled: () => assistantInitiatedThreadsEnabled,
 }));
 
+import { resolveAssistantInitiatedThread } from "../notifications/assistant-initiated-thread.js";
 import { pairDeliveryWithConversation } from "../notifications/conversation-pairing.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type {
@@ -1478,6 +1479,117 @@ describe("pairDeliveryWithConversation", () => {
         ...overrides,
       });
 
+    test("a prepared resolution is reused even if the source changes before pairing", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      const signal = share({
+        conversationMetadata: { groupId: "group-123" },
+      });
+      const original = structuredClone(signal);
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+      getConversationMock.mockClear();
+      mockExistingConversations[signal.sourceContextId] = {
+        id: signal.sourceContextId,
+        source: "user",
+        title: null,
+        conversationType: "standard",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "vellum",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.createdNewConversation).toBe(true);
+      expect(result.messageId).toBe("msg-001");
+      expect(createConversationMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          source: "assistant_initiated",
+          groupId: "group-123",
+        }),
+      );
+      expect(getConversationMock).not.toHaveBeenCalled();
+      expect(signal).toEqual(original);
+    });
+
+    test("an ineligible prepared resolution retains passive pairing when the flag changes", async () => {
+      const signal = share();
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+      assistantInitiatedThreadsEnabled = true;
+      mockExistingConversations[signal.sourceContextId] = {
+        id: signal.sourceContextId,
+        source: "heartbeat",
+        title: null,
+        conversationType: "background",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "vellum",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBe(signal.sourceContextId);
+      expect(createConversationMock).not.toHaveBeenCalled();
+      expect(addMessageMock).toHaveBeenCalledTimes(1);
+    });
+
+    test.each(["slack", "telegram", "discord"] as const)(
+      "%s retains the producer metadata despite a prepared vellum resolution",
+      async (channel) => {
+        assistantInitiatedThreadsEnabled = true;
+        const signal = share({
+          conversationMetadata: { groupId: "group-123" },
+        });
+        const original = structuredClone(signal);
+        const assistantInitiatedThread =
+          resolveAssistantInitiatedThread(signal);
+        getConversationMock.mockClear();
+
+        const result = await pairDeliveryWithConversation(
+          signal,
+          channel,
+          makeCopy(),
+          { assistantInitiatedThread },
+        );
+
+        expect(result.createdNewConversation).toBe(true);
+        expect(result.strategy).toBe("continue_existing_conversation");
+        expect(createConversationMock).toHaveBeenCalledWith(
+          expect.objectContaining({
+            conversationType: "background",
+            source: "notification",
+            groupId: "group-123",
+          }),
+        );
+        expect(addMessageMock).not.toHaveBeenCalled();
+        expect(getConversationMock).not.toHaveBeenCalled();
+        expect(signal).toEqual(original);
+      },
+    );
+
+    test("platform delivery does not pair a prepared vellum resolution", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      const signal = share();
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "platform",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.strategy).toBe("push_only");
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBeNull();
+      expect(createConversationMock).not.toHaveBeenCalled();
+      expect(addMessageMock).not.toHaveBeenCalled();
+    });
+
     test("flag on: a share from a background run materializes a section thread", async () => {
       assistantInitiatedThreadsEnabled = true;
       mockExistingConversations["conv-heartbeat"] = {

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -1,8 +1,26 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { saveRawConfig } from "../config/loader.js";
+import type { NotificationSignal } from "../notifications/signal.js";
 import type { NotificationChannel } from "../notifications/types.js";
 
+let assistantInitiatedCandidate = false;
+const resolveAssistantInitiatedThreadMock = mock(
+  (signal: NotificationSignal) => ({
+    isCandidate: assistantInitiatedCandidate,
+    vellumSignal: assistantInitiatedCandidate
+      ? {
+          ...signal,
+          requiresConversation: true,
+          conversationMetadata: { source: "assistant_initiated" },
+        }
+      : signal,
+  }),
+);
+mock.module("../notifications/assistant-initiated-thread.js", () => ({
+  resolveAssistantInitiatedThread: resolveAssistantInitiatedThreadMock,
+}));
+
 const evaluateSignalMock = mock();
 const enforceRoutingIntentMock = mock();
 const updateDecisionMock = mock();
@@ -113,6 +131,8 @@ import {
 
 beforeEach(() => {
   saveRawConfig({});
+  assistantInitiatedCandidate = false;
+  resolveAssistantInitiatedThreadMock.mockClear();
   writeHomeFeedItemForSignalMock.mockClear();
   evaluateSignalMock.mockReset();
   enforceRoutingIntentMock.mockReset();
@@ -1020,3 +1040,142 @@ describe("classifyNotificationReceipt", () => {
     ).toBe("unknown");
   });
 });
+
+describe("emitNotificationSignal From me push defaults", () => {
+  const params = {
+    sourceEventName: "assistant.share",
+    sourceChannel: "assistant_tool" as const,
+    sourceContextId: "conv-background",
+    attentionHints: {
+      urgency: "low" as const,
+      requiresAction: false,
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+  };
+  const decision = (selectedChannels: NotificationChannel[] = ["vellum"]) => ({
+    shouldNotify: true,
+    selectedChannels,
+    reasoningSummary: "Assistant-authored share",
+    renderedCopy: { vellum: { title: "An update", body: "A useful result." } },
+    dedupeKey: "share-1",
+    confidence: 1,
+    fallbackUsed: false,
+    persistedDecisionId: "decision-share",
+  });
+
+  beforeEach(() => {
+    assistantInitiatedCandidate = true;
+    evaluateSignalMock.mockResolvedValue(decision());
+  });
+
+  test("adds configured platform after routing and persists the final decision", async () => {
+    const result = await emitNotificationSignal(params);
+    expect(result.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(resolveAssistantInitiatedThreadMock).toHaveBeenCalledTimes(1);
+    expect(updateDecisionMock).toHaveBeenCalledWith(
+      "decision-share",
+      expect.objectContaining({
+        selectedChannels: ["vellum", "platform"],
+      }),
+    );
+    expect(dispatchDecisionMock.mock.calls[0]?.[0]).toMatchObject({
+      attentionHints: { urgency: "low" },
+    });
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: {
+        platformAdded: true,
+        resolution: {
+          isCandidate: true,
+          vellumSignal: {
+            requiresConversation: true,
+            conversationMetadata: { source: "assistant_initiated" },
+          },
+        },
+      },
+    });
+  });
+
+  test.each([
+    "quiet",
+    "unconfigured",
+    "noncandidate",
+    "suppressed",
+    "single_channel",
+    "external_only",
+    "vellum_allowlist",
+  ])("respects %s policy without adding platform", async (scenario) => {
+    assistantInitiatedCandidate = scenario !== "noncandidate";
+    isPlatformClientConfiguredMock.mockResolvedValue(
+      scenario !== "unconfigured",
+    );
+    evaluateSignalMock.mockResolvedValue({
+      ...decision(scenario === "external_only" ? ["telegram"] : ["vellum"]),
+      shouldNotify: scenario !== "suppressed",
+    });
+    const result = await emitNotificationSignal({
+      ...params,
+      routingIntent:
+        scenario === "single_channel" ? "single_channel" : undefined,
+      contextPayload: {
+        quiet: scenario === "quiet",
+        ...(scenario === "vellum_allowlist"
+          ? { channelAllowlist: ["vellum"] }
+          : {}),
+      },
+    });
+    expect(result.selectedChannels).not.toContain("platform");
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: { platformAdded: false },
+    });
+  });
+
+  test("keeps existing platform and external selections independent of this feature", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      decision(["vellum", "platform", "telegram"]),
+    );
+    const result = await emitNotificationSignal({
+      ...params,
+      contextPayload: { quiet: true },
+    });
+    expect(result.selectedChannels).toEqual(["vellum", "platform", "telegram"]);
+    expect(isPlatformClientConfiguredMock).not.toHaveBeenCalled();
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: { platformAdded: false },
+    });
+  });
+
+  test("probes an unbound platform once across urgency and From me policy", async () => {
+    isPlatformClientConfiguredMock.mockResolvedValue(false);
+    const result = await emitNotificationSignal({
+      ...params,
+      attentionHints: { ...params.attentionHints, urgency: "high" },
+    });
+    expect(result.selectedChannels).toEqual(["vellum"]);
+    expect(isPlatformClientConfiguredMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("preserves preferred external selections while adding the platform default", async () => {
+    evaluateSignalMock.mockResolvedValue(decision(["vellum", "telegram"]));
+    const result = await emitNotificationSignal(params);
+    expect(result.selectedChannels).toEqual(["vellum", "telegram", "platform"]);
+  });
+
+  test.each(["deduplicated", "source_active"])(
+    "does not resolve candidates for %s signals",
+    async (scenario) => {
+      if (scenario === "deduplicated") {
+        createEventMock.mockReturnValue(null);
+      }
+      await emitNotificationSignal({
+        ...params,
+        attentionHints: {
+          ...params.attentionHints,
+          visibleInSourceNow: scenario === "source_active",
+        },
+      });
+      expect(resolveAssistantInitiatedThreadMock).not.toHaveBeenCalled();
+      expect(dispatchDecisionMock).not.toHaveBeenCalled();
+    },
+  );
+});

package/src/__tests__/llm-catalog-parity.test.ts

@@ -390,9 +390,9 @@ describe("LLM catalog parity: daemon vs client", () => {
     });
   });
 
-  test("Fireworks catalog includes GLM 5.2", () => {
+  test("Fireworks catalog includes GLM 5.3", () => {
     expect(
-      isModelInCatalog("fireworks", "accounts/fireworks/models/glm-5p2"),
+      isModelInCatalog("fireworks", "accounts/fireworks/models/glm-5p3"),
     ).toBe(true);
 
     const fireworks = PROVIDER_CATALOG.find(
@@ -400,10 +400,10 @@ describe("LLM catalog parity: daemon vs client", () => {
     );
     expect(
       fireworks?.models.find(
-        (model) => model.id === "accounts/fireworks/models/glm-5p2",
+        (model) => model.id === "accounts/fireworks/models/glm-5p3",
       ),
     ).toMatchObject({
-      displayName: "GLM 5.2",
+      displayName: "GLM 5.3",
       contextWindowTokens: 1040000,
       maxOutputTokens: 131072,
       supportsToolUse: true,

package/src/__tests__/llm-schema.test.ts

@@ -198,7 +198,7 @@ describe("LLMSchema", () => {
       profiles: {
         "glm-default": {
           provider: "vellum",
-          model: "accounts/fireworks/models/glm-5p2",
+          model: "accounts/fireworks/models/glm-5p3",
         },
       },
       activeProfile: "glm-default",

package/src/__tests__/pricing.test.ts

@@ -10,6 +10,17 @@ import {
 } from "../util/pricing.js";
 
 describe("resolvePricing", () => {
+  test.each([
+    ["accounts/fireworks/models/glm-5p2", 1.4 + 4.4],
+    ["accounts/fireworks/models/kimi-k2p6", 0.95 + 4.0],
+    ["accounts/fireworks/models/deepseek-v4-pro-0813", 1.32 + 3.96],
+    ["accounts/fireworks/models/deepseek-v4-flash-0731", 0.14 + 0.28],
+  ])("prices stored usage for retired Fireworks model %s", (model, cost) => {
+    const result = resolvePricing("fireworks", model, 1_000_000, 1_000_000);
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBeCloseTo(cost, 10);
+  });
+
   describe("Anthropic models", () => {
     test("returns priced for claude-opus-4-6", () => {
       const result = resolvePricing(

package/src/__tests__/workspace-migration-133-collapse-provider-connections.test.ts

@@ -100,7 +100,7 @@ describe("133-collapse-provider-connections migration", () => {
             source: "user",
             provider: "fireworks",
             provider_connection: "vellum",
-            model: "accounts/fireworks/models/glm-5p2",
+            model: "accounts/fireworks/models/minimax-m3",
           },
         },
       },
@@ -257,7 +257,7 @@ describe("133-collapse-provider-connections migration", () => {
           encoded: {
             source: "user",
             provider: "vellum",
-            model: "fireworks/accounts/fireworks/models/glm-5p2",
+            model: "fireworks/accounts/fireworks/models/minimax-m3",
           },
         },
       },
@@ -272,7 +272,7 @@ describe("133-collapse-provider-connections migration", () => {
     expect(llm.profiles.encoded).toEqual({
       source: "user",
       provider: "vellum",
-      model: "accounts/fireworks/models/glm-5p2",
+      model: "accounts/fireworks/models/minimax-m3",
     });
   });
 

package/src/__tests__/workspace-migration-161-repair-retired-fireworks-glm-5p2-model-id.test.ts

@@ -0,0 +1,233 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairRetiredFireworksGlm5p2ModelIdMigration } from "../workspace/migrations/161-repair-retired-fireworks-glm-5p2-model-id.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const STALE = "accounts/fireworks/models/glm-5p2";
+const REPLACEMENT = "accounts/fireworks/models/glm-5p3";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-161-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function seedRows(rows: Array<{ name: string; provider: string }>): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
+    name TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  for (const row of rows) {
+    db.query(
+      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, '{"type":"api_key"}', 1, 1)`,
+    ).run(row.name, row.provider);
+  }
+  db.close();
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("161-repair-retired-fireworks-glm-5p2-model-id migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(repairRetiredFireworksGlm5p2ModelIdMigration.id).toBe(
+      "161-repair-retired-fireworks-glm-5p2-model-id",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "161-repair-retired-fireworks-glm-5p2-model-id",
+    );
+  });
+
+  test("repairs the stale ID in default, call sites, and profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        callSites: {
+          recall: { model: STALE, maxTokens: 4096 },
+          heartbeat: { model: `${STALE}-tuned` },
+          malformed: STALE,
+        },
+        profiles: {
+          "cost-optimized": { provider: "vellum", model: STALE },
+          legacy: { model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.maxTokens).toBe(4096);
+    // Non-exact matches and malformed leaves are untouched.
+    expect(llm.callSites.heartbeat.model).toBe(`${STALE}-tuned`);
+    expect(llm.callSites.malformed).toBe(STALE);
+    // Managed profiles stamped provider "vellum" carry Fireworks model IDs.
+    expect(llm.profiles["cost-optimized"].model).toBe(REPLACEMENT);
+    expect(llm.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("repairs entry-bound fragments whose row kind is fireworks or vellum", () => {
+    seedRows([
+      { name: "my-fireworks", provider: "fireworks" },
+      { name: "managed-alt", provider: "vellum" },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          bound: { provider: "my-fireworks", model: STALE },
+          managed: { provider: "managed-alt", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(REPLACEMENT);
+    expect(llm.profiles.managed.model).toBe(REPLACEMENT);
+  });
+
+  test("leaves fragments with an explicit other provider untouched", () => {
+    seedRows([{ name: "byo-compat", provider: "openai-compatible" }]);
+    writeConfig({
+      llm: {
+        default: { provider: "openai-compatible", model: STALE },
+        profiles: {
+          byo: { provider: "openai-compatible", model: STALE },
+          // Entry-bound profile whose row kind is not repairable.
+          compatBound: { provider: "byo-compat", model: STALE },
+          // Entry name with no row: dangling, so nothing proves it is a
+          // fireworks-kind route.
+          dangling: { provider: "ghost", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(STALE);
+    expect(llm.profiles.byo.model).toBe(STALE);
+    expect(llm.profiles.compatBound.model).toBe(STALE);
+    expect(llm.profiles.dangling.model).toBe(STALE);
+  });
+
+  test("leaves entry-name providers untouched when no DB file exists", () => {
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+  });
+
+  test("throws when an entry-name provider needs rows and the DB is unreadable", () => {
+    // A DB file without the provider_connections table is unqueryable, so
+    // the run must fail (and retry later) instead of skipping the profile.
+    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+    writeFileSync(join(workspaceDir, "data", "db", "assistant.db"), "");
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    expect(() =>
+      repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir),
+    ).toThrow();
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+
+    // Vendor and absent providers never need the rows, so the same broken
+    // DB does not block their repair.
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { legacy: { model: STALE } },
+      },
+    });
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+    const repaired = readConfig().llm as Record<string, any>;
+    expect(repaired.default.model).toBe(REPLACEMENT);
+    expect(repaired.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("is idempotent and a no-op without the stale ID", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { fine: { provider: "fireworks", model: REPLACEMENT } },
+      },
+    });
+
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+    const first = readConfig();
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(first);
+
+    const llm = first.llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.profiles.fine.model).toBe(REPLACEMENT);
+  });
+
+  test("handles missing config, missing llm block, and invalid JSON", () => {
+    // No config.json at all.
+    expect(() =>
+      repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    writeConfig({ theme: "dark" });
+    repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({ theme: "dark" });
+
+    writeFileSync(join(workspaceDir, "config.json"), "{not json");
+    expect(() =>
+      repairRetiredFireworksGlm5p2ModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+});