fix(llm-catalog): refresh default model pricing on sync

internal-packages/llm-model-catalog/package.json

@@ -9,7 +9,11 @@
     "@trigger.dev/core": "workspace:*",
     "@trigger.dev/database": "workspace:*"
   },
+  "devDependencies": {
+    "vitest": "3.1.4"
+  },
   "scripts": {
+    "test": "vitest --sequence.concurrent=false --no-file-parallelism",
     "typecheck": "tsc --noEmit",
     "generate": "node scripts/generate.mjs",
     "sync-prices": "bash scripts/sync-model-prices.sh && node scripts/generate.mjs",

internal-packages/llm-model-catalog/src/sync.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi } from "vitest";
+import { syncLlmCatalog } from "./sync.js";
+import { defaultModelPrices } from "./defaultPrices.js";
+
+const gpt4oDef = defaultModelPrices.find((m) => m.modelName === "gpt-4o");
+if (!gpt4oDef) {
+  throw new Error("expected gpt-4o in defaultModelPrices");
+}
+
+describe("syncLlmCatalog", () => {
+  it("rebuilds pricing tiers and prices for existing default-source models", async () => {
+    const existingId = "existing-gpt4o";
+
+    const llmModelUpdate = vi.fn();
+    const llmPricingTierDeleteMany = vi.fn();
+    const llmPricingTierCreate = vi.fn();
+
+    const prisma = {
+      llmModel: {
+        findFirst: vi.fn(async (args: { where: { modelName: string } }) => {
+          if (args.where.modelName === "gpt-4o") {
+            return {
+              id: existingId,
+              source: "default",
+              provider: "openai",
+              description: "stale description",
+              contextWindow: 999,
+              maxOutputTokens: 888,
+              capabilities: ["legacy"],
+              isHidden: true,
+              baseModelName: "legacy-base",
+            };
+          }
+          return null;
+        }),
+      },
+      $transaction: vi.fn(async (fn: (tx: unknown) => Promise<void>) => {
+        await fn({
+          llmModel: { update: llmModelUpdate },
+          llmPricingTier: {
+            deleteMany: llmPricingTierDeleteMany,
+            create: llmPricingTierCreate,
+          },
+        });
+      }),
+    };
+
+    await syncLlmCatalog(prisma as never);
+
+    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+
+    expect(llmModelUpdate).toHaveBeenCalledWith({
+      where: { id: existingId },
+      data: expect.objectContaining({
+        matchPattern: gpt4oDef.matchPattern,
+        startDate: gpt4oDef.startDate ? new Date(gpt4oDef.startDate) : null,
+      }),
+    });
+
+    expect(llmPricingTierDeleteMany).toHaveBeenCalledWith({
+      where: { modelId: existingId },
+    });
+
+    expect(llmPricingTierCreate).toHaveBeenCalledTimes(gpt4oDef.pricingTiers.length);
+
+    const firstTier = gpt4oDef.pricingTiers[0];
+    expect(llmPricingTierCreate).toHaveBeenCalledWith({
+      data: {
+        modelId: existingId,
+        name: firstTier.name,
+        isDefault: firstTier.isDefault,
+        priority: firstTier.priority,
+        conditions: firstTier.conditions,
+        prices: {
+          create: expect.arrayContaining(
+            Object.entries(firstTier.prices).map(([usageType, price]) => ({
+              modelId: existingId,
+              usageType,
+              price,
+            }))
+          ),
+        },
+      },
+    });
+
+    const createCall = llmPricingTierCreate.mock.calls[0][0] as {
+      data: { prices: { create: { usageType: string; price: number; modelId: string }[] } };
+    };
+    expect(createCall.data.prices.create).toHaveLength(Object.keys(firstTier.prices).length);
+  });
+
+  it("does not rebuild pricing for non-default source models", async () => {
+    const prisma = {
+      llmModel: {
+        findFirst: vi.fn(async (args: { where: { modelName: string } }) => {
+          if (args.where.modelName === "gpt-4o") {
+            return {
+              id: "admin-edited",
+              source: "admin",
+              provider: null,
+              description: null,
+              contextWindow: null,
+              maxOutputTokens: null,
+              capabilities: [],
+              isHidden: false,
+              baseModelName: null,
+            };
+          }
+          return null;
+        }),
+      },
+      $transaction: vi.fn(),
+    };
+
+    const result = await syncLlmCatalog(prisma as never);
+
+    expect(prisma.$transaction).not.toHaveBeenCalled();
+    expect(result.modelsUpdated).toBe(0);
+    expect(result.modelsSkipped).toBeGreaterThan(0);
+  });
+});

