@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/sandbox/QuickJSSandbox.js

@@ -1,7 +1,9 @@
 import { getQuickJS } from 'quickjs-emscripten';
 import { SANDBOX_HELPER_SOURCE } from '../sandbox/SandboxHelpers.js';
-const DEFAULT_TIMEOUT_MS = 1_000;
-const DEFAULT_MEMORY_LIMIT_BYTES = 8 * 1024 * 1024;
+import { SANDBOX_EXEC_TIMEOUT_MS, SANDBOX_MEMORY_LIMIT_MB } from '../../constants.js';
+const DEFAULT_TIMEOUT_MS = SANDBOX_EXEC_TIMEOUT_MS;
+const DEFAULT_MEMORY_LIMIT_BYTES = SANDBOX_MEMORY_LIMIT_MB * 1024 * 1024;
+const DEFAULT_MAX_BRIDGE_CALLS = 10;
 function marshalToQuickJS(ctx, value) {
     if (value === null || value === undefined)
         return ctx.undefined;
@@ -129,6 +131,137 @@ export class QuickJSSandbox {
             runtime.dispose();
         }
     }
+    async executeWithOrchestration(code, bridge, options = {}) {
+        const maxBridgeCalls = options.maxBridgeCalls ?? DEFAULT_MAX_BRIDGE_CALLS;
+        const startTime = Date.now();
+        const allLogs = [];
+        const allBridgeCalls = [];
+        if (options.bridgeAllowlist) {
+            bridge.setAllowlist(options.bridgeAllowlist);
+        }
+        let bridgeResults = {};
+        let lastOutput;
+        let round = 0;
+        while (round <= maxBridgeCalls) {
+            const roundGlobals = {
+                ...options.globals,
+                __bridgeRound: round,
+            };
+            if (round > 0) {
+                roundGlobals.__bridgeResults = bridgeResults;
+            }
+            const roundResult = await this._executeOneRound(code, bridge, {
+                ...options,
+                globals: roundGlobals,
+            });
+            allLogs.push(...roundResult.logs);
+            if (!roundResult.ok || roundResult.timedOut) {
+                return {
+                    ...roundResult,
+                    logs: allLogs,
+                    durationMs: Date.now() - startTime,
+                    bridgeCallCount: allBridgeCalls.length,
+                    bridgeCalls: allBridgeCalls,
+                };
+            }
+            lastOutput = roundResult.output;
+            if (!bridge.hasPending()) {
+                break;
+            }
+            const pending = bridge.drainPending();
+            const roundResults = {};
+            for (const req of pending) {
+                try {
+                    const result = await bridge.call(req.toolName, req.args);
+                    roundResults[req.id] = result;
+                    allBridgeCalls.push({ toolName: req.toolName, args: req.args, result });
+                }
+                catch (err) {
+                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    roundResults[req.id] = { __error: true, message: errorMsg };
+                    allBridgeCalls.push({
+                        toolName: req.toolName,
+                        args: req.args,
+                        result: { __error: true, message: errorMsg },
+                    });
+                }
+            }
+            bridgeResults = { ...bridgeResults, ...roundResults };
+            round++;
+        }
+        return {
+            ok: true,
+            output: lastOutput,
+            timedOut: false,
+            durationMs: Date.now() - startTime,
+            logs: allLogs,
+            bridgeCallCount: allBridgeCalls.length,
+            bridgeCalls: allBridgeCalls,
+        };
+    }
+    async _executeOneRound(code, bridge, options = {}) {
+        const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const memoryLimitBytes = options.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES;
+        const QuickJS = await getQuickJS();
+        const runtime = QuickJS.newRuntime();
+        runtime.setMemoryLimit(memoryLimitBytes);
+        const startTime = Date.now();
+        let timedOut = false;
+        runtime.setInterruptHandler(() => {
+            if (Date.now() - startTime > timeoutMs) {
+                timedOut = true;
+                return true;
+            }
+            return false;
+        });
+        const context = runtime.newContext();
+        const logs = [];
+        try {
+            this._injectConsole(context, logs);
+            this._injectHelpers(context);
+            this._injectBridgeForOrchestration(context, bridge, logs);
+            if (options.globals) {
+                this._injectGlobals(context, options.globals);
+            }
+            const result = context.evalCode(code, 'sandbox-eval.js');
+            if (result.error) {
+                const errorMsg = context.dump(result.error);
+                result.error.dispose();
+                if (timedOut) {
+                    return {
+                        ok: false,
+                        error: 'Execution timed out',
+                        timedOut: true,
+                        durationMs: Date.now() - startTime,
+                        logs,
+                    };
+                }
+                return {
+                    ok: false,
+                    error: typeof errorMsg === 'object' ? JSON.stringify(errorMsg) : String(errorMsg),
+                    timedOut: false,
+                    durationMs: Date.now() - startTime,
+                    logs,
+                };
+            }
+            const output = unmarshalFromQuickJS(context, result.value);
+            result.value.dispose();
+            return { ok: true, output, timedOut: false, durationMs: Date.now() - startTime, logs };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+                timedOut,
+                durationMs: Date.now() - startTime,
+                logs,
+            };
+        }
+        finally {
+            context.dispose();
+            runtime.dispose();
+        }
+    }
     _injectConsole(ctx, logs) {
         const consoleObj = ctx.newObject();
         const logFn = ctx.newFunction('log', (...args) => {
@@ -181,4 +314,31 @@ export class QuickJSSandbox {
         listFn.dispose();
         mcpObj.dispose();
     }
+    _injectBridgeForOrchestration(ctx, bridge, logs) {
+        const mcpObj = ctx.newObject();
+        const callFn = ctx.newFunction('call', (nameHandle, argsHandle) => {
+            const name = ctx.getString(nameHandle);
+            const args = ctx.dump(argsHandle) ?? {};
+            try {
+                const callId = bridge.enqueue(name, args);
+                logs.push(`[mcp.call] enqueued ${name}(${JSON.stringify(args)}) → ${callId}`);
+                return marshalToQuickJS(ctx, { __bridgeCall: true, callId });
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                logs.push(`[mcp.call] rejected ${name}: ${errorMsg}`);
+                return marshalToQuickJS(ctx, { __bridgeCall: false, error: errorMsg });
+            }
+        });
+        const listFn = ctx.newFunction('listTools', () => {
+            const tools = bridge.listAvailableTools();
+            return marshalToQuickJS(ctx, tools);
+        });
+        ctx.setProp(mcpObj, 'call', callFn);
+        ctx.setProp(mcpObj, 'listTools', listFn);
+        ctx.setProp(ctx.global, 'mcp', mcpObj);
+        callFn.dispose();
+        listFn.dispose();
+        mcpObj.dispose();
+    }
 }

package/dist/src/server/sandbox/types.d.ts

@@ -12,3 +12,16 @@ export interface SandboxResult {
     durationMs: number;
     logs: string[];
 }
+export interface BridgeCallRecord {
+    toolName: string;
+    args: Record<string, unknown>;
+    result: unknown;
+}
+export interface OrchestrationOptions extends SandboxOptions {
+    maxBridgeCalls?: number;
+    bridgeAllowlist?: string[];
+}
+export interface OrchestrationResult extends SandboxResult {
+    bridgeCallCount: number;
+    bridgeCalls: BridgeCallRecord[];
+}

package/dist/src/server/search/AffinityGraph.d.ts

@@ -2,6 +2,12 @@ export interface AffinityEdge {
     docIndex: number;
     weight: number;
 }
+export interface ExplicitEdge {
+    from: string;
+    to: string;
+    relation: 'requires' | 'precedes' | 'suggests';
+    weight: number;
+}
 interface DocumentInfo {
     name: string;
     domain: string | null;
@@ -9,7 +15,7 @@ interface DocumentInfo {
 export declare class AffinityGraphImpl {
     private readonly graph;
     private readonly docCount;
-    constructor(documents: DocumentInfo[]);
+    constructor(documents: DocumentInfo[], explicitEdges?: ExplicitEdge[]);
     private buildAffinityGraph;
     applyAffinityExpansion(scores: Float64Array): void;
     static applyDomainHubExpansion(scores: Float64Array, docCount: number, getDomain: (index: number) => string | null): void;

package/dist/src/server/search/AffinityGraph.js

@@ -2,11 +2,11 @@ import { SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_
 export class AffinityGraphImpl {
     graph;
     docCount;
-    constructor(documents) {
+    constructor(documents, explicitEdges) {
         this.docCount = documents.length;
-        this.graph = this.buildAffinityGraph(documents);
+        this.graph = this.buildAffinityGraph(documents, explicitEdges);
     }
-    buildAffinityGraph(documents) {
+    buildAffinityGraph(documents, explicitEdges) {
         const graph = new Map();
         const prefixGroups = new Map();
         for (let i = 0; i < documents.length; i++) {
@@ -33,6 +33,27 @@ export class AffinityGraphImpl {
                 graph.set(src, edges);
             }
         }
+        if (explicitEdges && explicitEdges.length > 0) {
+            const nameToIndex = new Map();
+            for (let i = 0; i < documents.length; i++) {
+                nameToIndex.set(documents[i].name, i);
+            }
+            for (const edge of explicitEdges) {
+                const srcIdx = nameToIndex.get(edge.from);
+                const dstIdx = nameToIndex.get(edge.to);
+                if (srcIdx === undefined || dstIdx === undefined)
+                    continue;
+                const edges = graph.get(srcIdx) ?? [];
+                const existing = edges.find((e) => e.docIndex === dstIdx);
+                if (existing) {
+                    existing.weight = Math.max(existing.weight, edge.weight);
+                }
+                else {
+                    edges.push({ docIndex: dstIdx, weight: edge.weight });
+                }
+                graph.set(srcIdx, edges);
+            }
+        }
         return graph;
     }
     applyAffinityExpansion(scores) {

package/dist/src/server/search/EmbeddingWorker.js

@@ -4,9 +4,9 @@ const MODEL_ID = 'Xenova/bge-micro-v2';
 async function getEmbedder() {
     if (!embedder) {
         const { pipeline } = await import('@huggingface/transformers');
-        embedder = await pipeline('feature-extraction', MODEL_ID, {
+        embedder = (await pipeline('feature-extraction', MODEL_ID, {
             quantized: true,
-        });
+        }));
     }
     return embedder;
 }
@@ -30,7 +30,9 @@ parentPort?.on('message', async (msg) => {
             const output = await pipe(msg.text, { pooling: 'mean', normalize: true });
             const raw = output.data;
             const embedding = normalise(new Float32Array(raw));
-            parentPort.postMessage({ type: 'result', id: msg.id, embedding }, [embedding.buffer]);
+            parentPort.postMessage({ type: 'result', id: msg.id, embedding }, [
+                embedding.buffer,
+            ]);
         }
         else if (msg.type === 'embed_batch') {
             const pipe = await getEmbedder();

package/dist/src/server/search/FeedbackTracker.d.ts

@@ -0,0 +1,9 @@
+import type { SearchConfig } from '../../types/config.js';
+export declare class FeedbackTracker {
+    private vectorWeight;
+    private lastVectorRanking;
+    constructor(searchConfig?: SearchConfig);
+    getVectorWeight(): number;
+    recordVectorRanking(ranking: Map<string, number>): void;
+    recordToolCallFeedback(toolName: string, vectorEnabled: boolean): boolean;
+}

package/dist/src/server/search/FeedbackTracker.js

@@ -0,0 +1,26 @@
+import { SEARCH_VECTOR_COSINE_WEIGHT } from '../../constants.js';
+export class FeedbackTracker {
+    vectorWeight;
+    lastVectorRanking = null;
+    constructor(searchConfig) {
+        this.vectorWeight = searchConfig?.vectorCosineWeight ?? SEARCH_VECTOR_COSINE_WEIGHT;
+    }
+    getVectorWeight() {
+        return this.vectorWeight;
+    }
+    recordVectorRanking(ranking) {
+        this.lastVectorRanking = ranking;
+    }
+    recordToolCallFeedback(toolName, vectorEnabled) {
+        if (!this.lastVectorRanking || !vectorEnabled)
+            return false;
+        const vectorRank = this.lastVectorRanking.get(toolName);
+        if (vectorRank !== undefined && vectorRank < 5) {
+            this.vectorWeight = Math.min(0.8, this.vectorWeight + 0.02);
+        }
+        else {
+            this.vectorWeight = Math.max(0.1, this.vectorWeight - 0.01);
+        }
+        return true;
+    }
+}

package/dist/src/server/search/QueryNormalizer.d.ts

@@ -0,0 +1,6 @@
+export declare const QueryNormalizer: {
+    extractParamTokens(inputSchema: unknown): string[];
+    extractShortDescription(description: string): string;
+    containsCJK(query: string): boolean;
+    normalizeToolName(query: string): string;
+};

package/dist/src/server/search/QueryNormalizer.js

@@ -0,0 +1,94 @@
+const PARAM_DESCRIPTION_STOP_WORDS = new Set([
+    'the',
+    'a',
+    'an',
+    'is',
+    'are',
+    'was',
+    'were',
+    'be',
+    'been',
+    'to',
+    'of',
+    'in',
+    'for',
+    'on',
+    'with',
+    'at',
+    'by',
+    'from',
+    'or',
+    'and',
+    'not',
+    'this',
+    'that',
+    'it',
+    'its',
+    'if',
+    'as',
+    'will',
+    'can',
+    'may',
+    'must',
+    'should',
+    'would',
+    'could',
+    'e',
+    'g',
+    'default',
+    'optional',
+    'required',
+    'when',
+    'set',
+]);
+export const QueryNormalizer = {
+    extractParamTokens(inputSchema) {
+        const tokens = [];
+        if (!inputSchema || typeof inputSchema !== 'object')
+            return tokens;
+        const schema = inputSchema;
+        const properties = schema.properties;
+        if (!properties || typeof properties !== 'object')
+            return tokens;
+        for (const [paramName, paramDef] of Object.entries(properties)) {
+            const nameParts = paramName.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[\s_-]+/);
+            for (const part of nameParts) {
+                const lower = part.toLowerCase();
+                if (lower.length > 1) {
+                    tokens.push(lower);
+                }
+            }
+            if (paramDef && typeof paramDef === 'object') {
+                const desc = paramDef.description;
+                if (typeof desc === 'string') {
+                    const descWords = desc
+                        .toLowerCase()
+                        .split(/[^a-z0-9]+/)
+                        .filter(Boolean);
+                    for (const w of descWords) {
+                        if (w.length > 2 && !PARAM_DESCRIPTION_STOP_WORDS.has(w)) {
+                            tokens.push(w);
+                        }
+                    }
+                }
+            }
+        }
+        return tokens;
+    },
+    extractShortDescription(description) {
+        if (!description)
+            return '';
+        const firstSentence = description.match(/^[^.!?\n]+[.!?]?/);
+        if (firstSentence) {
+            const result = firstSentence[0].trim();
+            return result.length > 120 ? result.slice(0, 117) + '...' : result;
+        }
+        return description.length > 120 ? description.slice(0, 117) + '...' : description;
+    },
+    containsCJK(query) {
+        return /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(query);
+    },
+    normalizeToolName(query) {
+        return query.toLowerCase().replace(/[\s-]+/g, '_');
+    },
+};

package/dist/src/server/search/ToolSearchEngineImpl.d.ts

@@ -23,8 +23,8 @@ export declare class ToolSearchEngine {
     private readonly trigramIndex;
     private readonly embeddingEngine;
     private toolEmbeddings;
-    private vectorWeight;
-    private lastVectorRanking;
+    private readonly feedbackTracker;
+    private feedbackEpoch;
     private readonly bm25Scorer;
     private readonly intentBoost;
     constructor(tools?: Tool[], domainOverrides?: ReadonlyMap<string, string>, domainScoreMultipliers?: ReadonlyMap<string, number>, toolScoreMultipliers?: ReadonlyMap<string, number>, searchConfig?: SearchConfig);
@@ -45,7 +45,6 @@ export declare class ToolSearchEngine {
     private computeVectorCosineScores;
     recordToolCallFeedback(toolName: string, _lastQuery: string): void;
     private applyIntentBonusBand;
-    static extractParamTokens(inputSchema: unknown): string[];
     private buildAffinityGraph;
     private applyAffinityExpansion;
     private applyDomainHubExpansion;

package/dist/src/server/search/ToolSearchEngineImpl.js

@@ -1,9 +1,26 @@
+function findDelimitedIndex(haystack, needle, wordChar) {
+    if (!needle)
+        return -1;
+    let idx = haystack.indexOf(needle);
+    while (idx >= 0) {
+        const before = idx > 0 ? haystack[idx - 1] : null;
+        const after = idx + needle.length < haystack.length ? haystack[idx + needle.length] : null;
+        const beforeOk = before === null || !wordChar.test(before);
+        const afterOk = after === null || !wordChar.test(after);
+        if (beforeOk && afterOk)
+            return idx;
+        idx = haystack.indexOf(needle, idx + 1);
+    }
+    return -1;
+}
 import { allTools, getToolDomain } from '../ToolCatalog.js';
-import { SEARCH_TFIDF_COSINE_WEIGHT, SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD, SEARCH_QUERY_CACHE_CAPACITY, SEARCH_TRIGRAM_WEIGHT, SEARCH_RRF_K, SEARCH_PARAM_TOKEN_WEIGHT, SEARCH_VECTOR_ENABLED, SEARCH_VECTOR_COSINE_WEIGHT, } from '../../constants.js';
+import { SEARCH_TFIDF_COSINE_WEIGHT, SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD, SEARCH_QUERY_CACHE_CAPACITY, SEARCH_TRIGRAM_WEIGHT, SEARCH_RRF_K, SEARCH_PARAM_TOKEN_WEIGHT, SEARCH_VECTOR_ENABLED, } from '../../constants.js';
 import { BM25ScorerImpl } from './BM25Scorer.js';
 import { EmbeddingEngine } from './EmbeddingEngine.js';
 import { IntentBoostImpl } from './IntentBoost.js';
 import { TrigramIndex } from './TrigramIndex.js';
+import { FeedbackTracker } from './FeedbackTracker.js';
+import { QueryNormalizer } from './QueryNormalizer.js';
 class LRUCache {
     capacity;
     map = new Map();
@@ -46,8 +63,8 @@ export class ToolSearchEngine {
     trigramIndex;
     embeddingEngine;
     toolEmbeddings = null;
-    vectorWeight;
-    lastVectorRanking = null;
+    feedbackTracker;
+    feedbackEpoch = 0;
     bm25Scorer;
     intentBoost;
     constructor(tools, domainOverrides, domainScoreMultipliers, toolScoreMultipliers, searchConfig) {
@@ -59,19 +76,19 @@ export class ToolSearchEngine {
         this.bm25Scorer = new BM25ScorerImpl(searchConfig);
         const vectorEnabled = searchConfig?.vectorEnabled ?? SEARCH_VECTOR_ENABLED;
         this.embeddingEngine = vectorEnabled ? new EmbeddingEngine() : null;
-        this.vectorWeight = searchConfig?.vectorCosineWeight ?? SEARCH_VECTOR_COSINE_WEIGHT;
+        this.feedbackTracker = new FeedbackTracker(searchConfig);
         this.intentBoost = new IntentBoostImpl(searchConfig?.intentToolBoostRules);
         let totalLength = 0;
         for (let i = 0; i < source.length; i++) {
             const tool = source[i];
             const domain = this.domainOverrides?.get(tool.name) ?? getToolDomain(tool.name);
             const description = tool.description ?? '';
-            const shortDescription = extractShortDescription(description);
+            const shortDescription = QueryNormalizer.extractShortDescription(description);
             const nameTokens = this.bm25Scorer.tokenise(tool.name);
             const nameTokenSet = new Set(nameTokens);
             const domainTokens = domain ? this.bm25Scorer.tokenise(domain) : [];
             const descTokens = this.bm25Scorer.tokenise(description);
-            const paramTokens = ToolSearchEngine.extractParamTokens(tool.inputSchema);
+            const paramTokens = QueryNormalizer.extractParamTokens(tool.inputSchema);
             const allTokens = [...nameTokens, ...domainTokens, ...descTokens, ...paramTokens];
             const doc = {
                 name: tool.name,
@@ -124,7 +141,7 @@ export class ToolSearchEngine {
             }
         }
         this.avgDocLength = this.docCount > 0 ? totalLength / this.docCount : 1;
-        this.sortedKeys = [...this.invertedIndex.keys()].sort();
+        this.sortedKeys = [...this.invertedIndex.keys()].toSorted();
         const idfMap = new Map();
         for (const [term, postings] of this.invertedIndex) {
             idfMap.set(term, Math.log(1 + this.docCount / postings.length));
@@ -163,21 +180,6 @@ export class ToolSearchEngine {
                 return null;
             const wordCharIdent = /[a-z0-9_]/;
             const wordCharPlain = /[a-z0-9]/;
-            const findDelimitedIndex = (haystack, needle, wordChar) => {
-                if (!needle)
-                    return -1;
-                let idx = haystack.indexOf(needle);
-                while (idx >= 0) {
-                    const before = idx > 0 ? haystack[idx - 1] : null;
-                    const after = idx + needle.length < haystack.length ? haystack[idx + needle.length] : null;
-                    const beforeOk = before === null || !wordChar.test(before);
-                    const afterOk = after === null || !wordChar.test(after);
-                    if (beforeOk && afterOk)
-                        return idx;
-                    idx = haystack.indexOf(needle, idx + 1);
-                }
-                return -1;
-            };
             let bestTool = null;
             let bestIdx = Number.POSITIVE_INFINITY;
             for (const toolName of this.docNameIndex.keys()) {
@@ -197,7 +199,7 @@ export class ToolSearchEngine {
             }
             return bestTool;
         })();
-        const cacheKey = `${query}\0${topK}`;
+        const cacheKey = `${query}\0${topK}\0${this.feedbackEpoch}`;
         const cached = this.queryCache.get(cacheKey);
         if (cached) {
             const active = activeToolNames ?? new Set();
@@ -302,7 +304,7 @@ export class ToolSearchEngine {
         }
         return Array.from(domainMap.entries())
             .map(([domain, tools]) => ({ domain, count: tools.length, tools }))
-            .sort((a, b) => b.count - a.count);
+            .toSorted((a, b) => b.count - a.count);
     }
     scoreToken(token, scores) {
         const postings = this.invertedIndex.get(token);
@@ -350,10 +352,11 @@ export class ToolSearchEngine {
         const vectorScores = await this.computeVectorCosineScores(query);
         const vectorRanked = this.rankByMap(vectorScores);
         if (vectorRanked.size > 0) {
-            this.lastVectorRanking = new Map();
+            const ranking = new Map();
             for (const [docIdx, rank] of vectorRanked) {
-                this.lastVectorRanking.set(this.docs[docIdx].name, rank);
+                ranking.set(this.docs[docIdx].name, rank);
             }
+            this.feedbackTracker.recordVectorRanking(ranking);
         }
         for (let i = 0; i < this.docCount; i++) {
             let rrfScore = 0;
@@ -370,8 +373,8 @@ export class ToolSearchEngine {
                 rrfScore += trigramWeight * (1 / (k + trigramRank));
             }
             const vectorRank = vectorRanked.get(i);
-            if (vectorRank !== undefined && this.vectorWeight > 0) {
-                rrfScore += this.vectorWeight * (1 / (k + vectorRank));
+            if (vectorRank !== undefined && this.feedbackTracker.getVectorWeight() > 0) {
+                rrfScore += this.feedbackTracker.getVectorWeight() * (1 / (k + vectorRank));
             }
             if (rrfScore > 0) {
                 const bm25Original = scores[i];
@@ -430,7 +433,7 @@ export class ToolSearchEngine {
         return ranked;
     }
     rankByMap(scoreMap) {
-        const entries = [...scoreMap.entries()].sort((a, b) => b[1] - a[1]);
+        const entries = [...scoreMap.entries()].toSorted((a, b) => b[1] - a[1]);
         const ranked = new Map();
         for (let rank = 0; rank < entries.length; rank++) {
             ranked.set(entries[rank][0], rank);
@@ -475,16 +478,9 @@ export class ToolSearchEngine {
         return results;
     }
     recordToolCallFeedback(toolName, _lastQuery) {
-        if (!this.lastVectorRanking || !this.embeddingEngine)
-            return;
-        const vectorRank = this.lastVectorRanking.get(toolName);
-        if (vectorRank !== undefined && vectorRank < 5) {
-            this.vectorWeight = Math.min(0.8, this.vectorWeight + 0.02);
-            this.queryCache.clear();
-        }
-        else {
-            this.vectorWeight = Math.max(0.1, this.vectorWeight - 0.01);
-            this.queryCache.clear();
+        const adjusted = this.feedbackTracker.recordToolCallFeedback(toolName, !!this.embeddingEngine);
+        if (adjusted) {
+            this.feedbackEpoch += 1;
         }
     }
     applyIntentBonusBand(scores, intentToolBonuses) {
@@ -503,8 +499,9 @@ export class ToolSearchEngine {
             return;
         }
         const bonusBand = Math.max(1, maxScore + 1);
-        const distinctBonuses = [...new Set([...intentToolBonuses.values()].filter((bonus) => bonus > 0))]
-            .sort((a, b) => a - b);
+        const distinctBonuses = [
+            ...new Set([...intentToolBonuses.values()].filter((bonus) => bonus > 0)),
+        ].toSorted((a, b) => a - b);
         const bonusTierByValue = new Map();
         for (let i = 0; i < distinctBonuses.length; i++) {
             bonusTierByValue.set(distinctBonuses[i], i + 1);
@@ -524,43 +521,6 @@ export class ToolSearchEngine {
             scores[docIndex] += bonusBand * tier;
         }
     }
-    static extractParamTokens(inputSchema) {
-        const tokens = [];
-        if (!inputSchema || typeof inputSchema !== 'object')
-            return tokens;
-        const schema = inputSchema;
-        const properties = schema.properties;
-        if (!properties || typeof properties !== 'object')
-            return tokens;
-        for (const [paramName, paramDef] of Object.entries(properties)) {
-            const nameParts = paramName.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[\s_-]+/);
-            for (const part of nameParts) {
-                const lower = part.toLowerCase();
-                if (lower.length > 1) {
-                    tokens.push(lower);
-                }
-            }
-            if (paramDef && typeof paramDef === 'object') {
-                const desc = paramDef.description;
-                if (typeof desc === 'string') {
-                    const STOP_WORDS = new Set([
-                        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
-                        'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from',
-                        'or', 'and', 'not', 'this', 'that', 'it', 'its', 'if', 'as',
-                        'will', 'can', 'may', 'must', 'should', 'would', 'could',
-                        'e', 'g', 'default', 'optional', 'required', 'when', 'set',
-                    ]);
-                    const descWords = desc.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
-                    for (const w of descWords) {
-                        if (w.length > 2 && !STOP_WORDS.has(w)) {
-                            tokens.push(w);
-                        }
-                    }
-                }
-            }
-        }
-        return tokens;
-    }
     buildAffinityGraph() {
         const graph = new Map();
         const prefixGroups = new Map();
@@ -648,13 +608,3 @@ export class ToolSearchEngine {
         }
     }
 }
-function extractShortDescription(description) {
-    if (!description)
-        return '';
-    const firstSentence = description.match(/^[^.!?\n]+[.!?]?/);
-    if (firstSentence) {
-        const result = firstSentence[0].trim();
-        return result.length > 120 ? result.slice(0, 117) + '...' : result;
-    }
-    return description.length > 120 ? description.slice(0, 117) + '...' : description;
-}