langfuse

1
/** @jest-environment node */
2

3
import { pruneDatabase } from "@/src/__tests__/test-utils";
4
import { ModelUsageUnit } from "@/src/constants";
5
import { prisma } from "@/src/server/db";
6

7
describe("cost retrieval tests", () => {
8
  beforeEach(async () => await pruneDatabase());
9

10
  [
11
    {
12
      testDescription: "prompt and completion tokens",
13
      promptTokens: 200,
14
      completionTokens: 3000,
15
      totalTokens: undefined,
16
      inputPrice: "0.0000010",
17
      outputPrice: "0.0000020",
18
      totalPrice: undefined,
19
      expectedPromptTokens: 200,
20
      expectedCompletionTokens: 3000,
21
      expectedTotalTokens: 0,
22
      expectedInputCost: "0.0002", // 200 / 1000 * 0.0010
23
      expectedOutputCost: "0.006", // 3000 / 1000 * 0.0020
24
      expectedTotalCost: "0.0062", // 0.0002 + 0.006
25
    },
26
    {
27
      testDescription: "missing completion tokens",
28
      promptTokens: 200,
29
      completionTokens: undefined,
30
      totalTokens: undefined,
31
      inputPrice: "0.0000010",
32
      outputPrice: "0.0000020",
33
      totalPrice: undefined,
34
      expectedPromptTokens: 200,
35
      expectedCompletionTokens: 0,
36
      expectedTotalTokens: 0,
37
      expectedInputCost: "0.0002",
38
      expectedOutputCost: "0", // completionTokens are set to 0 when ingesting undefined, hence 0 cost
39
      expectedTotalCost: "0.0002",
40
    },
41
    {
42
      testDescription: "missing prompt tokens",
43
      promptTokens: undefined,
44
      completionTokens: 3000,
45
      totalTokens: undefined,
46
      inputPrice: "0.0000010",
47
      outputPrice: "0.0000020",
48
      totalPrice: undefined,
49
      expectedPromptTokens: 0,
50
      expectedCompletionTokens: 3000,
51
      expectedTotalTokens: 0,
52
      expectedInputCost: "0", // promptTokens are set to 0 when ingesting undefined, hence 0 cost
53
      expectedOutputCost: "0.006",
54
      expectedTotalCost: "0.006",
55
    },
56
    {
57
      testDescription: "prompt and completion and total",
58
      promptTokens: 200,
59
      completionTokens: 3000,
60
      totalTokens: 3200,
61
      inputPrice: "0.0000010",
62
      outputPrice: "0.0000020",
63
      totalPrice: undefined,
64
      expectedPromptTokens: 200,
65
      expectedCompletionTokens: 3000,
66
      expectedTotalTokens: 3200,
67
      expectedInputCost: "0.0002", // 200 / 1000 * 0.0010
68
      expectedOutputCost: "0.006", // 3000 / 1000 * 0.0020
69
      expectedTotalCost: "0.0062", // 0.0002 + 0.006
70
    },
71
    {
72
      testDescription: "total only without price",
73
      promptTokens: undefined,
74
      completionTokens: undefined,
75
      totalTokens: 3200,
76
      inputPrice: "0.0000010",
77
      outputPrice: "0.0000020",
78
      totalPrice: undefined,
79
      expectedPromptTokens: 0,
80
      expectedCompletionTokens: 0,
81
      expectedTotalTokens: 3200,
82
      expectedInputCost: "0",
83
      expectedOutputCost: "0",
84
      expectedTotalCost: "0",
85
    },
86
    {
87
      testDescription: "total only",
88
      promptTokens: undefined,
89
      completionTokens: undefined,
90
      totalTokens: 3200,
91
      inputPrice: "0.0000010",
92
      outputPrice: "0.0000020",
93
      totalPrice: "0.1",
94
      expectedPromptTokens: 0,
95
      expectedCompletionTokens: 0,
96
      expectedTotalTokens: 3200,
97
      expectedInputCost: "0",
98
      expectedOutputCost: "0",
99
      expectedTotalCost: "320",
100
    },
101
  ].forEach((input) => {
102
    it(`should calculate cost correctly ${input.testDescription}`, async () => {
103
      await pruneDatabase();
104

105
      await prisma.model.create({
106
        data: {
107
          modelName: "gpt-3.5-turbo",
108
          inputPrice: input.inputPrice,
109
          outputPrice: input.outputPrice,
110
          totalPrice: input.totalPrice,
111
          matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
112
          projectId: null,
113
          startDate: new Date("2023-12-01"),
114
          tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
115
          unit: ModelUsageUnit.Tokens,
116
        },
117
      });
118

119
      const dbTrace = await prisma.trace.create({
120
        data: {
121
          name: "trace-name",
122
          project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
123
        },
124
      });
125

126
      await prisma.observation.create({
127
        data: {
128
          traceId: dbTrace.id,
129
          type: "GENERATION",
130
          project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
131
          model: "gpt-3.5-turbo",
132
          internalModel: "gpt-3.5-turbo",
133
          startTime: new Date("2024-01-01T00:00:00.000Z"),
134
          unit: ModelUsageUnit.Tokens,
135
          promptTokens: input.promptTokens,
136
          completionTokens: input.completionTokens,
137
          totalTokens: input.totalTokens,
138
        },
139
      });
140

141
      const view = await prisma.observationView.findFirst({
142
        where: { traceId: dbTrace.id },
143
      });
144

145
      expect(view?.promptTokens).toBe(input.expectedPromptTokens);
146
      expect(view?.completionTokens).toBe(input.expectedCompletionTokens);
147
      expect(view?.totalTokens).toBe(input.expectedTotalTokens);
148

149
      // calculated cost fields
150
      expect(view?.calculatedInputCost?.toString()).toBe(
151
        input.expectedInputCost,
152
      );
153
      expect(view?.calculatedOutputCost?.toString()).toBe(
154
        input.expectedOutputCost,
155
      );
156
      expect(view?.calculatedTotalCost?.toString()).toBe(
157
        input.expectedTotalCost,
158
      );
159
    });
160
  });
161

162
  [
163
    {
164
      testDescription: "overwriting project specific model",
165
      expectedInputCost: "0.0004", // 200 / 1000 * 0.0010
166
      expectedOutputCost: "0.012", // 3000 / 1000 * 0.0020
167
      expectedTotalCost: "0.0124", // 0.0002 + 0.006
168
      expectedModelId: "model-2",
169
    },
170
  ].forEach((input) => {
171
    it(`should calculate cost correctly with multiple models ${input.testDescription}`, async () => {
172
      await pruneDatabase();
173

174
      await prisma.model.create({
175
        data: {
176
          id: "model-1",
177
          modelName: "gpt-3.5-turbo",
178
          inputPrice: "0.0000010",
179
          outputPrice: "0.0000020",
180
          totalPrice: "0.1",
181
          matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
182
          projectId: null,
183
          startDate: new Date("2023-12-01"),
184
          tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
185
          unit: ModelUsageUnit.Tokens,
186
        },
187
      });
188
      await prisma.model.create({
189
        data: {
190
          id: "model-2",
191
          modelName: "gpt-3.5-turbo",
192
          inputPrice: "0.0000020",
193
          outputPrice: "0.0000040",
194
          totalPrice: undefined,
195
          matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
196
          startDate: new Date("2023-12-01"),
197
          tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
198
          unit: ModelUsageUnit.Tokens,
199
          project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
200
        },
201
      });
202

203
      const dbTrace = await prisma.trace.create({
204
        data: {
205
          name: "trace-name",
206
          project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
207
        },
208
      });
209

210
      await prisma.observation.create({
211
        data: {
212
          traceId: dbTrace.id,
213
          type: "GENERATION",
214
          project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
215
          model: "gpt-3.5-turbo",
216
          internalModel: "gpt-3.5-turbo",
217
          startTime: new Date("2024-01-01T00:00:00.000Z"),
218
          unit: ModelUsageUnit.Tokens,
219
          promptTokens: 200,
220
          completionTokens: 3000,
221
          totalTokens: undefined,
222
        },
223
      });
224

225
      const view = await prisma.observationView.findFirst({
226
        where: { traceId: dbTrace.id },
227
      });
228

229
      // calculated cost fields
230
      expect(view?.modelId).toBe(input.expectedModelId);
231
      expect(view?.calculatedInputCost?.toString()).toBe(
232
        input.expectedInputCost,
233
      );
234
      expect(view?.calculatedOutputCost?.toString()).toBe(
235
        input.expectedOutputCost,
236
      );
237
      expect(view?.calculatedTotalCost?.toString()).toBe(
238
        input.expectedTotalCost,
239
      );
240
    });
241
  });
242

243
  it(`should prioritize latest models`, async () => {
244
    await pruneDatabase();
245
    await prisma.model.create({
246
      data: {
247
        id: "model-0",
248
        modelName: "gpt-3.5-turbo",
249
        inputPrice: "0.0000000",
250
        outputPrice: "0.0000000",
251
        totalPrice: "0.1",
252
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
253
        projectId: null,
254
        startDate: null,
255
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
256
        unit: ModelUsageUnit.Tokens,
257
      },
258
    });
259

260
    await prisma.model.create({
261
      data: {
262
        id: "model-1",
263
        modelName: "gpt-3.5-turbo",
264
        inputPrice: "0.0000010",
265
        outputPrice: "0.0000020",
266
        totalPrice: "0.1",
267
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
268
        projectId: null,
269
        startDate: new Date("2023-12-01"),
270
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
271
        unit: ModelUsageUnit.Tokens,
272
      },
273
    });
274
    await prisma.model.create({
275
      data: {
276
        id: "model-2",
277
        modelName: "gpt-3.5-turbo",
278
        inputPrice: "0.0000020",
279
        outputPrice: "0.0000040",
280
        totalPrice: undefined,
281
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
282
        startDate: new Date("2023-12-02"),
283
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
284
        unit: ModelUsageUnit.Tokens,
285
      },
286
    });
287

288
    const dbTrace = await prisma.trace.create({
289
      data: {
290
        name: "trace-name",
291
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
292
      },
293
    });
294

295
    await prisma.observation.create({
296
      data: {
297
        traceId: dbTrace.id,
298
        type: "GENERATION",
299
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
300
        model: "gpt-3.5-turbo",
301
        internalModel: "gpt-3.5-turbo",
302
        startTime: new Date("2024-01-01T00:00:00.000Z"),
303
        unit: ModelUsageUnit.Tokens,
304
        promptTokens: 200,
305
        completionTokens: 3000,
306
        totalTokens: undefined,
307
      },
308
    });
309

310
    const view = await prisma.observationView.findFirst({
311
      where: { traceId: dbTrace.id },
312
    });
313

314
    console.log(view);
315

316
    // calculated cost fields
317
    expect(view?.modelId).toBe("model-2");
318
    expect(view?.calculatedInputCost?.toString()).toBe("0.0004");
319
    expect(view?.calculatedOutputCost?.toString()).toBe("0.012");
320
    expect(view?.calculatedTotalCost?.toString()).toBe("0.0124");
321
  });
322

323
  it(`should take old model for old observations`, async () => {
324
    await prisma.model.create({
325
      data: {
326
        id: "model-0",
327
        modelName: "gpt-3.5-turbo",
328
        inputPrice: "0.0000000",
329
        outputPrice: "0.0000000",
330
        totalPrice: "0.1",
331
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
332
        projectId: null,
333
        startDate: null,
334
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
335
        unit: ModelUsageUnit.Tokens,
336
      },
337
    });
338

339
    await prisma.model.create({
340
      data: {
341
        id: "model-1",
342
        modelName: "gpt-3.5-turbo",
343
        inputPrice: "0.0000010",
344
        outputPrice: "0.0000020",
345
        totalPrice: "0.1",
346
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
347
        projectId: null,
348
        startDate: new Date("2023-12-01"),
349
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
350
        unit: ModelUsageUnit.Tokens,
351
      },
352
    });
353
    await prisma.model.create({
354
      data: {
355
        id: "model-2",
356
        modelName: "gpt-3.5-turbo",
357
        inputPrice: "0.0000020",
358
        outputPrice: "0.0000040",
359
        totalPrice: undefined,
360
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
361
        startDate: new Date("2023-12-02"),
362
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
363
        unit: ModelUsageUnit.Tokens,
364
      },
365
    });
366

367
    const dbTrace = await prisma.trace.create({
368
      data: {
369
        name: "trace-name",
370
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
371
      },
372
    });
373

374
    await prisma.observation.create({
375
      data: {
376
        traceId: dbTrace.id,
377
        type: "GENERATION",
378
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
379
        model: "gpt-3.5-turbo",
380
        internalModel: "gpt-3.5-turbo",
381
        startTime: new Date("2023-01-01T00:00:00.000Z"),
382
        unit: ModelUsageUnit.Tokens,
383
        promptTokens: 200,
384
        completionTokens: 3000,
385
        totalTokens: undefined,
386
      },
387
    });
388

389
    const view = await prisma.observationView.findFirst({
390
      where: { traceId: dbTrace.id },
391
    });
392

393
    console.log(view);
394

395
    // calculated cost fields
396
    expect(view?.modelId).toBe("model-0");
397
    expect(view?.calculatedInputCost?.toString()).toBe("0");
398
    expect(view?.calculatedOutputCost?.toString()).toBe("0");
399
    expect(view?.calculatedTotalCost?.toString()).toBe("0");
400
  });
401

402
  it(`should prioritize own models`, async () => {
403
    await pruneDatabase();
404
    await prisma.model.create({
405
      data: {
406
        id: "model-0",
407
        modelName: "gpt-3.5-turbo",
408
        inputPrice: "0.0000000",
409
        outputPrice: "0.0000000",
410
        totalPrice: "0.1",
411
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
412
        projectId: null,
413
        startDate: null,
414
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
415
        unit: ModelUsageUnit.Tokens,
416
      },
417
    });
418

419
    await prisma.model.create({
420
      data: {
421
        id: "model-1",
422
        modelName: "gpt-3.5-turbo",
423
        inputPrice: "0.0000010",
424
        outputPrice: "0.0000020",
425
        totalPrice: "0.1",
426
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
427
        startDate: null,
428
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
429
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
430
        unit: ModelUsageUnit.Tokens,
431
      },
432
    });
433

434
    const dbTrace = await prisma.trace.create({
435
      data: {
436
        name: "trace-name",
437
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
438
      },
439
    });
440

441
    await prisma.observation.create({
442
      data: {
443
        traceId: dbTrace.id,
444
        type: "GENERATION",
445
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
446
        model: "gpt-3.5-turbo",
447
        internalModel: "gpt-3.5-turbo",
448
        startTime: new Date("2024-01-01T00:00:00.000Z"),
449
        unit: ModelUsageUnit.Tokens,
450
        promptTokens: 200,
451
        completionTokens: 3000,
452
        totalTokens: undefined,
453
      },
454
    });
455

456
    const view = await prisma.observationView.findFirst({
457
      where: { traceId: dbTrace.id },
458
    });
459

460
    console.log(view);
461

462
    // calculated cost fields
463
    expect(view?.modelId).toBe("model-1");
464
  });
465

466
  it(`should prioritize old model if the latest model is not own one`, async () => {
467
    await prisma.model.create({
468
      data: {
469
        id: "model-1",
470
        modelName: "gpt-3.5-turbo",
471
        inputPrice: "0.0010",
472
        outputPrice: "0.0020",
473
        totalPrice: "0.1",
474
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
475
        startDate: new Date("2023-12-02"),
476
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
477
        unit: ModelUsageUnit.Tokens,
478
      },
479
    });
480
    await prisma.model.create({
481
      data: {
482
        id: "model-2",
483
        modelName: "gpt-3.5-turbo",
484
        inputPrice: "0.0000020",
485
        outputPrice: "0.0000040",
486
        totalPrice: undefined,
487
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
488
        startDate: new Date("2023-12-01"),
489
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
490
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
491
        unit: ModelUsageUnit.Tokens,
492
      },
493
    });
494

495
    const dbTrace = await prisma.trace.create({
496
      data: {
497
        name: "trace-name",
498
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
499
      },
500
    });
501

502
    await prisma.observation.create({
503
      data: {
504
        traceId: dbTrace.id,
505
        type: "GENERATION",
506
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
507
        model: "gpt-3.5-turbo",
508
        internalModel: "gpt-3.5-turbo",
509
        startTime: new Date("2024-01-01T00:00:00.000Z"),
510
        unit: ModelUsageUnit.Tokens,
511
        promptTokens: 200,
512
        completionTokens: 3000,
513
        totalTokens: undefined,
514
      },
515
    });
516

517
    const view = await prisma.observationView.findFirst({
518
      where: { traceId: dbTrace.id },
519
    });
520

521
    console.log(view);
522

523
    // calculated cost fields
524
    expect(view?.modelId).toBe("model-2");
525
    expect(view?.calculatedInputCost?.toString()).toBe("0.0004");
526
    expect(view?.calculatedOutputCost?.toString()).toBe("0.012");
527
    expect(view?.calculatedTotalCost?.toString()).toBe("0.0124");
528
  });
529

530
  it(`should prioritize new model if the latest model is own one`, async () => {
531
    await pruneDatabase();
532

533
    await prisma.model.create({
534
      data: {
535
        id: "model-1",
536
        modelName: "gpt-3.5-turbo",
537
        inputPrice: "0.0010",
538
        outputPrice: "0.0020",
539
        totalPrice: "0.1",
540
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
541
        startDate: null,
542
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
543
        unit: ModelUsageUnit.Tokens,
544
      },
545
    });
546
    await prisma.model.create({
547
      data: {
548
        id: "model-2",
549
        modelName: "gpt-3.5-turbo",
550
        inputPrice: "0.0000020",
551
        outputPrice: "0.0000040",
552
        totalPrice: undefined,
553
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
554
        startDate: new Date("2023-12-01"),
555
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
556
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
557
        unit: ModelUsageUnit.Tokens,
558
      },
559
    });
560

561
    const dbTrace = await prisma.trace.create({
562
      data: {
563
        name: "trace-name",
564
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
565
      },
566
    });
567

568
    await prisma.observation.create({
569
      data: {
570
        traceId: dbTrace.id,
571
        type: "GENERATION",
572
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
573
        model: "gpt-3.5-turbo",
574
        internalModel: "gpt-3.5-turbo",
575
        startTime: new Date("2024-01-01T00:00:00.000Z"),
576
        unit: ModelUsageUnit.Tokens,
577
        promptTokens: 200,
578
        completionTokens: 3000,
579
        totalTokens: undefined,
580
      },
581
    });
582

583
    const view = await prisma.observationView.findFirst({
584
      where: { traceId: dbTrace.id },
585
    });
586

587
    console.log(view);
588

589
    // calculated cost fields
590
    expect(view?.modelId).toBe("model-2");
591
    expect(view?.calculatedInputCost?.toString()).toBe("0.0004");
592
    expect(view?.calculatedOutputCost?.toString()).toBe("0.012");
593
    expect(view?.calculatedTotalCost?.toString()).toBe("0.0124");
594
  });
595

596
  it(`should prioritize user provided cost`, async () => {
597
    await pruneDatabase();
598

599
    await prisma.model.create({
600
      data: {
601
        id: "model-1",
602
        modelName: "gpt-3.5-turbo",
603
        inputPrice: "0.0010",
604
        outputPrice: "0.0020",
605
        totalPrice: "0.1",
606
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
607
        startDate: new Date("2023-12-02"),
608
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
609
        unit: ModelUsageUnit.Tokens,
610
      },
611
    });
612
    await prisma.model.create({
613
      data: {
614
        id: "model-2",
615
        modelName: "gpt-3.5-turbo",
616
        inputPrice: "0.0020",
617
        outputPrice: "0.0040",
618
        totalPrice: undefined,
619
        matchPattern: "(.*)(gpt-)(35|3.5)(-turbo)?(.*)",
620
        startDate: new Date("2023-12-01"),
621
        tokenizerConfig: { tokensPerMessage: 3, tokensPerName: 1 },
622
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
623
        unit: ModelUsageUnit.Tokens,
624
      },
625
    });
626

627
    const dbTrace = await prisma.trace.create({
628
      data: {
629
        name: "trace-name",
630
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
631
      },
632
    });
633

634
    await prisma.observation.create({
635
      data: {
636
        traceId: dbTrace.id,
637
        type: "GENERATION",
638
        project: { connect: { id: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a" } },
639
        model: "gpt-3.5-turbo",
640
        internalModel: "gpt-3.5-turbo",
641
        startTime: new Date("2024-01-01T00:00:00.000Z"),
642
        unit: ModelUsageUnit.Tokens,
643
        promptTokens: 200,
644
        completionTokens: 3000,
645
        totalTokens: undefined,
646
        inputCost: "1",
647
        outputCost: "2",
648
        totalCost: "3",
649
      },
650
    });
651

652
    const view = await prisma.observationView.findFirst({
653
      where: { traceId: dbTrace.id },
654
    });
655

656
    console.log(view);
657

658
    // calculated cost fields
659
    expect(view?.modelId).toBe("model-2");
660
    expect(view?.calculatedInputCost?.toString()).toBe("1");
661
    expect(view?.calculatedOutputCost?.toString()).toBe("2");
662
    expect(view?.calculatedTotalCost?.toString()).toBe("3");
663
  });
664
});
665