improvement(memory): replace manual TTL Maps with lru-cache for toolSchemaCache and effectiveEnvCache

Replaces the homegrown Map + setInterval sweep pattern with LRUCache from
the lru-cache npm package, which is the standard Node.js solution for
bounded in-process caching with TTL.

Changes per cache:
- Removes manual ToolSchemaCacheEntry / EffectiveEnvCacheEntry types
- Removes setInterval sweep timers (and the .unref() boilerplate)
- Removes the two-phase promise->value entry update inside the IIFE
- Stores Promise<T> directly — in-flight and resolved states share one type
- max: 200 (toolSchemaCache) / max: 500 (effectiveEnvCache) as hard ceilings
- TTL behaviour and concurrent-request deduplication are preserved exactly
- cache-registry .size reporting works unchanged via lru-cache's .size prop

Author: waleedlatif1

apps/sim/lib/copilot/chat/payload.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
+import { LRUCache } from 'lru-cache'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
 import { isPaid } from '@/lib/billing/plan-helpers'
 import { getToolEntry } from '@/lib/copilot/tool-executor/router'
@@ -14,20 +15,10 @@ import { getLatestVersionTools, stripVersionSuffix } from '@/tools/utils'
 const logger = createLogger('CopilotChatPayload')
 const TOOL_SCHEMA_CACHE_TTL_MS = 30_000
 
-type ToolSchemaCacheEntry = {
-  expiresAt: number
-  value?: ToolSchema[]
-  promise?: Promise<ToolSchema[]>
-}
-
-const toolSchemaCache = new Map<string, ToolSchemaCacheEntry>()
-
-setInterval(() => {
-  const now = Date.now()
-  for (const [key, entry] of toolSchemaCache) {
-    if (entry.expiresAt <= now) toolSchemaCache.delete(key)
-  }
-}, TOOL_SCHEMA_CACHE_TTL_MS).unref()
+const toolSchemaCache = new LRUCache<string, Promise<ToolSchema[]>>({
+  max: 200,
+  ttl: TOOL_SCHEMA_CACHE_TTL_MS,
+})
 
 registerCache('toolSchemaCache', () => toolSchemaCache.size)
 
@@ -84,13 +75,10 @@ export async function buildIntegrationToolSchemas(
   workspaceId?: string
 ): Promise<ToolSchema[]> {
   const cacheKey = `${userId}:${workspaceId ?? ''}:${options.schemaSurface ?? 'copilot'}`
-  const now = Date.now()
+
   const cached = toolSchemaCache.get(cacheKey)
-  if (cached?.value && cached.expiresAt > now) {
-    return cached.value.map((tool) => ({ ...tool, input_schema: { ...tool.input_schema } }))
-  }
-  if (cached?.promise) {
-    const tools = await cached.promise
+  if (cached) {
+    const tools = await cached
     return tools.map((tool) => ({ ...tool, input_schema: { ...tool.input_schema } }))
   }
 
@@ -197,18 +185,10 @@ export async function buildIntegrationToolSchemas(
       )
     }
 
-    toolSchemaCache.set(cacheKey, {
-      value: integrationTools,
-      expiresAt: Date.now() + TOOL_SCHEMA_CACHE_TTL_MS,
-    })
-
     return integrationTools
   })()
 
-  toolSchemaCache.set(cacheKey, {
-    expiresAt: now + TOOL_SCHEMA_CACHE_TTL_MS,
-    promise,
-  })
+  toolSchemaCache.set(cacheKey, promise)
 
   const integrationTools = await promise
   return integrationTools.map((tool) => ({ ...tool, input_schema: { ...tool.input_schema } }))

apps/sim/lib/environment/utils.ts

@@ -4,6 +4,7 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
 import { eq, inArray } from 'drizzle-orm'
+import { LRUCache } from 'lru-cache'
 import { decryptSecret, encryptSecret } from '@/lib/core/security/encryption'
 import {
   createWorkspaceEnvCredentials,
@@ -16,20 +17,10 @@ import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 const logger = createLogger('EnvironmentUtils')
 const EFFECTIVE_ENV_CACHE_TTL_MS = 15_000
 
-type EffectiveEnvCacheEntry = {
-  expiresAt: number
-  value?: Record<string, string>
-  promise?: Promise<Record<string, string>>
-}
-
-const effectiveEnvCache = new Map<string, EffectiveEnvCacheEntry>()
-
-setInterval(() => {
-  const now = Date.now()
-  for (const [key, entry] of effectiveEnvCache) {
-    if (!entry.promise && entry.expiresAt <= now) effectiveEnvCache.delete(key)
-  }
-}, EFFECTIVE_ENV_CACHE_TTL_MS).unref()
+const effectiveEnvCache = new LRUCache<string, Promise<Record<string, string>>>({
+  max: 500,
+  ttl: EFFECTIVE_ENV_CACHE_TTL_MS,
+})
 
 registerCache('effectiveEnvCache', () => effectiveEnvCache.size)
 
@@ -335,37 +326,24 @@ export async function getEffectiveDecryptedEnv(
   workspaceId?: string
 ): Promise<Record<string, string>> {
   const cacheKey = getEffectiveEnvCacheKey(userId, workspaceId)
-  const now = Date.now()
-  const cached = effectiveEnvCache.get(cacheKey)
 
-  if (cached?.value && cached.expiresAt > now) {
-    return { ...cached.value }
-  }
-
-  if (cached?.promise) {
-    const value = await cached.promise
+  const cached = effectiveEnvCache.get(cacheKey)
+  if (cached) {
+    const value = await cached
     return { ...value }
   }
 
   const promise = getPersonalAndWorkspaceEnv(userId, workspaceId)
-    .then(({ personalDecrypted, workspaceDecrypted }) => {
-      const value = { ...personalDecrypted, ...workspaceDecrypted }
-      effectiveEnvCache.set(cacheKey, {
-        value,
-        expiresAt: Date.now() + EFFECTIVE_ENV_CACHE_TTL_MS,
-      })
-      return value
-    })
+    .then(({ personalDecrypted, workspaceDecrypted }) => ({
+      ...personalDecrypted,
+      ...workspaceDecrypted,
+    }))
     .catch((error) => {
       effectiveEnvCache.delete(cacheKey)
       throw error
     })
 
-  effectiveEnvCache.set(cacheKey, {
-    expiresAt: now + EFFECTIVE_ENV_CACHE_TTL_MS,
-    promise,
-  })
-
+  effectiveEnvCache.set(cacheKey, promise)
   const value = await promise
   return { ...value }
 }

apps/sim/package.json

@@ -147,6 +147,7 @@
     "json5": "2.2.3",
     "jszip": "3.10.1",
     "jwt-decode": "^4.0.0",
+    "lru-cache": "11.3.6",
     "lucide-react": "^0.479.0",
     "mammoth": "^1.9.0",
     "mermaid": "11.15.0",