@vellumai/assistant 0.5.16 → 0.6.1

package/src/memory/qdrant-client.ts

@@ -20,7 +20,7 @@ export interface QdrantClientConfig {
 }
 
 export interface QdrantPointPayload {
-  target_type: "segment" | "item" | "summary" | "media";
+  target_type: "segment" | "item" | "summary" | "media" | "graph_node";
   target_id: string;
   text: string;
   kind?: string;
@@ -47,14 +47,14 @@ let _instance: VellumQdrantClient | null = null;
 export function getQdrantClient(): VellumQdrantClient {
   if (!_instance) {
     throw new Error(
-      "Qdrant client not initialized. Call initQdrantClient() first.",
+      "Qdrant client not initialized. Call initQdrantClient() first."
     );
   }
   return _instance;
 }
 
 export function initQdrantClient(
-  config: QdrantClientConfig,
+  config: QdrantClientConfig
 ): VellumQdrantClient {
   _instance = new VellumQdrantClient(config);
   return _instance;
@@ -125,7 +125,7 @@ export class VellumQdrantClient {
                 currentSize,
                 expectedSize: this.vectorSize,
               },
-              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed.",
+              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed."
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -138,7 +138,7 @@ export class VellumQdrantClient {
                 expectedSize: this.vectorSize,
                 modelMismatch,
               },
-              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand.",
+              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand."
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -152,7 +152,7 @@ export class VellumQdrantClient {
         } catch (err) {
           log.warn(
             { err },
-            "Failed to verify collection compatibility, assuming compatible",
+            "Failed to verify collection compatibility, assuming compatible"
           );
           if (await this.ensurePayloadIndexesSafe()) {
             this.collectionReady = true;
@@ -166,7 +166,7 @@ export class VellumQdrantClient {
 
     log.info(
       { collection: this.collection, vectorSize: this.vectorSize },
-      "Creating Qdrant collection with named vectors (dense + sparse)",
+      "Creating Qdrant collection with named vectors (dense + sparse)"
     );
 
     try {
@@ -222,7 +222,7 @@ export class VellumQdrantClient {
       this.collectionReady = true;
       log.info(
         { collection: this.collection },
-        "Qdrant collection created with payload indexes",
+        "Qdrant collection created with payload indexes"
       );
     }
 
@@ -230,11 +230,11 @@ export class VellumQdrantClient {
   }
 
   async upsert(
-    targetType: "segment" | "item" | "summary" | "media",
+    targetType: QdrantPointPayload["target_type"],
     targetId: string,
     vector: number[],
     payload: Omit<QdrantPointPayload, "target_type" | "target_id">,
-    sparseVector?: QdrantSparseVector,
+    sparseVector?: QdrantSparseVector
   ): Promise<string> {
     await this.ensureCollection();
 
@@ -289,7 +289,7 @@ export class VellumQdrantClient {
   async search(
     vector: number[],
     limit: number,
-    filter?: Record<string, unknown>,
+    filter?: Record<string, unknown>
   ): Promise<QdrantSearchResult[]> {
     await this.ensureCollection();
 
@@ -317,7 +317,7 @@ export class VellumQdrantClient {
     return results.map((result) => ({
       id: typeof result.id === "string" ? result.id : String(result.id),
       score: result.score,
-      payload: result.payload as unknown as QdrantPointPayload,
+      payload: (result.payload as unknown) as QdrantPointPayload,
     }));
   }
 
@@ -326,7 +326,7 @@ export class VellumQdrantClient {
     limit: number,
     targetTypes: Array<"segment" | "item" | "summary" | "media">,
     excludeMessageIds?: string[],
-    scopeIds?: string[],
+    scopeIds?: string[]
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
@@ -403,7 +403,7 @@ export class VellumQdrantClient {
     const queryParams = {
       prefetch: [
         {
-          query: denseVector as unknown as number[],
+          query: (denseVector as unknown) as number[],
           using: "dense",
           limit: effectivePrefetchLimit,
         },
@@ -438,7 +438,7 @@ export class VellumQdrantClient {
     return (results.points ?? []).map((point) => ({
       id: typeof point.id === "string" ? point.id : String(point.id),
       score: point.score ?? 0,
-      payload: point.payload as unknown as QdrantPointPayload,
+      payload: (point.payload as unknown) as QdrantPointPayload,
     }));
   }
 
@@ -469,6 +469,33 @@ export class VellumQdrantClient {
     }
   }
 
+  /**
+   * Delete all vectors matching a given target_type (bulk cleanup).
+   */
+  async deleteByTargetType(targetType: string): Promise<void> {
+    await this.ensureCollection();
+
+    const doDelete = () =>
+      this.client.delete(this.collection, {
+        wait: true,
+        filter: {
+          must: [{ key: "target_type", match: { value: targetType } }],
+        },
+      });
+
+    try {
+      await doDelete();
+    } catch (err) {
+      if (this.isCollectionMissing(err)) {
+        this.collectionReady = false;
+        await this.ensureCollection();
+        await doDelete();
+      } else {
+        throw err;
+      }
+    }
+  }
+
   async count(): Promise<number> {
     await this.ensureCollection();
 
@@ -498,7 +525,7 @@ export class VellumQdrantClient {
     } catch (err) {
       log.warn(
         { err, collection: this.collection },
-        "Failed to delete Qdrant collection",
+        "Failed to delete Qdrant collection"
       );
       return false;
     }
@@ -615,7 +642,7 @@ export class VellumQdrantClient {
 
   private async findByTarget(
     targetType: string,
-    targetId: string,
+    targetId: string
   ): Promise<string | null> {
     try {
       const results = await this.client.scroll(this.collection, {

package/src/memory/schema/conversations.ts

@@ -30,9 +30,11 @@ export const conversations = sqliteTable(
     forkParentMessageId: text("fork_parent_message_id"),
     isAutoTitle: integer("is_auto_title").notNull().default(1),
     scheduleJobId: text("schedule_job_id"),
+    lastMessageAt: integer("last_message_at"),
   },
   (table) => [
     index("idx_conversations_updated_at").on(table.updatedAt),
+    index("idx_conversations_last_message_at").on(table.lastMessageAt),
     index("idx_conversations_conversation_type").on(table.conversationType),
     index("idx_conversations_fork_parent_conversation_id").on(
       table.forkParentConversationId,
@@ -109,6 +111,18 @@ export const messageAttachments = sqliteTable("message_attachments", {
   createdAt: integer("created_at").notNull(),
 });
 
+export const conversationGraphMemoryState = sqliteTable(
+  "conversation_graph_memory_state",
+  {
+    conversationId: text("conversation_id")
+      .primaryKey()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    stateJson: text("state_json").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
 export const channelInboundEvents = sqliteTable("channel_inbound_events", {
   id: text("id").primaryKey(),
   sourceChannel: text("source_channel").notNull(),

package/src/memory/schema/index.ts

@@ -4,6 +4,7 @@ export * from "./conversations.js";
 export * from "./guardian.js";
 export * from "./infrastructure.js";
 export * from "./memory-core.js";
+export * from "./memory-graph.js";
 export * from "./notifications.js";
 export * from "./oauth.js";
 export * from "./tasks.js";

package/src/memory/schema/infrastructure.ts

@@ -25,6 +25,9 @@ export const cronJobs = sqliteTable("cron_jobs", {
   routingHintsJson: text("routing_hints_json").notNull().default("{}"),
   status: text("status").notNull().default("active"), // 'active' | 'firing' | 'fired' | 'cancelled'
   quiet: integer("quiet", { mode: "boolean" }).notNull().default(false), // suppress completion notifications
+  reuseConversation: integer("reuse_conversation", { mode: "boolean" })
+    .notNull()
+    .default(false), // reuse the same conversation across runs
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
 });
@@ -118,7 +121,10 @@ export const llmRequestLogs = sqliteTable(
     responsePayload: text("response_payload").notNull(),
     createdAt: integer("created_at").notNull(),
   },
-  (table) => [index("idx_llm_request_logs_message_id").on(table.messageId)],
+  (table) => [
+    index("idx_llm_request_logs_message_id").on(table.messageId),
+    index("idx_llm_request_logs_created_at").on(table.createdAt),
+  ],
 );
 
 export const memoryRecallLogs = sqliteTable(
@@ -144,6 +150,7 @@ export const memoryRecallLogs = sqliteTable(
     topCandidatesJson: text("top_candidates_json").notNull(),
     injectedText: text("injected_text"),
     reason: text("reason"),
+    queryContext: text("query_context"),
     createdAt: integer("created_at").notNull(),
   },
   (table) => [

package/src/memory/schema/memory-core.ts

@@ -2,7 +2,6 @@ import {
   blob,
   index,
   integer,
-  real,
   sqliteTable,
   text,
   uniqueIndex,
@@ -32,56 +31,6 @@ export const memorySegments = sqliteTable(
   (table) => [index("idx_memory_segments_scope_id").on(table.scopeId)],
 );
 
-export const memoryItems = sqliteTable(
-  "memory_items",
-  {
-    id: text("id").primaryKey(),
-    kind: text("kind").notNull(),
-    subject: text("subject").notNull(),
-    statement: text("statement").notNull(),
-    status: text("status").notNull(),
-    confidence: real("confidence").notNull(),
-    importance: real("importance"),
-    accessCount: integer("access_count").notNull().default(0),
-    fingerprint: text("fingerprint").notNull(),
-    verificationState: text("verification_state")
-      .notNull()
-      .default("assistant_inferred"),
-    scopeId: text("scope_id").notNull().default("default"),
-    firstSeenAt: integer("first_seen_at").notNull(),
-    lastSeenAt: integer("last_seen_at").notNull(),
-    lastUsedAt: integer("last_used_at"),
-    validFrom: integer("valid_from"),
-    invalidAt: integer("invalid_at"),
-    supersedes: text("supersedes"),
-    supersededBy: text("superseded_by"),
-    overrideConfidence: text("override_confidence").default("inferred"),
-    sourceType: text("source_type").notNull().default("extraction"),
-    sourceMessageRole: text("source_message_role"),
-  },
-  (table) => [
-    index("idx_memory_items_scope_id").on(table.scopeId),
-    index("idx_memory_items_fingerprint").on(table.fingerprint),
-  ],
-);
-
-export const memoryItemSources = sqliteTable(
-  "memory_item_sources",
-  {
-    memoryItemId: text("memory_item_id")
-      .notNull()
-      .references(() => memoryItems.id, { onDelete: "cascade" }),
-    messageId: text("message_id")
-      .notNull()
-      .references(() => messages.id, { onDelete: "cascade" }),
-    evidence: text("evidence"),
-    createdAt: integer("created_at").notNull(),
-  },
-  (table) => [
-    index("idx_memory_item_sources_memory_item_id").on(table.memoryItemId),
-  ],
-);
-
 export const memorySummaries = sqliteTable(
   "memory_summaries",
   {

package/src/memory/schema/memory-graph.ts

@@ -0,0 +1,154 @@
+import {
+  blob,
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+// ---------------------------------------------------------------------------
+// Memory Graph — Drizzle ORM schema
+// ---------------------------------------------------------------------------
+
+export const memoryGraphNodes = sqliteTable(
+  "memory_graph_nodes",
+  {
+    id: text("id").primaryKey(),
+
+    /** First-person prose — how the assistant naturally remembers this. */
+    content: text("content").notNull(),
+    /** Memory type: episodic, semantic, procedural, emotional, prospective, behavioral, narrative, shared. */
+    type: text("type").notNull(),
+
+    // -- Temporal --
+    /** Epoch ms. Hour/dayOfWeek/month derived at query time via Date. */
+    created: integer("created").notNull(),
+    /** Epoch ms. Decay-rate modifier only — NOT a retrieval signal. */
+    lastAccessed: integer("last_accessed").notNull(),
+    /** Epoch ms of last consolidation pass. */
+    lastConsolidated: integer("last_consolidated").notNull(),
+    /** Epoch ms of the event this memory describes (null for non-event memories). */
+    eventDate: integer("event_date"),
+
+    // -- Energy --
+    /** JSON-serialized EmotionalCharge object. Read/written atomically. */
+    emotionalCharge: text("emotional_charge").notNull(),
+    /** vivid | clear | faded | gist | gone */
+    fidelity: text("fidelity").notNull().default("vivid"),
+    /** 0–1. How sure the assistant is this is accurate. */
+    confidence: real("confidence").notNull(),
+    /** 0–1. How important. Subject to Ebbinghaus decay. */
+    significance: real("significance").notNull(),
+
+    // -- Reinforcement --
+    /** Resistance to decay. Grows ×1.5 per reinforcement. */
+    stability: real("stability").notNull().default(14),
+    /** How many times confirmed/reinforced. */
+    reinforcementCount: integer("reinforcement_count").notNull().default(0),
+    /** Epoch ms. */
+    lastReinforced: integer("last_reinforced").notNull(),
+
+    // -- Provenance --
+    /** JSON array of conversation IDs. */
+    sourceConversations: text("source_conversations").notNull().default("[]"),
+    /** direct | inferred | observed | told-by-other */
+    sourceType: text("source_type").notNull().default("inferred"),
+
+    // -- Narrative --
+    narrativeRole: text("narrative_role"),
+    partOfStory: text("part_of_story"),
+
+    /** Memory scope for multi-scope isolation. */
+    scopeId: text("scope_id").notNull().default("default"),
+
+    /** JSON array of ImageRef objects — images attached to this memory. */
+    imageRefs: text("image_refs"),
+  },
+  (table) => [
+    index("idx_graph_nodes_scope_id").on(table.scopeId),
+    index("idx_graph_nodes_type").on(table.type),
+    index("idx_graph_nodes_fidelity").on(table.fidelity),
+    index("idx_graph_nodes_created").on(table.created),
+    index("idx_graph_nodes_significance").on(table.significance),
+    index("idx_graph_nodes_event_date").on(table.eventDate),
+  ],
+);
+
+export const memoryGraphEdges = sqliteTable(
+  "memory_graph_edges",
+  {
+    id: text("id").primaryKey(),
+    sourceNodeId: text("source_node_id")
+      .notNull()
+      .references(() => memoryGraphNodes.id, { onDelete: "cascade" }),
+    targetNodeId: text("target_node_id")
+      .notNull()
+      .references(() => memoryGraphNodes.id, { onDelete: "cascade" }),
+    /** caused-by | reminds-of | contradicts | depends-on | part-of | supersedes | resolved-by */
+    relationship: text("relationship").notNull(),
+    /** Connection strength 0–1. */
+    weight: real("weight").notNull().default(1.0),
+    /** Epoch ms. */
+    created: integer("created").notNull(),
+  },
+  (table) => [
+    index("idx_graph_edges_source").on(table.sourceNodeId),
+    index("idx_graph_edges_target").on(table.targetNodeId),
+  ],
+);
+
+export const memoryGraphTriggers = sqliteTable(
+  "memory_graph_triggers",
+  {
+    id: text("id").primaryKey(),
+    nodeId: text("node_id")
+      .notNull()
+      .references(() => memoryGraphNodes.id, { onDelete: "cascade" }),
+    /** temporal | semantic | event */
+    type: text("type").notNull(),
+
+    // -- Temporal --
+    schedule: text("schedule"),
+
+    // -- Semantic --
+    condition: text("condition"),
+    /** Pre-computed embedding stored as binary blob. */
+    conditionEmbedding: blob("condition_embedding"),
+    /** Cosine similarity threshold (0–1). */
+    threshold: real("threshold"),
+
+    // -- Event --
+    /** Epoch ms of the event date. */
+    eventDate: integer("event_date"),
+    rampDays: integer("ramp_days"),
+    followUpDays: integer("follow_up_days"),
+
+    // -- State --
+    recurring: integer("recurring", { mode: "boolean" })
+      .notNull()
+      .default(false),
+    consumed: integer("consumed", { mode: "boolean" }).notNull().default(false),
+    cooldownMs: integer("cooldown_ms"),
+    lastFired: integer("last_fired"),
+  },
+  (table) => [
+    index("idx_graph_triggers_node_id").on(table.nodeId),
+    index("idx_graph_triggers_type").on(table.type),
+  ],
+);
+
+export const memoryGraphNodeEdits = sqliteTable(
+  "memory_graph_node_edits",
+  {
+    id: text("id").primaryKey(),
+    nodeId: text("node_id")
+      .notNull()
+      .references(() => memoryGraphNodes.id, { onDelete: "cascade" }),
+    previousContent: text("previous_content").notNull(),
+    newContent: text("new_content").notNull(),
+    source: text("source").notNull(),
+    conversationId: text("conversation_id"),
+    created: integer("created").notNull(),
+  },
+);

package/src/memory/search/semantic.ts

@@ -8,15 +8,42 @@ import type {
   QdrantSparseVector,
 } from "../qdrant-client.js";
 import { getQdrantClient } from "../qdrant-client.js";
-import {
-  conversations,
-  memoryItems,
-  memoryItemSources,
-  memorySegments,
-  memorySummaries,
-} from "../schema.js";
-import { computeRecencyScore } from "./ranking.js";
-import type { Candidate } from "./types.js";
+import { conversations, memorySegments, memorySummaries } from "../schema.js";
+// ── Types (inlined from deleted types.ts) ──────────────────────────
+
+type CandidateType = "segment" | "item" | "summary" | "media";
+
+export interface Candidate {
+  key: string;
+  type: CandidateType;
+  id: string;
+  source: "semantic";
+  text: string;
+  kind: string;
+  modality?: "text" | "image" | "audio" | "video";
+  conversationId?: string;
+  messageId?: string;
+  confidence: number;
+  importance: number;
+  createdAt: number;
+  semantic: number;
+  recency: number;
+  finalScore: number;
+}
+
+// ── Recency scoring (inlined from deleted ranking.ts) ──────────────
+
+/**
+ * Logarithmic recency decay (ACT-R inspired).
+ *
+ *   1 day -> 0.50, 7 days -> 0.25, 30 days -> 0.17
+ *   90 days -> 0.15, 1 year -> 0.12, 2 years -> 0.10
+ */
+function computeRecencyScore(createdAt: number): number {
+  const ageMs = Math.max(0, Date.now() - createdAt);
+  const ageDays = ageMs / (24 * 60 * 60 * 1000);
+  return 1 / (1 + Math.log2(1 + ageDays));
+}
 
 const _log = getLogger("semantic-search");
 
@@ -27,7 +54,7 @@ export async function semanticSearch(
   limit: number,
   excludedMessageIds: string[] = [],
   scopeIds?: string[],
-  sparseVector?: QdrantSparseVector,
+  sparseVector?: QdrantSparseVector
 ): Promise<Candidate[]> {
   if (limit <= 0) return [];
 
@@ -52,31 +79,28 @@ export async function semanticSearch(
         filter,
         limit: fetchLimit,
         prefetchLimit: fetchLimit,
-      }),
+      })
     );
   } else {
     results = await withQdrantBreaker(() =>
       qdrant.searchWithFilter(
         queryVector,
         fetchLimit,
-        ["item", "summary", "segment", "media"],
+        ["summary", "segment", "media"],
         excludedMessageIds,
-        scopeIds,
-      ),
+        scopeIds
+      )
     );
   }
 
   const db = getDb();
 
   // Batch-fetch all backing records upfront to avoid N+1 queries per result
-  const itemTargetIds: string[] = [];
   const summaryTargetIds: string[] = [];
   const segmentTargetIds: string[] = [];
   const mediaConversationIds: string[] = [];
   for (const r of results) {
-    if (r.payload.target_type === "item")
-      itemTargetIds.push(r.payload.target_id);
-    else if (r.payload.target_type === "summary")
+    if (r.payload.target_type === "summary")
       summaryTargetIds.push(r.payload.target_id);
     else if (r.payload.target_type === "segment")
       segmentTargetIds.push(r.payload.target_id);
@@ -84,33 +108,6 @@ export async function semanticSearch(
       mediaConversationIds.push(r.payload.conversation_id);
   }
 
-  const itemsMap = new Map<string, typeof memoryItems.$inferSelect>();
-  if (itemTargetIds.length > 0) {
-    const allItems = db
-      .select()
-      .from(memoryItems)
-      .where(inArray(memoryItems.id, itemTargetIds))
-      .all();
-    for (const item of allItems) itemsMap.set(item.id, item);
-  }
-
-  const sourcesMap = new Map<string, string[]>();
-  if (itemTargetIds.length > 0) {
-    const allSources = db
-      .select({
-        memoryItemId: memoryItemSources.memoryItemId,
-        messageId: memoryItemSources.messageId,
-      })
-      .from(memoryItemSources)
-      .where(inArray(memoryItemSources.memoryItemId, itemTargetIds))
-      .all();
-    for (const s of allSources) {
-      const existing = sourcesMap.get(s.memoryItemId);
-      if (existing) existing.push(s.messageId);
-      else sourcesMap.set(s.memoryItemId, [s.messageId]);
-    }
-  }
-
   const summariesMap = new Map<string, typeof memorySummaries.$inferSelect>();
   if (scopeIds && summaryTargetIds.length > 0) {
     const allSummaries = db
@@ -148,8 +145,6 @@ export async function semanticSearch(
     for (const row of rows) mediaScopeMap.set(row.id, row.memoryScopeId);
   }
 
-  const excludedSet =
-    excludedMessageIds.length > 0 ? new Set(excludedMessageIds) : null;
 
   const candidates: Candidate[] = [];
   for (const result of results) {
@@ -159,29 +154,8 @@ export async function semanticSearch(
     const createdAt = payload.created_at ?? Date.now();
 
     if (payload.target_type === "item") {
-      const item = itemsMap.get(payload.target_id);
-      if (!item || item.status !== "active" || item.invalidAt != null) continue;
-      if (scopeIds && !scopeIds.includes(item.scopeId)) continue;
-      const sources = sourcesMap.get(payload.target_id);
-      if (!sources || sources.length === 0) continue;
-      if (excludedSet) {
-        const hasNonExcluded = sources.some((msgId) => !excludedSet.has(msgId));
-        if (!hasNonExcluded) continue;
-      }
-      candidates.push({
-        key: `item:${payload.target_id}`,
-        type: "item",
-        id: payload.target_id,
-        source: "semantic",
-        text: `${item.subject}: ${item.statement}`,
-        kind: item.kind,
-        confidence: item.confidence,
-        importance: item.importance ?? 0.5,
-        createdAt: item.lastSeenAt,
-        semantic,
-        recency: computeRecencyScore(item.lastSeenAt),
-        finalScore: 0,
-      });
+      // Legacy item vectors — skip (table dropped, Qdrant cleanup pending)
+      continue;
     } else if (payload.target_type === "summary") {
       if (scopeIds) {
         const summary = summariesMap.get(payload.target_id);
@@ -284,33 +258,15 @@ export async function semanticSearch(
  */
 function buildHybridFilter(
   excludeMessageIds: string[],
-  scopeIds?: string[],
+  scopeIds?: string[]
 ): Record<string, unknown> {
   const mustConditions: Array<Record<string, unknown>> = [
     {
       key: "target_type",
-      match: { any: ["item", "summary", "segment", "media"] },
+      match: { any: ["summary", "segment", "media"] },
     },
   ];
 
-  if (excludeMessageIds.length > 0) {
-    // Only require status=active for items; segments and summaries don't have a status field
-    mustConditions.push({
-      should: [
-        {
-          must: [
-            { key: "target_type", match: { value: "item" } },
-            { key: "status", match: { value: "active" } },
-          ],
-        },
-        {
-          key: "target_type",
-          match: { any: ["segment", "summary", "media"] },
-        },
-      ],
-    });
-  }
-
   // Scope filtering: accept points whose memory_scope_id matches one of the
   // allowed scopes, OR points that lack the field entirely (legacy data).
   // Post-query DB filtering remains as defense-in-depth for legacy points.
@@ -346,6 +302,6 @@ export function mapCosineToUnit(value: number): number {
 export function isQdrantConnectionError(err: unknown): boolean {
   if (!(err instanceof Error)) return false;
   return /ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|fetch failed/i.test(
-    err.message,
+    err.message
   );
 }