@jshookmcp/jshook 0.2.3 → 0.2.5

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;
-}

package/dist/src/server/workflows/WorkflowContract.d.ts

@@ -9,6 +9,7 @@ export interface ToolNode {
     readonly id: string;
     readonly toolName: string;
     readonly input?: Record<string, unknown>;
+    readonly inputFrom?: Record<string, string>;
     readonly timeoutMs?: number;
     readonly retry?: RetryPolicy;
 }
@@ -36,11 +37,29 @@ export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode;
 export interface WorkflowExecutionContext {
     readonly workflowRunId: string;
     readonly profile: string;
+    readonly stepResults: ReadonlyMap<string, unknown>;
     invokeTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
     emitSpan(name: string, attrs?: Record<string, unknown>): void;
     emitMetric(name: string, value: number, type: 'counter' | 'gauge' | 'histogram', attrs?: Record<string, unknown>): void;
     getConfig<T = unknown>(path: string, fallback?: T): T;
 }
+export interface WorkflowRouteStep {
+    readonly id: string;
+    readonly toolName: string;
+    readonly description: string;
+    readonly prerequisites: string[];
+    readonly parallel?: boolean;
+    readonly expectedInputs?: Record<string, string>;
+    readonly evidenceNodeType?: string;
+}
+export type WorkflowRouteKind = 'preset' | 'workflow';
+export interface WorkflowRouteMetadata {
+    readonly kind: WorkflowRouteKind;
+    readonly triggerPatterns: RegExp[];
+    readonly steps: WorkflowRouteStep[];
+    readonly requiredDomains: string[];
+    readonly priority: number;
+}
 export interface WorkflowContract {
     readonly kind: 'workflow-contract';
     readonly version: 1;
@@ -50,6 +69,7 @@ export interface WorkflowContract {
     readonly tags?: string[];
     readonly timeoutMs?: number;
     readonly defaultMaxConcurrency?: number;
+    readonly route?: WorkflowRouteMetadata;
     build(ctx: WorkflowExecutionContext): WorkflowNode;
     onStart?(ctx: WorkflowExecutionContext): Promise<void> | void;
     onFinish?(ctx: WorkflowExecutionContext, result: unknown): Promise<void> | void;
@@ -69,10 +89,12 @@ type AnyWorkflowNodeBuilder = WorkflowNodeBuilder<WorkflowNode>;
 export declare class ToolNodeBuilder extends WorkflowNodeBuilder<ToolNode> {
     private toolName;
     private _input?;
+    private _inputFrom?;
     private _retry?;
     private _timeoutMs?;
     constructor(id: string, toolName: string);
     input(input: Record<string, unknown>): this;
+    inputFrom(mapping: Record<string, string>): this;
     retry(policy: RetryPolicy): this;
     timeout(ms: number): this;
     build(): ToolNode;
@@ -117,6 +139,7 @@ export declare class WorkflowBuilder {
     private _tags?;
     private _timeoutMs?;
     private _defaultMaxConcurrency?;
+    private _route?;
     private _buildFn;
     private _onStart?;
     private _onFinish?;
@@ -126,6 +149,7 @@ export declare class WorkflowBuilder {
     tags(tags: string[]): this;
     timeoutMs(timeout: number): this;
     defaultMaxConcurrency(max: number): this;
+    route(route: WorkflowRouteMetadata): this;
     buildGraph(fn: (ctx: WorkflowExecutionContext) => AnyWorkflowNodeBuilder): this;
     onStart(fn: (ctx: WorkflowExecutionContext) => Promise<void> | void): this;
     onFinish(fn: (ctx: WorkflowExecutionContext, result: unknown) => Promise<void> | void): this;

package/dist/src/server/workflows/WorkflowContract.js

@@ -7,6 +7,7 @@ export class WorkflowNodeBuilder {
 export class ToolNodeBuilder extends WorkflowNodeBuilder {
     toolName;
     _input;
+    _inputFrom;
     _retry;
     _timeoutMs;
     constructor(id, toolName) {
@@ -17,6 +18,10 @@ export class ToolNodeBuilder extends WorkflowNodeBuilder {
         this._input = input;
         return this;
     }
+    inputFrom(mapping) {
+        this._inputFrom = mapping;
+        return this;
+    }
     retry(policy) {
         this._retry = policy;
         return this;
@@ -31,6 +36,7 @@ export class ToolNodeBuilder extends WorkflowNodeBuilder {
             id: this.id,
             toolName: this.toolName,
             input: this._input,
+            inputFrom: this._inputFrom,
             retry: this._retry,
             timeoutMs: this._timeoutMs,
         };
@@ -174,6 +180,7 @@ export class WorkflowBuilder {
     _tags;
     _timeoutMs;
     _defaultMaxConcurrency;
+    _route;
     _buildFn;
     _onStart;
     _onFinish;
@@ -198,6 +205,10 @@ export class WorkflowBuilder {
         this._defaultMaxConcurrency = max;
         return this;
     }
+    route(route) {
+        this._route = route;
+        return this;
+    }
     buildGraph(fn) {
         this._buildFn = (ctx) => fn(ctx).build();
         return this;
@@ -226,6 +237,7 @@ export class WorkflowBuilder {
             tags: this._tags,
             timeoutMs: this._timeoutMs,
             defaultMaxConcurrency: this._defaultMaxConcurrency,
+            route: this._route,
             build: this._buildFn,
             onStart: this._onStart,
             onFinish: this._onFinish,

package/dist/src/server/workflows/WorkflowEngine.d.ts

@@ -16,6 +16,7 @@ interface WorkflowSpan {
 export interface ExecuteWorkflowOptions {
     profile?: string;
     config?: JsonRecord;
+    preflightMode?: 'warn' | 'strict' | 'skip';
     nodeInputOverrides?: Record<string, Record<string, unknown>>;
     timeoutMs?: number;
 }

package/dist/src/server/workflows/WorkflowEngine.js

@@ -1,4 +1,14 @@
 import { randomUUID } from 'node:crypto';
+import { getEffectivePrerequisites } from '../ToolRouter.policy.js';
+import { getRoutingState } from '../ToolRouter.probe.js';
+class PreflightError extends Error {
+    warnings;
+    constructor(warnings) {
+        super(`Workflow preflight failed with ${warnings.length} unsatisfied prerequisite(s)`);
+        this.warnings = warnings;
+        this.name = 'PreflightError';
+    }
+}
 function extractConfigValue(config, path, fallback) {
     const segments = path.split('.').filter(Boolean);
     let current = config;
@@ -77,9 +87,29 @@ function collectSuccessStats(value) {
     }
     return { success: 0, failure: 0 };
 }
-async function runToolNode(ctx, node, overrides) {
+function resolveInputFrom(mapping, stepResults) {
+    const resolved = {};
+    for (const [targetKey, sourceRef] of Object.entries(mapping)) {
+        const dotIndex = sourceRef.indexOf('.');
+        if (dotIndex === -1) {
+            resolved[targetKey] = stepResults.get(sourceRef);
+            continue;
+        }
+        const stepId = sourceRef.slice(0, dotIndex);
+        const fieldPath = sourceRef.slice(dotIndex + 1);
+        const stepResult = stepResults.get(stepId);
+        const payload = parseToolPayload(stepResult) ?? stepResult;
+        resolved[targetKey] = payload?.[fieldPath];
+    }
+    return resolved;
+}
+async function runToolNode(ctx, node, overrides, executionContext) {
+    const fromResolved = node.inputFrom
+        ? resolveInputFrom(node.inputFrom, executionContext.stepResults)
+        : {};
     const mergedInput = {
         ...node.input,
+        ...fromResolved,
         ...overrides?.[node.id],
     };
     const runAttempt = async () => {
@@ -113,7 +143,7 @@ async function runToolNode(ctx, node, overrides) {
 }
 async function runParallelNode(ctx, node, executionContext, options) {
     const concurrency = Math.max(1, node.maxConcurrency ?? 4);
-    const results = new Array(node.steps.length);
+    const results = Array.from({ length: node.steps.length });
     let nextIndex = 0;
     let stopped = false;
     const worker = async () => {
@@ -177,7 +207,7 @@ async function executeNode(ctx, node, executionContext, options) {
     let result;
     switch (node.kind) {
         case 'tool':
-            result = await runToolNode(ctx, node, options.nodeInputOverrides);
+            result = await runToolNode(ctx, node, options.nodeInputOverrides, executionContext);
             break;
         case 'sequence': {
             const sequenceNode = node;
@@ -210,6 +240,52 @@ async function executeNode(ctx, node, executionContext, options) {
     executionContext.emitSpan('workflow.node.finish', { nodeId: node.id, kind: node.kind });
     return result;
 }
+function collectToolNodes(node) {
+    switch (node.kind) {
+        case 'tool':
+            return [node];
+        case 'sequence':
+        case 'parallel':
+            return node.steps.flatMap((step) => collectToolNodes(step));
+        case 'branch':
+            return [
+                ...collectToolNodes(node.whenTrue),
+                ...(node.whenFalse ? collectToolNodes(node.whenFalse) : []),
+            ];
+        default:
+            return [];
+    }
+}
+function getEvidenceState(ctx) {
+    try {
+        const evidenceGraph = ctx.getDomainInstance('evidenceGraph');
+        return evidenceGraph
+            ? { hasGraph: true, nodeCount: evidenceGraph.nodeCount, edgeCount: evidenceGraph.edgeCount }
+            : { hasGraph: false, nodeCount: 0, edgeCount: 0 };
+    }
+    catch {
+        return { hasGraph: false, nodeCount: 0, edgeCount: 0 };
+    }
+}
+function collectUnsatisfiedPrerequisites(graph, routingState) {
+    const prerequisites = getEffectivePrerequisites();
+    const warnings = [];
+    for (const toolNode of collectToolNodes(graph)) {
+        const toolPrerequisites = prerequisites[toolNode.toolName] ?? [];
+        for (const prerequisite of toolPrerequisites) {
+            if (prerequisite.check(routingState)) {
+                continue;
+            }
+            warnings.push({
+                nodeId: toolNode.id,
+                toolName: toolNode.toolName,
+                condition: prerequisite.condition,
+                fix: prerequisite.fix,
+            });
+        }
+    }
+    return warnings;
+}
 export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     const runId = randomUUID();
     const profile = options.profile ?? String(ctx.baseTier ?? 'workflow');
@@ -241,8 +317,65 @@ export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     try {
         await workflow.onStart?.(executionContext);
         const graph = workflow.build(executionContext);
+        const preflightMode = options.preflightMode ?? 'warn';
+        let preflightWarnings = [];
+        if (preflightMode === 'skip') {
+            executionContext.emitSpan('workflow.preflight', {
+                mode: preflightMode,
+                skipped: true,
+                evidenceState: getEvidenceState(ctx),
+                warningCount: 0,
+            });
+        }
+        else {
+            try {
+                const routingState = await getRoutingState(ctx);
+                const evidenceState = getEvidenceState(ctx);
+                preflightWarnings = collectUnsatisfiedPrerequisites(graph, routingState);
+                executionContext.emitSpan('workflow.preflight', {
+                    mode: preflightMode,
+                    routingState,
+                    evidenceState,
+                    warningCount: preflightWarnings.length,
+                    warnings: preflightWarnings,
+                });
+                if (preflightMode === 'strict' && preflightWarnings.length > 0) {
+                    throw new PreflightError(preflightWarnings);
+                }
+            }
+            catch (error) {
+                if (error instanceof PreflightError) {
+                    throw error;
+                }
+                executionContext.emitSpan('workflow.preflight', {
+                    mode: preflightMode,
+                    warningCount: 0,
+                    skipped: true,
+                    error: error instanceof Error ? error.message : String(error),
+                    evidenceState: getEvidenceState(ctx),
+                });
+            }
+        }
         const result = await withTimeout(executeNode(ctx, graph, executionContext, options), options.timeoutMs ?? workflow.timeoutMs ?? 0, `Workflow "${workflow.id}"`);
         await workflow.onFinish?.(executionContext, result);
+        try {
+            const evidenceGraph = typeof ctx.getDomainInstance === 'function'
+                ? ctx.getDomainInstance('evidenceGraph')
+                : undefined;
+            if (evidenceGraph && evidenceGraph.nodeCount > 0) {
+                stepResults.set('__evidenceSnapshot', evidenceGraph.exportJson());
+                executionContext.emitSpan('workflow.evidence.auto-export', {
+                    nodeCount: evidenceGraph.nodeCount,
+                    edgeCount: evidenceGraph.edgeCount,
+                });
+            }
+        }
+        catch (exportError) {
+            executionContext.emitSpan('workflow.evidence.auto-export', {
+                skipped: true,
+                error: exportError instanceof Error ? exportError.message : String(exportError),
+            });
+        }
         return {
             workflowId: workflow.id,
             displayName: workflow.displayName,

package/dist/src/types/config.d.ts

@@ -1,24 +1,10 @@
 export interface Config {
-    llm: LLMConfig;
     puppeteer: PuppeteerConfig;
     mcp: MCPConfig;
     cache: CacheConfig;
     performance: PerformanceConfig;
     search: SearchConfig;
 }
-export interface LLMConfig {
-    provider: 'openai' | 'anthropic';
-    openai?: {
-        apiKey: string;
-        model: string;
-        baseURL?: string;
-    };
-    anthropic?: {
-        apiKey: string;
-        model: string;
-        baseURL?: string;
-    };
-}
 export interface PuppeteerConfig {
     headless: boolean;
     timeout: number;

package/dist/src/types/deobfuscator.d.ts

@@ -6,7 +6,6 @@ export interface Transformation {
 }
 export interface DeobfuscateOptions {
     code: string;
-    llm?: 'gpt-4' | 'claude';
     aggressive?: boolean;
     preserveLogic?: boolean;
     renameVariables?: boolean;

package/dist/src/types/index.d.ts

@@ -1,5 +1,5 @@
 export type { CodeLocation, Result } from './common.js';
-export type { Config, LLMConfig, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, SearchConfig, SearchQueryCategoryProfileConfig, SearchCjkQueryAliasConfig, SearchIntentToolBoostRuleConfig, } from './config.js';
+export type { Config, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, SearchConfig, SearchQueryCategoryProfileConfig, SearchCjkQueryAliasConfig, SearchIntentToolBoostRuleConfig, } from './config.js';
 export type { BrowserContext } from './browser.js';
 export type { CollectCodeOptions, CodeFile, CollectCodeResult, DependencyGraph, DependencyNode, DependencyEdge, } from './collector.js';
 export type { ObfuscationType, Transformation, DeobfuscateOptions, DeobfuscateResult, DeobfuscateMappingRule, DeobfuscateSavedArtifact, DeobfuscateBundleModuleSummary, DeobfuscateBundleSummary, } from './deobfuscator.js';

package/dist/src/utils/DetailedDataManager.js

@@ -51,6 +51,8 @@ export class DetailedDataManager {
         return Object(value)[key];
     }
     smartHandle(data, threshold = DETAILED_DATA_SMART_THRESHOLD_BYTES) {
+        if (data === null || data === undefined || typeof data !== 'object')
+            return data;
         const { json: jsonStr, size } = this.serializeWithMemo(data);
         if (size <= threshold) {
             return data;

package/dist/src/utils/RingBuffer.js

@@ -6,7 +6,7 @@ export class RingBuffer {
     count = 0;
     constructor(capacity) {
         this.capacity = capacity;
-        this.buf = new Array(capacity);
+        this.buf = Array.from({ length: capacity });
     }
     get length() {
         return this.count;
@@ -37,7 +37,7 @@ export class RingBuffer {
         return item;
     }
     clear() {
-        this.buf = new Array(Math.min(64, this.capacity));
+        this.buf = Array.from({ length: Math.min(64, this.capacity) });
         this.head = 0;
         this.tail = 0;
         this.count = 0;
@@ -48,14 +48,14 @@ export class RingBuffer {
         }
     }
     toArray() {
-        const result = new Array(this.count);
+        const result = Array.from({ length: this.count });
         for (let i = 0; i < this.count; i++) {
             result[i] = this.buf[(this.head + i) % this.buf.length];
         }
         return result;
     }
     map(fn) {
-        const result = new Array(this.count);
+        const result = Array.from({ length: this.count });
         for (let i = 0; i < this.count; i++) {
             result[i] = fn(this.buf[(this.head + i) % this.buf.length], i);
         }
@@ -63,7 +63,7 @@ export class RingBuffer {
     }
     grow() {
         const newSize = Math.min(this.buf.length * 2, this.capacity);
-        const newBuf = new Array(newSize);
+        const newBuf = Array.from({ length: newSize });
         for (let i = 0; i < this.count; i++) {
             newBuf[i] = this.buf[(this.head + i) % this.buf.length];
         }

package/dist/src/utils/TokenBudgetManager.js

@@ -257,7 +257,7 @@ export class TokenBudgetManager {
             tokens,
             percentage: Math.round((tokens / this.currentUsage) * 100),
         }))
-            .sort((a, b) => b.tokens - a.tokens)
+            .toSorted((a, b) => b.tokens - a.tokens)
             .slice(0, 10);
         const suggestions = this.generateSuggestions(topTools);
         const recentCalls = this.toolCallHistory.slice(-20);