internal-packages/llm-model-catalog/src/sync.ts

@@ -1,6 +1,27 @@
-import type { PrismaClient } from "@trigger.dev/database";
+import type { Prisma, PrismaClient } from "@trigger.dev/database";
 import { defaultModelPrices } from "./defaultPrices.js";
 import { modelCatalog } from "./modelCatalog.js";
+import type { DefaultModelDefinition } from "./types.js";
+
+function pricingTierCreateData(
+  modelId: string,
+  tier: DefaultModelDefinition["pricingTiers"][number]
+): Prisma.LlmPricingTierUncheckedCreateInput {
+  return {
+    modelId,
+    name: tier.name,
+    isDefault: tier.isDefault,
+    priority: tier.priority,
+    conditions: tier.conditions,
+    prices: {
+      create: Object.entries(tier.prices).map(([usageType, price]) => ({
+        modelId,
+        usageType,
+        price,
+      })),
+    },
+  };
+}
 
 export async function syncLlmCatalog(prisma: PrismaClient): Promise<{
   modelsUpdated: number;
@@ -31,21 +52,35 @@ export async function syncLlmCatalog(prisma: PrismaClient): Promise<{
 
     const catalog = modelCatalog[modelDef.modelName];
 
-    await prisma.llmModel.update({
-      where: { id: existing.id },
-      data: {
-        // Update match pattern and start date from Langfuse (may have changed)
-        matchPattern: modelDef.matchPattern,
-        startDate: modelDef.startDate ? new Date(modelDef.startDate) : null,
-        // Update catalog metadata
-        provider: catalog?.provider ?? existing.provider,
-        description: catalog?.description ?? existing.description,
-        contextWindow: catalog?.contextWindow ?? existing.contextWindow,
-        maxOutputTokens: catalog?.maxOutputTokens ?? existing.maxOutputTokens,
-        capabilities: catalog?.capabilities ?? existing.capabilities,
-        isHidden: catalog?.isHidden ?? existing.isHidden,
-        baseModelName: catalog?.baseModelName ?? existing.baseModelName,
-      },
+    await prisma.$transaction(async (tx) => {
+      await tx.llmModel.update({
+        where: { id: existing.id },
+        data: {
+          // Update match pattern and start date from Langfuse (may have changed)
+          matchPattern: modelDef.matchPattern,
+          startDate: modelDef.startDate ? new Date(modelDef.startDate) : null,
+          // Update catalog metadata
+          provider: catalog?.provider ?? existing.provider,
+          description: catalog?.description ?? existing.description,
+          contextWindow:
+            catalog?.contextWindow === undefined ? existing.contextWindow : catalog.contextWindow,
+          maxOutputTokens:
+            catalog?.maxOutputTokens === undefined
+              ? existing.maxOutputTokens
+              : catalog.maxOutputTokens,
+          capabilities: catalog?.capabilities ?? existing.capabilities,
+          isHidden: catalog?.isHidden ?? existing.isHidden,
+          baseModelName: catalog?.baseModelName ?? existing.baseModelName,
+        },
+      });
+
+      await tx.llmPricingTier.deleteMany({ where: { modelId: existing.id } });
+
+      for (const tier of modelDef.pricingTiers) {
+        await tx.llmPricingTier.create({
+          data: pricingTierCreateData(existing.id, tier),
+        });
+      }
     });
 
     modelsUpdated++;

internal-packages/llm-model-catalog/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["**/*.test.ts"],
+    globals: true,
+    isolate: true,
+    fileParallelism: false,
+    poolOptions: {
+      threads: {
+        singleThread: true,
+      },
+    },
+  },
+});