@bbradar/mcp 0.1.7 → 0.1.8

package/dist/server.js

@@ -29,8 +29,9 @@ const DEFAULT_FILTER_TARGET_SAMPLE_PROGRAMS = 10;
 const MAX_FILTER_TARGET_SAMPLE_PROGRAMS = 25;
 const MAX_LOCAL_EXPORT_RESOURCES = 25;
 const EXPORT_PREVIEW_LIMIT = 25;
-const STALE_PROGRAM_ID_RESOLVE_PAGES = 5;
-const STALE_PROGRAM_ID_RESOLVE_BUDGET = 5;
+const STALE_PROGRAM_ID_RESOLVE_PAGES = 1;
+const STALE_PROGRAM_ID_RESOLVE_BUDGET = 1;
+const PROGRAM_FALLBACK_CACHE_MAX_ENTRIES = 200;
 const MAX_RESOLVE_SEARCH_QUERIES = 4;
 const SDK_VERSION = "1.29.0";
 const WEB3_TAGS = ["web3", "crypto", "blockchain", "smart-contract", "smart contract", "defi", "nft", "ethereum", "solana", "solidity"];
@@ -1488,7 +1489,19 @@ function registerResources(server, client, config, exportStore) {
         }));
     });
 }
+const programFallbackCache = new Map();
+const programTargetsFallbackCaches = new WeakMap();
 async function getProgramWithIdFallback(client, config, requestedProgramId) {
+    const cachedFallback = getCachedProgramFallback(config, requestedProgramId);
+    if (cachedFallback && !isProgramIndexFallback(cachedFallback)) {
+        return {
+            api: await client.getProgram(cachedFallback.resolvedProgramId),
+            programId: cachedFallback.resolvedProgramId,
+            sourceRequests: cachedFallback.sourceRequests,
+            warnings: cachedFallback.warnings,
+            fallback: cachedFallback
+        };
+    }
     try {
         return {
             api: await client.getProgram(requestedProgramId),
@@ -1505,6 +1518,7 @@ async function getProgramWithIdFallback(client, config, requestedProgramId) {
         if (!fallback) {
             throw error;
         }
+        rememberProgramFallback(config, fallback);
         return {
             api: await client.getProgram(fallback.resolvedProgramId),
             programId: fallback.resolvedProgramId,
@@ -1515,6 +1529,30 @@ async function getProgramWithIdFallback(client, config, requestedProgramId) {
     }
 }
 async function runProgramIdTool(client, config, requestedProgramId, callback, indexFallbackCallback) {
+    const cachedFallback = getCachedProgramFallback(config, requestedProgramId);
+    if (cachedFallback) {
+        if (isProgramIndexFallback(cachedFallback) && indexFallbackCallback) {
+            const payload = await indexFallbackCallback(cachedFallback);
+            return withProgramIndexFallbackMetadata(payload, cachedFallback);
+        }
+        try {
+            const payload = await callback(cachedFallback.resolvedProgramId);
+            return withProgramIdFallbackMetadata(payload, cachedFallback);
+        }
+        catch (cachedFallbackError) {
+            if (!isProgramNotFoundError(cachedFallbackError) || !indexFallbackCallback) {
+                throw cachedFallbackError;
+            }
+            const indexFallback = createProgramIndexFallbackFromStaleResolution(cachedFallback, requestedProgramId, cachedFallbackError) ??
+                (await resolveIndexedProgramId(client, config, cachedFallback.resolvedProgramId, cachedFallbackError));
+            if (!indexFallback) {
+                throw cachedFallbackError;
+            }
+            rememberProgramFallback(config, indexFallback);
+            const payload = await indexFallbackCallback(indexFallback);
+            return withProgramIndexFallbackMetadata(payload, indexFallback);
+        }
+    }
     try {
         return await callback(requestedProgramId);
     }
@@ -1531,10 +1569,12 @@ async function runProgramIdTool(client, config, requestedProgramId, callback, in
             if (!indexFallback) {
                 throw error;
             }
+            rememberProgramFallback(config, indexFallback);
             const payload = await indexFallbackCallback(indexFallback);
             return withProgramIndexFallbackMetadata(payload, indexFallback);
         }
         try {
+            rememberProgramFallback(config, fallback);
             const payload = await callback(fallback.resolvedProgramId);
             return withProgramIdFallbackMetadata(payload, fallback);
         }
@@ -1542,21 +1582,107 @@ async function runProgramIdTool(client, config, requestedProgramId, callback, in
             if (!isProgramNotFoundError(fallbackError) || !indexFallbackCallback) {
                 throw fallbackError;
             }
-            const indexFallback = await resolveIndexedProgramId(client, config, fallback.resolvedProgramId, fallbackError);
+            const indexFallback = createProgramIndexFallbackFromStaleResolution(fallback, requestedProgramId, fallbackError) ??
+                (await resolveIndexedProgramId(client, config, fallback.resolvedProgramId, fallbackError));
             if (!indexFallback) {
                 throw fallbackError;
             }
-            const combinedFallback = {
-                ...indexFallback,
-                requestedProgramId,
-                sourceRequests: [...fallback.sourceRequests, ...indexFallback.sourceRequests],
-                warnings: uniqueStrings([...fallback.warnings, ...indexFallback.warnings])
-            };
+            const combinedFallback = indexFallback.requestedProgramId === requestedProgramId
+                ? indexFallback
+                : {
+                    ...indexFallback,
+                    requestedProgramId,
+                    sourceRequests: [...fallback.sourceRequests, ...indexFallback.sourceRequests],
+                    warnings: uniqueStrings([...fallback.warnings, ...indexFallback.warnings])
+                };
+            rememberProgramFallback(config, combinedFallback);
             const payload = await indexFallbackCallback(combinedFallback);
             return withProgramIndexFallbackMetadata(payload, combinedFallback);
         }
     }
 }
+function getCachedProgramFallback(config, requestedProgramId) {
+    if (config.cacheTtlMs <= 0 || config.cacheMaxEntries <= 0) {
+        return undefined;
+    }
+    const key = programFallbackCacheKey(config, requestedProgramId);
+    const cached = programFallbackCache.get(key);
+    if (!cached) {
+        return undefined;
+    }
+    if (cached.expiresAt <= Date.now()) {
+        programFallbackCache.delete(key);
+        return undefined;
+    }
+    return cloneProgramFallbackForRequest(cached.fallback, requestedProgramId, true);
+}
+function rememberProgramFallback(config, fallback) {
+    if (config.cacheTtlMs <= 0 || config.cacheMaxEntries <= 0) {
+        return;
+    }
+    pruneProgramFallbackCache();
+    const key = programFallbackCacheKey(config, fallback.requestedProgramId);
+    programFallbackCache.set(key, {
+        expiresAt: Date.now() + config.cacheTtlMs,
+        fallback: cloneProgramFallbackForRequest(fallback, fallback.requestedProgramId, false)
+    });
+    if (programFallbackCache.size > PROGRAM_FALLBACK_CACHE_MAX_ENTRIES) {
+        const oldestKey = programFallbackCache.keys().next().value;
+        if (oldestKey) {
+            programFallbackCache.delete(oldestKey);
+        }
+    }
+}
+function pruneProgramFallbackCache() {
+    const now = Date.now();
+    for (const [key, cached] of programFallbackCache) {
+        if (cached.expiresAt <= now) {
+            programFallbackCache.delete(key);
+        }
+    }
+}
+function programFallbackCacheKey(config, requestedProgramId) {
+    return `${config.apiBaseUrl}\n${normalizeTag(requestedProgramId)}`;
+}
+function cloneProgramFallbackForRequest(fallback, requestedProgramId, fromCache) {
+    const warnings = fromCache
+        ? uniqueStrings([...fallback.warnings, `Reused cached program_id resolution for ${requestedProgramId}.`])
+        : [...fallback.warnings];
+    const cloned = {
+        ...fallback,
+        requestedProgramId,
+        warnings,
+        sourceRequests: [...fallback.sourceRequests],
+        resolution: { ...fallback.resolution }
+    };
+    if (isProgramIndexFallback(fallback)) {
+        const indexClone = {
+            ...cloned,
+            program: { ...fallback.program }
+        };
+        return indexClone;
+    }
+    return cloned;
+}
+function isProgramIndexFallback(fallback) {
+    return readObject(fallback.program) !== undefined;
+}
+function createProgramIndexFallbackFromStaleResolution(fallback, requestedProgramId, detailError) {
+    const match = selectProgramIndexFallbackMatch(fallback.resolvedProgramId, fallback.resolution);
+    if (!match) {
+        return undefined;
+    }
+    const detailApiError = detailError instanceof BBRadarApiError ? detailError : undefined;
+    const indexWarning = `program_id ${fallback.resolvedProgramId} exists in the BBRadar program index, but the per-program detail endpoint returned 404.`;
+    return {
+        ...fallback,
+        requestedProgramId,
+        staleRequestId: fallback.staleRequestId ?? detailApiError?.requestId,
+        staleUpstreamRequestId: fallback.staleUpstreamRequestId ?? detailApiError?.upstreamRequestId,
+        warnings: uniqueStrings([...fallback.warnings, indexWarning]),
+        program: match.program
+    };
+}
 async function resolveIndexedProgramId(client, config, requestedProgramId, staleError) {
     const query = programSearchText(requestedProgramId);
     if (query.length < 2) {
@@ -2862,6 +2988,10 @@ async function getProgramTargetsExportFallbackPayload(client, input, programId)
     });
 }
 async function fetchProgramTargetsWithEndpointFallback(client, programId) {
+    const cachedLookup = getCachedProgramTargetsFallback(client, programId);
+    if (cachedLookup) {
+        return cachedLookup;
+    }
     try {
         const api = await client.getProgramTargets(programId);
         const data = readObject(api.data);
@@ -2894,9 +3024,86 @@ async function fetchProgramTargetsWithEndpointFallback(client, programId) {
         if (!isProgramNotFoundError(error)) {
             throw error;
         }
-        return fetchProgramTargetsFromExportFallback(client, programId);
+        const lookup = await fetchProgramTargetsFromExportFallback(client, programId);
+        rememberProgramTargetsFallback(client, programId, lookup);
+        return lookup;
+    }
+}
+function getCachedProgramTargetsFallback(client, programId) {
+    const diagnostics = client.diagnostics();
+    if (!diagnostics.response_cache.enabled) {
+        return undefined;
+    }
+    const cache = programTargetsFallbackCaches.get(client);
+    const key = programTargetsFallbackCacheKey(programId);
+    const cached = cache?.get(key);
+    if (!cached) {
+        return undefined;
+    }
+    if (cached.expiresAt <= Date.now()) {
+        cache?.delete(key);
+        return undefined;
+    }
+    return {
+        ...cached.lookup,
+        cache: readObject(stripUndefined({
+            ...(cached.lookup.cache ?? {}),
+            hit: true,
+            expires_at: new Date(cached.expiresAt).toISOString()
+        })),
+        sourceRequests: cached.lookup.sourceRequests.map((request) => ({
+            ...request,
+            cache_hit: true,
+            cache_expires_at: new Date(cached.expiresAt).toISOString()
+        })),
+        warnings: uniqueStrings([...cached.lookup.warnings, `Reused cached target fallback for ${programId}.`])
+    };
+}
+function rememberProgramTargetsFallback(client, programId, lookup) {
+    const diagnostics = client.diagnostics();
+    if (!diagnostics.response_cache.enabled || lookup.unavailable) {
+        return;
+    }
+    const cache = programTargetsFallbackCacheForClient(client);
+    pruneProgramTargetsFallbackCache(cache);
+    const ttlMs = cacheTtlMsFromDiagnostics(diagnostics.response_cache);
+    if (ttlMs <= 0) {
+        return;
+    }
+    cache.set(programTargetsFallbackCacheKey(programId), {
+        expiresAt: Date.now() + ttlMs,
+        lookup
+    });
+    if (cache.size > PROGRAM_FALLBACK_CACHE_MAX_ENTRIES) {
+        const oldestKey = cache.keys().next().value;
+        if (oldestKey) {
+            cache.delete(oldestKey);
+        }
+    }
+}
+function programTargetsFallbackCacheForClient(client) {
+    const existing = programTargetsFallbackCaches.get(client);
+    if (existing) {
+        return existing;
+    }
+    const cache = new Map();
+    programTargetsFallbackCaches.set(client, cache);
+    return cache;
+}
+function pruneProgramTargetsFallbackCache(cache) {
+    const now = Date.now();
+    for (const [key, cached] of cache) {
+        if (cached.expiresAt <= now) {
+            cache.delete(key);
+        }
     }
 }
+function programTargetsFallbackCacheKey(programId) {
+    return normalizeTag(programId);
+}
+function cacheTtlMsFromDiagnostics(cache) {
+    return cache.enabled ? cache.ttl_ms : 0;
+}
 async function fetchProgramTargetsFromExportFallback(client, programId) {
     try {
         const api = await client.exportTargets({