Update external types (#137)

* Separate server and frontend error logic

* Update types in external api

app/src/components/OutputsTable/EditScenarioVars.tsx

@@ -4,7 +4,7 @@ import { useEffect, useState } from "react";
 import { BsPencil, BsX } from "react-icons/bs";
 import { api } from "~/utils/api";
 import { useExperiment, useHandledAsyncCallback, useScenarioVars } from "~/utils/hooks";
-import { maybeReportError } from "~/utils/standardResponses";
+import { maybeReportError } from "~/utils/errorHandling/maybeReportError";
 import { FloatingLabelInput } from "./FloatingLabelInput";
 
 export const ScenarioVar = ({

app/src/server/api/routers/externalApi.router.ts

@@ -39,7 +39,7 @@ export const externalApiRouter = createTRPCRouter({
     })
     .input(
       z.object({
-        startTime: z.number().describe("Unix timestamp in milliseconds"),
+        requestedAt: z.number().describe("Unix timestamp in milliseconds"),
         reqPayload: z.unknown().describe("JSON-encoded request payload"),
         tags: z
           .record(z.string())
@@ -85,7 +85,7 @@ export const externalApiRouter = createTRPCRouter({
       await prisma.loggedCall.create({
         data: {
           projectId: key.projectId,
-          requestedAt: new Date(input.startTime),
+          requestedAt: new Date(input.requestedAt),
           cacheHit: true,
           modelResponseId: existingResponse.id,
         },
@@ -106,12 +106,12 @@ export const externalApiRouter = createTRPCRouter({
     })
     .input(
       z.object({
-        startTime: z.number().describe("Unix timestamp in milliseconds"),
-        endTime: z.number().describe("Unix timestamp in milliseconds"),
+        requestedAt: z.number().describe("Unix timestamp in milliseconds"),
+        receivedAt: z.number().describe("Unix timestamp in milliseconds"),
         reqPayload: z.unknown().describe("JSON-encoded request payload"),
         respPayload: z.unknown().optional().describe("JSON-encoded response payload"),
-        respStatus: z.number().optional().describe("HTTP status code of response"),
-        error: z.string().optional().describe("User-friendly error message"),
+        statusCode: z.number().optional().describe("HTTP status code of response"),
+        errorMessage: z.string().optional().describe("User-friendly error message"),
         tags: z
           .record(z.string())
           .optional()
@@ -153,7 +153,7 @@ export const externalApiRouter = createTRPCRouter({
           data: {
             id: newLoggedCallId,
             projectId: key.projectId,
-            requestedAt: new Date(input.startTime),
+            requestedAt: new Date(input.requestedAt),
             cacheHit: false,
           },
         }),
@@ -161,13 +161,13 @@ export const externalApiRouter = createTRPCRouter({
           data: {
             id: newModelResponseId,
             originalLoggedCallId: newLoggedCallId,
-            requestedAt: new Date(input.startTime),
-            receivedAt: new Date(input.endTime),
+            requestedAt: new Date(input.requestedAt),
+            receivedAt: new Date(input.receivedAt),
             reqPayload: input.reqPayload as Prisma.InputJsonValue,
             respPayload: input.respPayload as Prisma.InputJsonValue,
-            statusCode: input.respStatus,
-            errorMessage: input.error,
-            durationMs: input.endTime - input.startTime,
+            statusCode: input.statusCode,
+            errorMessage: input.errorMessage,
+            durationMs: input.receivedAt - input.requestedAt,
             cacheKey: respPayload.success ? requestHash : null,
             inputTokens: usage?.inputTokens,
             outputTokens: usage?.outputTokens,

app/src/server/api/routers/promptVariants.router.ts

@@ -3,7 +3,7 @@ import { createTRPCRouter, protectedProcedure, publicProcedure } from "~/server/
 import { prisma } from "~/server/db";
 import { Prisma } from "@prisma/client";
 import { generateNewCell } from "~/server/utils/generateNewCell";
-import { error, success } from "~/utils/standardResponses";
+import { error, success } from "~/utils/errorHandling/standardResponses";
 import { recordExperimentUpdated } from "~/server/utils/recordExperimentUpdated";
 import { reorderPromptVariants } from "~/server/utils/reorderPromptVariants";
 import { type PromptVariant } from "@prisma/client";

app/src/server/api/routers/scenarioVariables.router.ts

@@ -3,7 +3,7 @@ import { sql } from "kysely";
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure, publicProcedure } from "~/server/api/trpc";
 import { kysely, prisma } from "~/server/db";
-import { error, success } from "~/utils/standardResponses";
+import { error, success } from "~/utils/errorHandling/standardResponses";
 import { requireCanModifyExperiment, requireCanViewExperiment } from "~/utils/accessControl";
 
 export const scenarioVarsRouter = createTRPCRouter({

app/src/utils/errorHandling/maybeReportError.ts

@@ -1,16 +1,5 @@
 import { toast } from "~/theme/ChakraThemeProvider";
-
-export function error(message: string): { status: "error"; message: string } {
-  return {
-    status: "error",
-    message,
-  };
-}
-export function success<T>(payload: T): { status: "success"; payload: T };
-export function success(payload?: undefined): { status: "success"; payload: undefined };
-export function success<T>(payload?: T) {
-  return { status: "success", payload };
-}
+import { type error, type success } from "./standardResponses";
 
 type SuccessType<T> = ReturnType<typeof success<T>>;
 type ErrorType = ReturnType<typeof error>;

app/src/utils/errorHandling/standardResponses.ts

@@ -0,0 +1,11 @@
+export function error(message: string): { status: "error"; message: string } {
+  return {
+    status: "error",
+    message,
+  };
+}
+export function success<T>(payload: T): { status: "success"; payload: T };
+export function success(payload?: undefined): { status: "success"; payload: undefined };
+export function success<T>(payload?: T) {
+  return { status: "success", payload };
+}