Centralize date/time formatting utilities (#11831)

src/memory/batch-voyage.ts

@@ -59,7 +59,9 @@ function getVoyageHeaders(
 }
 
 function splitVoyageBatchRequests(requests: VoyageBatchRequest[]): VoyageBatchRequest[][] {
-  if (requests.length <= VOYAGE_BATCH_MAX_REQUESTS) return [requests];
+  if (requests.length <= VOYAGE_BATCH_MAX_REQUESTS) {
+    return [requests];
+  }
   const groups: VoyageBatchRequest[][] = [];
   for (let i = 0; i < requests.length; i += VOYAGE_BATCH_MAX_REQUESTS) {
     groups.push(requests.slice(i, i + VOYAGE_BATCH_MAX_REQUESTS));
@@ -170,7 +172,9 @@ async function readVoyageBatchError(params: {
       throw new Error(`voyage batch error file content failed: ${res.status} ${text}`);
     }
     const text = await res.text();
-    if (!text.trim()) return undefined;
+    if (!text.trim()) {
+      return undefined;
+    }
     const lines = text
       .split("\n")
       .map((line) => line.trim())
@@ -246,7 +250,9 @@ export async function runVoyageEmbeddingBatches(params: {
   concurrency: number;
   debug?: (message: string, data?: Record<string, unknown>) => void;
 }): Promise<Map<string, number[]>> {
-  if (params.requests.length === 0) return new Map();
+  if (params.requests.length === 0) {
+    return new Map();
+  }
   const groups = splitVoyageBatchRequests(params.requests);
   const byCustomId = new Map<string, number[]>();
 
@@ -307,15 +313,19 @@ export async function runVoyageEmbeddingBatches(params: {
 
     if (contentRes.body) {
       const reader = createInterface({
-        input: Readable.fromWeb(contentRes.body as any),
+        input: Readable.fromWeb(contentRes.body as unknown as import("stream/web").ReadableStream),
         terminal: false,
       });
 
       for await (const rawLine of reader) {
-        if (!rawLine.trim()) continue;
+        if (!rawLine.trim()) {
+          continue;
+        }
         const line = JSON.parse(rawLine) as VoyageBatchOutputLine;
         const customId = line.custom_id;
-        if (!customId) continue;
+        if (!customId) {
+          continue;
+        }
         remaining.delete(customId);
         if (line.error?.message) {
           errors.push(`${customId}: ${line.error.message}`);

src/memory/embeddings-voyage.test.ts

@@ -3,7 +3,9 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 vi.mock("../agents/model-auth.js", () => ({
   resolveApiKeyForProvider: vi.fn(),
   requireApiKey: (auth: { apiKey?: string; mode?: string }, provider: string) => {
-    if (auth?.apiKey) return auth.apiKey;
+    if (auth?.apiKey) {
+      return auth.apiKey;
+    }
     throw new Error(`No API key resolved for provider "${provider}" (auth mode: ${auth?.mode}).`);
   },
 }));

src/memory/embeddings-voyage.ts

@@ -12,8 +12,12 @@ const DEFAULT_VOYAGE_BASE_URL = "https://api.voyageai.com/v1";
 
 export function normalizeVoyageModel(model: string): string {
   const trimmed = model.trim();
-  if (!trimmed) return DEFAULT_VOYAGE_EMBEDDING_MODEL;
-  if (trimmed.startsWith("voyage/")) return trimmed.slice("voyage/".length);
+  if (!trimmed) {
+    return DEFAULT_VOYAGE_EMBEDDING_MODEL;
+  }
+  if (trimmed.startsWith("voyage/")) {
+    return trimmed.slice("voyage/".length);
+  }
   return trimmed;
 }
 
@@ -24,12 +28,16 @@ export async function createVoyageEmbeddingProvider(
   const url = `${client.baseUrl.replace(/\/$/, "")}/embeddings`;
 
   const embed = async (input: string[], input_type?: "query" | "document"): Promise<number[][]> => {
-    if (input.length === 0) return [];
+    if (input.length === 0) {
+      return [];
+    }
     const body: { model: string; input: string[]; input_type?: "query" | "document" } = {
       model: client.model,
       input,
     };
-    if (input_type) body.input_type = input_type;
+    if (input_type) {
+      body.input_type = input_type;
+    }
 
     const res = await fetch(url, {
       method: "POST",

src/memory/internal.ts

@@ -280,7 +280,9 @@ export async function runWithConcurrency<T>(
   tasks: Array<() => Promise<T>>,
   limit: number,
 ): Promise<T[]> {
-  if (tasks.length === 0) return [];
+  if (tasks.length === 0) {
+    return [];
+  }
   const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
   const results: T[] = Array.from({ length: tasks.length });
   let next = 0;
@@ -288,10 +290,14 @@ export async function runWithConcurrency<T>(
 
   const workers = Array.from({ length: resolvedLimit }, async () => {
     while (true) {
-      if (firstError) return;
+      if (firstError) {
+        return;
+      }
       const index = next;
       next += 1;
-      if (index >= tasks.length) return;
+      if (index >= tasks.length) {
+        return;
+      }
       try {
         results[index] = await tasks[index]();
       } catch (err) {
@@ -302,6 +308,8 @@ export async function runWithConcurrency<T>(
   });
 
   await Promise.allSettled(workers);
-  if (firstError) throw firstError;
+  if (firstError) {
+    throw firstError;
+  }
   return results;
 }

src/memory/manager.ts

@@ -1890,7 +1890,9 @@ export class MemoryIndexManager implements MemorySearchManager {
     if (!voyage) {
       return this.embedChunksInBatches(chunks);
     }
-    if (chunks.length === 0) return [];
+    if (chunks.length === 0) {
+      return [];
+    }
     const cached = this.loadEmbeddingCache(chunks.map((chunk) => chunk.hash));
     const embeddings: number[][] = Array.from({ length: chunks.length }, () => []);
     const missing: Array<{ index: number; chunk: MemoryChunk }> = [];
@@ -1905,7 +1907,9 @@ export class MemoryIndexManager implements MemorySearchManager {
       }
     }
 
-    if (missing.length === 0) return embeddings;
+    if (missing.length === 0) {
+      return embeddings;
+    }
 
     const requests: VoyageBatchRequest[] = [];
     const mapping = new Map<string, { index: number; hash: string }>();
@@ -1937,13 +1941,17 @@ export class MemoryIndexManager implements MemorySearchManager {
         }),
       fallback: async () => await this.embedChunksInBatches(chunks),
     });
-    if (Array.isArray(batchResult)) return batchResult;
+    if (Array.isArray(batchResult)) {
+      return batchResult;
+    }
     const byCustomId = batchResult;
 
     const toCache: Array<{ hash: string; embedding: number[] }> = [];
     for (const [customId, embedding] of byCustomId.entries()) {
       const mapped = mapping.get(customId);
-      if (!mapped) continue;
+      if (!mapped) {
+        continue;
+      }
       embeddings[mapped.index] = embedding;
       toCache.push({ hash: mapped.hash, embedding });
     }

src/memory/sqlite.ts

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { installProcessWarningFilter } from "../infra/warnings.js";
+import { installProcessWarningFilter } from "../infra/warning-filter.js";
 
 const require = createRequire(import.meta.url);