braintrustdata · cpinn · Nov 19, 2025
diff --git a/packages/proxy/package.json b/packages/proxy/package.json
@@ -83,7 +83,7 @@
   "devDependencies": {
     "@types/content-disposition": "^0.5.8",
     "@types/jsonwebtoken": "^9.0.7",
-    "@types/node": "^20.10.5",
+    "@types/node": "^20.17.0",
     "@types/uuid": "^9.0.7",
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.21.0",
@@ -93,7 +93,7 @@
     "openapi-zod-client": "^1.18.3",
     "skott": "^0.35.4",
     "tsup": "^8.4.0",
-    "typescript": "5.5.4",
+    "typescript": "5.9.3",
     "vite-tsconfig-paths": "^4.3.2",
     "vitest": "^2.1.9",
     "yargs": "^17.7.2",

diff --git a/packages/proxy/scripts/sync_models.ts b/packages/proxy/scripts/sync_models.ts
@@ -394,7 +394,7 @@ JSON array only:`;
         const allGrokModels = [...grokModels, ...newModelNames];
         if (
           parsedOrder.length === allGrokModels.length &&
-          parsedOrder.every((name) => allGrokModels.includes(name)) &&
+          parsedOrder.every((name: string) => allGrokModels.includes(name)) &&
           allGrokModels.every((name) => parsedOrder.includes(name))
         ) {
           console.log("✅ Claude Code provided optimal Grok ordering");
@@ -408,7 +408,7 @@ JSON array only:`;
       } catch (parseError) {
         console.warn(
           "Failed to parse Claude's JSON response:",
-          parseError.message,
+          parseError instanceof Error ? parseError.message : String(parseError),
         );
       }
     } else {
@@ -420,7 +420,10 @@ JSON array only:`;
     );
     return getFallbackCompleteOrdering(existingModelNames, newModelNames);
   } catch (error) {
-    console.warn("Failed to get ordering from Claude:", error.message);
+    console.warn(
+      "Failed to get ordering from Claude:",
+      error instanceof Error ? error.message : String(error),
+    );
     return getFallbackCompleteOrdering(existingModelNames, newModelNames);
   }
 }

diff --git a/packages/proxy/src/PrometheusSerializer.ts b/packages/proxy/src/PrometheusSerializer.ts
@@ -32,7 +32,7 @@ import {
   Histogram,
 } from "@opentelemetry/sdk-metrics";
 import { hrTimeToMilliseconds } from "@opentelemetry/core";
-import { IResource } from "@opentelemetry/resources";
+import { Resource } from "@opentelemetry/resources";
 
 type PrometheusDataTypeLiteral =
   | "counter"
@@ -217,7 +217,16 @@ export class PrometheusSerializer {
     }
     const dataPointType = metricData.dataPointType;
 
-    name = enforcePrometheusNamingConvention(name, metricData.descriptor.type);
+    // Get instrument type from the metric data point type
+    const instrumentType =
+      metricData.dataPointType === DataPointType.SUM && metricData.isMonotonic
+        ? InstrumentType.COUNTER
+        : metricData.dataPointType === DataPointType.SUM
+          ? InstrumentType.UP_DOWN_COUNTER
+          : metricData.dataPointType === DataPointType.GAUGE
+            ? InstrumentType.GAUGE
+            : InstrumentType.HISTOGRAM;
+    name = enforcePrometheusNamingConvention(name, instrumentType);
 
     const help = `# HELP ${name} ${escapeString(
       metricData.descriptor.description || "description missing",
@@ -233,23 +242,15 @@ export class PrometheusSerializer {
       case DataPointType.GAUGE: {
         results = metricData.dataPoints
           .map((it) =>
-            this._serializeSingularDataPoint(
-              name,
-              metricData.descriptor.type,
-              it,
-            ),
+            this._serializeSingularDataPoint(name, instrumentType, it),
           )
           .join("");
         break;
       }
       case DataPointType.HISTOGRAM: {
         results = metricData.dataPoints
           .map((it) =>
-            this._serializeHistogramDataPoint(
-              name,
-              metricData.descriptor.type,
-              it,
-            ),
+            this._serializeHistogramDataPoint(name, instrumentType, it),
           )
           .join("");
         break;
@@ -343,7 +344,7 @@ export class PrometheusSerializer {
     return results;
   }
 
-  protected _serializeResource(resource: IResource): string {
+  protected _serializeResource(resource: Resource): string {
     const name = "target_info";
     const help = `# HELP ${name} Target metadata`;
     const type = `# TYPE ${name} gauge`;

diff --git a/packages/proxy/src/providers/google.test.ts b/packages/proxy/src/providers/google.test.ts
@@ -59,7 +59,7 @@
      });

      const streamedEvents = events();
      expect(streamedEvents.length).toBeGreaterThan(0);

      const hasContent = streamedEvents.some(
        (event) => event.data.choices[0]?.delta?.content !== undefined,
@@ -107,7 +107,7 @@
        },
      });

      expect(json()).toEqual({
        choices: [
          {
            finish_reason: "stop",
@@ -176,7 +176,7 @@
        },
      });

      expect(json()).toEqual({
        choices: [
          {
            finish_reason: "stop",
@@ -254,7 +254,7 @@
        body,
      });

      expect(result.json()).toMatchObject({
        id: expect.any(String),
        choices: [
          {
@@ -353,7 +353,7 @@
        body,
      });

      expect(result.json()).toMatchObject({
        id: expect.any(String),
        choices: [
          {
@@ -442,7 +442,7 @@
      });

      const response = result.json();
      expect(response).toMatchObject({
        id: expect.any(String),
        choices: expect.arrayContaining([
          expect.objectContaining({
@@ -456,8 +456,16 @@
       });
 
       // Parse and validate the response content
-      const messageContent = response.choices[0]?.message?.content;
-      if (messageContent) {
+      const choice = response.choices[0];
+      const messageContent =
+        choice &&
+        "message" in choice &&
+        typeof choice.message === "object" &&
+        choice.message !== null &&
+        "content" in choice.message
+          ? (choice.message as { content?: unknown }).content
+          : undefined;
+      if (messageContent && typeof messageContent === "string") {
         const parsed = JSON.parse(messageContent);
         expect(parsed).toHaveProperty("name");
         expect(parsed).toHaveProperty("addresses");

diff --git a/packages/proxy/src/proxy.ts b/packages/proxy/src/proxy.ts
@@ -454,6 +454,7 @@ export async function proxyV1({
   let spanType: SpanType | undefined = undefined;
   const isStreaming = !!bodyData?.stream;
 
+  // TypeScript 5.9.3: Use ReadableStream<Uint8Array> - we'll cast pipeThrough results
   let stream: ReadableStream<Uint8Array> | null = null;
   if (readFromCache) {
     const cached = await cacheGet(encryptionKey, cacheKey);
@@ -1412,7 +1413,7 @@ async function fetchModelLoop(
     }
   }
 
-  let stream = proxyResponse.stream;
+  let stream: ReadableStream<Uint8Array> | null = proxyResponse.stream;
   if (!proxyResponse.response.ok) {
     logHistogram?.({
       name: "endpoint_failures",
@@ -1444,7 +1445,8 @@ async function fetchModelLoop(
         controller.terminate();
       },
     });
-    stream = stream.pipeThrough(timingStream);
+    stream =
+      (stream.pipeThrough(timingStream) as ReadableStream<Uint8Array>) || null;
   }
   return {
     modelResponse: {
@@ -1790,7 +1792,7 @@ async function fetchOpenAIResponsesTranslate({
     body: JSON.stringify(responsesRequestFromChatCompletionsRequest(body)),
     signal,
   });
-  let stream = response.body;
+  let stream: ReadableStream<Uint8Array> | null = response.body;
   if (response.ok && stream) {
     const oaiResponse: OpenAIResponse = await collectStream(stream);
     if (oaiResponse.error) {
@@ -1809,7 +1811,11 @@ async function fetchOpenAIResponsesTranslate({
     if (body.stream) {
       // Fake stream for now, since it looks like the entire text output is sent in one chunk,
       // so we don't see any UX improvement.
-      stream = stream.pipeThrough(makeFakeOpenAIStreamTransformer());
+      // TypeScript 5.9.3: pipeThrough returns ReadableStream<Uint8Array<ArrayBufferLike>>
+      // but we need ReadableStream<Uint8Array<ArrayBuffer>>, so we cast it
+      stream = stream.pipeThrough(
+        makeFakeOpenAIStreamTransformer(),
+      ) as ReadableStream<Uint8Array>;
     }
   }
   return {
@@ -2136,10 +2142,11 @@ async function fetchOpenAI(
         },
   );
 
-  let stream = proxyResponse.body;
+  let stream: ReadableStream<Uint8Array> | null =
+    proxyResponse.body as ReadableStream<Uint8Array> | null;
   if (isManagedStructuredOutput && stream) {
     if (bodyData?.stream) {
-      stream = stream.pipeThrough(
+      const transformedStream = stream.pipeThrough(
         createEventStreamTransformer((data) => {
           const chunk: ChatCompletionChunk = JSON.parse(data);
           const choice = chunk.choices[0];
@@ -2163,34 +2170,43 @@ async function fetchOpenAI(
           };
         }),
       );
+      // TypeScript 5.9.3: pipeThrough returns ReadableStream<Uint8Array<ArrayBufferLike>>
+      // but we need ReadableStream<Uint8Array<ArrayBuffer>>, so we cast it
+      stream = (transformedStream as ReadableStream<Uint8Array>) || null;
     } else {
       const chunks: Uint8Array[] = [];
-      stream = stream.pipeThrough(
-        new TransformStream({
-          transform(chunk, _controller) {
-            chunks.push(chunk);
-          },
-          flush(controller) {
-            const data: ChatCompletion = JSON.parse(flattenChunks(chunks));
-            const choice = data.choices[0];
-            const toolCall = choice.message.tool_calls![0];
-            if (toolCall.type === "function") {
-              choice.message.content = toolCall.function.arguments;
-            }
-            choice.finish_reason = "stop";
-            delete choice.message.tool_calls;
-            controller.enqueue(new TextEncoder().encode(JSON.stringify(data)));
-            controller.terminate();
-          },
-        }),
-      );
+      stream =
+        (stream.pipeThrough(
+          new TransformStream({
+            transform(chunk, _controller) {
+              chunks.push(chunk);
+            },
+            flush(controller) {
+              const data: ChatCompletion = JSON.parse(flattenChunks(chunks));
+              const choice = data.choices[0];
+              const toolCall = choice.message.tool_calls![0];
+              if (toolCall.type === "function") {
+                choice.message.content = toolCall.function.arguments;
+              }
+              choice.finish_reason = "stop";
+              delete choice.message.tool_calls;
+              controller.enqueue(
+                new TextEncoder().encode(JSON.stringify(data)),
+              );
+              controller.terminate();
+            },
+          }),
+        ) as ReadableStream<Uint8Array>) || null;
     }
   }
 
   if (secret.type === "mistral" && stream && bodyData?.stream) {
-    stream = stream.pipeThrough(
-      createEventStreamTransformer(transformMistralThinkingChunks()),
-    );
+    // TypeScript 5.9.3: pipeThrough returns ReadableStream<Uint8Array<ArrayBufferLike>>
+    // but we need ReadableStream<Uint8Array<ArrayBuffer>>, so we cast it
+    stream =
+      (stream.pipeThrough(
+        createEventStreamTransformer(transformMistralThinkingChunks()),
+      ) as ReadableStream<Uint8Array>) || null;
   }
 
   return {

diff --git a/packages/proxy/src/util.ts b/packages/proxy/src/util.ts
@@ -1,5 +1,6 @@
 import contentDisposition from "content-disposition";
 export interface ModelResponse {
+  // TypeScript 5.9.3: Use ReadableStream<Uint8Array> - pipeThrough results are cast
   stream: ReadableStream<Uint8Array> | null;
   response: Response;
 }

diff --git a/packages/proxy/tsconfig.json b/packages/proxy/tsconfig.json
@@ -3,8 +3,10 @@
     "declaration": true,
     "lib": ["es2015", "dom"],
     "target": "ES2018",
+    "module": "esnext",
     "strict": true,
-    "moduleResolution": "node",
+    "moduleResolution": "bundler",
+    "jsx": "react",
     "baseUrl": ".",
     "paths": {
       "@lib/*": ["src/*"],
@@ -13,7 +15,8 @@
       "@types": ["types/index"]
     },
     "resolveJsonModule": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "skipLibCheck": true
   },
   "include": ["."],
   "exclude": ["node_modules/**", "**/dist/**"]

diff --git a/packages/proxy/utils/audioEncoder.ts b/packages/proxy/utils/audioEncoder.ts
@@ -21,9 +21,10 @@ export function makeWavFile(
       byte_order: "little",
       bits_per_sample: 16,
     };
+    // TypeScript 5.9.3: Int16Array<ArrayBuffer> is compatible with ArrayBufferLike
     buffers = buffers.map((buffer) =>
       floatTo16BitPCM(new Float32Array(buffer)),
-    );
+    ) as unknown as ArrayBufferLike[];
   }
 
   const dataLength = buffers.reduce((sum, b) => sum + b.byteLength, 0);
@@ -57,7 +58,8 @@ export function makeWavFile(
     ...buffers,
   ];
 
-  return new Blob(blobParts, { type: "audio/wav" });
+  // TypeScript 5.9.3: BlobPart accepts ArrayBufferLike, but type checking is stricter
+  return new Blob(blobParts as BlobPart[], { type: "audio/wav" });
 }
 
 function wavFormatCode(format: PcmAudioFormat) {
@@ -134,7 +136,7 @@ export function makeMp3File(
     bitrate,
   );
 
-  const blobParts: ArrayBuffer[] = [];
+  const blobParts: BlobPart[] = [];
 
   for (const buffer of buffers) {
     const int16Buffer =
@@ -143,11 +145,13 @@ export function makeMp3File(
         : floatTo16BitPCM(new Float32Array(buffer));
     const encoded = encoder.encodeBuffer(int16Buffer);
     if (encoded.length) {
-      blobParts.push(encoded);
+      // TypeScript 5.9.3: Uint8Array<ArrayBufferLike> is compatible with BlobPart
+      blobParts.push(encoded as BlobPart);
     }
   }
 
-  blobParts.push(encoder.flush());
+  // TypeScript 5.9.3: encoder.flush() returns Uint8Array<ArrayBufferLike> which is compatible with BlobPart
+  blobParts.push(encoder.flush() as BlobPart);
 
   return new Blob(blobParts, { type: "audio/mpeg" });
 }
diff --git a/packages/proxy/utils/encrypt.ts b/packages/proxy/utils/encrypt.ts
@@ -100,7 +100,8 @@ export async function encryptMessage(
   );
 
   return {
-    iv: arrayBufferToBase64(new Uint8Array(iv)),
+    // TypeScript 5.9.3: Uint8Array.buffer is ArrayBufferLike, need explicit conversion
+    iv: arrayBufferToBase64(iv.buffer as ArrayBuffer),
     data: arrayBufferToBase64(decoded),
   };
 }
diff --git a/packages/proxy/utils/tempCredentials.ts b/packages/proxy/utils/tempCredentials.ts
@@ -60,9 +60,8 @@ export function makeTempCredentialsJwt({
 
   // Generate 256-bit key since our cache uses AES-256.
   const keyLengthBytes = 256 / 8;
-  const cacheEncryptionKey = arrayBufferToBase64(
-    crypto.getRandomValues(new Uint8Array(keyLengthBytes)),
-  );
+  const randomValues = crypto.getRandomValues(new Uint8Array(keyLengthBytes));
+  const cacheEncryptionKey = arrayBufferToBase64(randomValues.buffer);
 
   // The partial payload is missing timestamps (`iat`, `exp`). They will be
   // populated at signing time with the `mutatePayload` option.

diff --git a/packages/proxy/utils/tests.ts b/packages/proxy/utils/tests.ts
@@ -4,6 +4,7 @@ import { TextDecoder } from "util";
 import { Buffer } from "node:buffer";
 import { proxyV1 } from "../src/proxy";
 import { getModelEndpointTypes } from "@schema";
+import type { APISecret } from "@schema";
 import { createParser, ParsedEvent, ParseEvent } from "eventsource-parser";
 
 export function createResponseStream(): [
@@ -54,6 +55,7 @@ export const getKnownApiSecrets: Parameters<
   useCache: boolean,
   authToken: string,
   model: string | null,
+  _org_name?: string,
 ) => {
   const endpointTypes = model && getModelEndpointTypes(model);
   if (!endpointTypes?.length) throw new Error(`Unknown model: ${model}`);
@@ -123,7 +125,9 @@ export const getKnownApiSecrets: Parameters<
         excludeDefaultModels: true,
       },
     },
-  ].filter((secret) => !!secret.secret && endpointTypes.includes(secret.type));
+  ].filter(
+    (secret) => !!secret.secret && endpointTypes.includes(secret.type),
+  ) as APISecret[];
 };
 
 export async function callProxyV1<Input extends object, Output extends object>({