12634922999

Committed 06 Jan 2025 03:07PM UTC coverage: 84.618%. Remained the same

Build # 12634922999

Build Type

push

github

Committed by

web-flow

Commit Message

fix: ESLint issues in bobuilder-ai-orchestrator (#4837)

* fix ESLint issues in botbuilder-ai-orchestrator

* Merge branch 'southworks/update/eslint-packages' into southworks/fix/eslint-issues-botbuilder-ai-orchestrator

* remove eslint config file

* update yarn.lock

Run Details

8183 of 10819 branches covered (75.64%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

20517 of 23098 relevant lines covered (88.83%)

7388.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.83

/libraries/botbuilder-ai-orchestrator/src/orchestratorRecognizer.ts

/**
 * @module botbuilder-ai-orchestrator
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */

import { existsSync, readFileSync } from 'fs';
import { resolve } from 'path';
import { v4 as uuidv4 } from 'uuid';

import {
    BoolExpression,
    BoolExpressionConverter,
    Expression,
    NumberExpression,
    NumberExpressionConverter,
    StringExpression,
    StringExpressionConverter,
} from 'adaptive-expressions';

import { AdaptiveRecognizer } from 'botbuilder-dialogs-adaptive';
import { Activity, RecognizerResult } from 'botbuilder-core';
import { Converter, ConverterFactory, DialogContext, Recognizer, RecognizerConfiguration } from 'botbuilder-dialogs';

//eslint-disable-next-line @typescript-eslint/no-require-imports
const oc = require('@microsoft/orchestrator-core');

export interface OrchestratorRecognizerConfiguration extends RecognizerConfiguration {
    modelFolder?: string | Expression | StringExpression;
    snapshotFile?: string | Expression | StringExpression;
    disambiguationScoreThreshold?: number | string | Expression | NumberExpression;
    detectAmbiguousIntents?: boolean | string | Expression | BoolExpression;
    externalEntityRecognizer?: Recognizer;
}

export enum LabelType {
    Intent = 1,
    Entity = 2,
}

interface Label {
    name: string;
    span: {
        offset: number;
        length: number;
    };
}

interface Result {
    score: number;
    closest_text: string;
    label: Label;
}

interface LabelResolver {
    score(text: string, labelType?: number): Result[];
}

interface Orchestrator {
    createLabelResolver(snapshot: Uint8Array): LabelResolver;
}

interface OrchestratorDictionaryEntry {
    orchestrator: Orchestrator;
    isEntityExtractionCapable: boolean;
}

/**
 * Class that represents an adaptive Orchestrator recognizer.
 */
export class OrchestratorRecognizer extends AdaptiveRecognizer implements OrchestratorRecognizerConfiguration {
    static $kind = 'Microsoft.OrchestratorRecognizer';

    /**
     * Path to Orchestrator base model folder.
     */
    modelFolder: StringExpression = new StringExpression('=settings.orchestrator.modelFolder');

    /**
     * Path to the snapshot (.blu file) to load.
     */
    snapshotFile: StringExpression = new StringExpression('=settings.orchestrator.snapshotFile');

    /**
     * Threshold value to use for ambiguous intent detection. Defaults to 0.05.
     * Recognizer returns ChooseIntent (disambiguation) if other intents are classified within this threshold of the top scoring intent.
     */
    disambiguationScoreThreshold: NumberExpression = new NumberExpression(0.05);

    /**
     * Enable ambiguous intent detection. Defaults to false.
     */
    detectAmbiguousIntents: BoolExpression = new BoolExpression(false);

    /**
     * The external entity recognizer.
     */
    externalEntityRecognizer?: Recognizer = undefined;

    /**
     * Enable entity detection if entity model exists inside modelFolder. Defaults to true.
     * NOTE: SHOULD consider removing this flag in the next major SDK release (V5).
     */
    scoreEntities = true;

    /**
     * Intent name if ambiguous intents are detected.
     */
    readonly chooseIntent = 'ChooseIntent';

    /**
     * Full intent recognition results are available under this property
     */
    readonly resultProperty = 'result';

    /**
     * Full entity recognition results are available under this property
     */
    readonly entityProperty = 'entityResult';

    /**
     * @param property The key of the conditional selector configuration.
     * @returns The converter for the selector configuration.
     */
    getConverter(property: keyof OrchestratorRecognizerConfiguration): Converter | ConverterFactory {
        switch (property) {
            case 'modelFolder':
                return new StringExpressionConverter();
            case 'snapshotFile':
                return new StringExpressionConverter();
            case 'disambiguationScoreThreshold':
                return new NumberExpressionConverter();
            case 'detectAmbiguousIntents':
                return new BoolExpressionConverter();
            default:
                return super.getConverter(property);
        }
    }

    private readonly unknownIntentFilterScore = 0.4;
    private static orchestratorMap = new Map<string, OrchestratorDictionaryEntry>();
    private _orchestrator?: OrchestratorDictionaryEntry = undefined;
    private _resolver?: LabelResolver = undefined;
    private _isResolverExternal = false;

    /**
     * Returns an OrchestratorRecognizer instance.
     *
     * @param {string} modelFolder Path to NLR model.
     * @param {string} snapshotFile Path to snapshot.
     * @param {any} resolverExternal Orchestrator resolver to use.
     */
    constructor(modelFolder?: string, snapshotFile?: string, resolverExternal?: LabelResolver) {
        super();

        if ((modelFolder && snapshotFile) || resolverExternal) {
            this._initializeModel(modelFolder, snapshotFile, resolverExternal);
        }
    }

    /**
     * Returns a new OrchestratorRecognizer instance.
     *
     * @param {DialogContext} dc Context for the current dialog.
     * @param {Partial<Activity>} activity Current activity sent from user.
     * @param {Record<string, string>} telemetryProperties Additional properties to be logged to telemetry with event.
     * @param {Record<string, number>} telemetryMetrics Additional metrics to be logged to telemetry with event.
     * @returns {Promise<RecognizerResult>} Recognized result.
     */
    async recognize(
        dc: DialogContext,
        activity: Partial<Activity>,
        telemetryProperties?: Record<string, string>,
        telemetryMetrics?: Record<string, number>,
    ): Promise<RecognizerResult> {
        if (!this._resolver) {
            const modelFolder: string = this.modelFolder.getValue(dc.state);
            const snapshotFile: string = this.snapshotFile.getValue(dc.state);
            this._initializeModel(modelFolder, snapshotFile, undefined);
        }

        const text = activity.text ?? '';
        const detectAmbiguity = this.detectAmbiguousIntents.getValue(dc.state);

        let recognizerResult: RecognizerResult = {
            text,
            intents: {},
            entities: {},
        };

        if (!text) {
            // nothing to recognize, return empty result.
            return recognizerResult;
        }

        // Score with orchestrator
        const results = await this._resolver?.score(text);

        if (results?.length) {
            // Add full recognition result as a 'result' property
            recognizerResult[this.resultProperty] = results;

            const topScore = results[0].score;

            // if top scoring intent is less than threshold, return None
            if (topScore < this.unknownIntentFilterScore) {
                // add all scores
                recognizerResult.intents = results.reduce(function (
                    intents: { [index: string]: { score: number } },
                    result,
                ) {
                    intents[result.label.name] = { score: result.score };
                    return intents;
                }, {});
                recognizerResult.intents.None = { score: 1.0 };
            } else {
                // add all scores
                recognizerResult.intents = results.reduce(function (
                    intents: { [index: string]: { score: number } },
                    result,
                ) {
                    intents[result.label.name] = { score: result.score };
                    return intents;
                }, {});

                // disambiguate
                if (detectAmbiguity) {
                    const disambiguationScoreThreshold = this.disambiguationScoreThreshold.getValue(dc.state);
                    const classifyingScore = topScore - disambiguationScoreThreshold;
                    const ambiguousResults = results.filter(
                        (item: { score: number }) => item.score >= classifyingScore,
                    );
                    if (ambiguousResults.length > 1) {
                        const recognizerResults: Record<string, RecognizerResult> = ambiguousResults
                            .map(
                                (result): RecognizerResult => ({
                                    text,
                                    alteredText: result.closest_text,
                                    entities: recognizerResult.entities,
                                    intents: { [result.label.name]: { score: result.score } },
                                }),
                            )
                            .reduce((results: Record<string, RecognizerResult>, result: RecognizerResult) => {
                                const guid = uuidv4();
                                results[`${guid}`] = result;
                                return results;
                            }, {});

                        // replace RecognizerResult with ChooseIntent => Ambiguous recognizerResults as candidates.
                        recognizerResult = this.createChooseIntentResult(recognizerResults);
                    }
                }
            }
        } else {
            // Return 'None' if no intent matched.
            recognizerResult.intents.None = { score: 1.0 };
        }

        if (this.externalEntityRecognizer) {
            // Run external recognition
            const externalResults = await this.externalEntityRecognizer.recognize(
                dc,
                activity,
                telemetryProperties,
                telemetryMetrics,
            );
            recognizerResult.entities = externalResults.entities;
        }

        await this.tryScoreEntitiesAsync(text, recognizerResult);

        await dc.context.sendTraceActivity(
            'OrchestratorRecognizer',
            recognizerResult,
            'OrchestratorRecognizer',
            'Orchestrator Recognition',
        );
        this.trackRecognizerResult(
            dc,
            'OrchestratorRecognizerResult',
            this.fillRecognizerResultTelemetryProperties(recognizerResult, telemetryProperties, dc),
            telemetryMetrics,
        );

        return recognizerResult;
    }

    private getTopTwoIntents(result: RecognizerResult): { name: string; score: number }[] {
        if (!result || !result.intents) {
            throw new Error('result is empty');
        }
        const intents = Object.entries(result.intents)
            .map((intent) => {
                let score = 0;
                if (intent[1].score) {
                    score = intent[1].score;
                }
                return { name: intent[0], score: +score };
            })
            .sort((a, b) => b.score - a.score);
        intents.length = 2;

        return intents;
    }

    /**
     * Uses the RecognizerResult to create a list of properties to be included when tracking the result in telemetry.
     *
     * @param {RecognizerResult} recognizerResult Recognizer Result.
     * @param {Record<string, string>} telemetryProperties A list of properties to append or override the properties created using the RecognizerResult.
     * @param {DialogContext} dialogContext Dialog Context.
     * @returns {Record<string, string>} A collection of properties that can be included when calling the TrackEvent method on the TelemetryClient.
     */
    protected fillRecognizerResultTelemetryProperties(
        recognizerResult: RecognizerResult,
        telemetryProperties?: Record<string, string>,
        dialogContext?: DialogContext,
    ): Record<string, string> {
        const topTwo = this.getTopTwoIntents(recognizerResult);
        const intent = Object.entries(recognizerResult.intents);
        // customRecognizerProps = recognizerResult with following properties omitted:
        //   text, alteredText, intents, entities
        // eslint-disable-next-line  @typescript-eslint/no-unused-vars
        const { text, alteredText, intents, entities, ...customRecognizerProps } = recognizerResult;
        const properties: Record<string, string> = {
            TopIntent: intent.length > 0 ? topTwo[0].name : '',
            TopIntentScore: intent.length > 0 ? topTwo[0].score.toString() : '',
            NextIntent: intent.length > 1 ? topTwo[1].name : '',
            NextIntentScore: intent.length > 1 ? topTwo[1].score.toString() : '',
            Intents: intent.length > 0 ? JSON.stringify(recognizerResult.intents) : '',
            Entities: recognizerResult.entities ? JSON.stringify(recognizerResult.entities) : '',
            AdditionalProperties: JSON.stringify(customRecognizerProps),
        };

        let logPersonalInformation =
            this.logPersonalInformation instanceof BoolExpression
                ? this.logPersonalInformation.getValue(dialogContext.state)
                : this.logPersonalInformation;
        if (logPersonalInformation == undefined) logPersonalInformation = false;

        if (logPersonalInformation) {
            properties['Text'] = recognizerResult.text;
            properties['AlteredText'] = recognizerResult.alteredText;
        }

        // Additional Properties can override "stock" properties.
        if (telemetryProperties) {
            return Object.assign({}, properties, telemetryProperties);
        }

        return properties;
    }

    private _initializeModel(modelFolder?: string, snapshotFile?: string, resolverExternal?: LabelResolver): void {
        if (this._resolver) {
            return;
        }
        if (resolverExternal) {
            this._resolver = resolverExternal;
            this._isResolverExternal = true;
            return;
        }

        if (!modelFolder) {
            throw new Error('Missing "ModelFolder" information.');
        }

        if (!snapshotFile) {
            throw new Error('Missing "ShapshotFile" information.');
        }

        // Create orchestrator core
        const fullModelFolder: string = resolve(modelFolder);

        this._orchestrator = OrchestratorRecognizer.orchestratorMap.has(fullModelFolder)
            ? OrchestratorRecognizer.orchestratorMap.get(fullModelFolder)
            : ((): OrchestratorDictionaryEntry => {
                  // eslint-disable-next-line security/detect-non-literal-fs-filename
                  if (!existsSync(fullModelFolder)) {
                      throw new Error(`Model folder does not exist at ${fullModelFolder}.`);
                  }

                  const entityModelFolder: string = resolve(modelFolder, 'entity');
                  // eslint-disable-next-line security/detect-non-literal-fs-filename
                  const isEntityExtractionCapable: boolean = existsSync(entityModelFolder);
                  const orchestrator = new oc.Orchestrator();
                  if (isEntityExtractionCapable) {
                      if (!orchestrator.load(fullModelFolder, entityModelFolder)) {
                          throw new Error(
                              `Model load failed - model folder ${fullModelFolder}, entity model folder ${entityModelFolder}.`,
                          );
                      }
                  } else {
                      if (!orchestrator.load(fullModelFolder)) {
                          throw new Error(`Model load failed - model folder ${fullModelFolder}.`);
                      }
                  }
                  const orchestratorDictionaryEntry: OrchestratorDictionaryEntry = {
                      orchestrator,
                      isEntityExtractionCapable,
                  };
                  OrchestratorRecognizer.orchestratorMap.set(fullModelFolder, orchestratorDictionaryEntry);
                  return orchestratorDictionaryEntry;
              })();

        const fullSnapshotPath = resolve(snapshotFile);
        // eslint-disable-next-line security/detect-non-literal-fs-filename
        if (!existsSync(fullSnapshotPath)) {
            throw new Error(`Snapshot file does not exist at ${fullSnapshotPath}.`);
        }

        // Load the snapshot
        // eslint-disable-next-line security/detect-non-literal-fs-filename
        const snapshot: Uint8Array = readFileSync(fullSnapshotPath);

        // Load snapshot and create resolver
        this._resolver = this._orchestrator?.orchestrator.createLabelResolver(snapshot);
    }

    private async tryScoreEntitiesAsync(text: string, recognizerResult: RecognizerResult) {
        // It's impossible to extract entities without a _resolver object.
        if (!this._resolver) {
            return;
        }

        // Entity extraction can be controlled by the ScoreEntities flag.
        // NOTE: SHOULD consider removing this flag in the next major SDK release (V5).
        if (!this.scoreEntities) {
            return;
        }

        // The following check is necessary to ensure that the _resolver object
        // is capable of entity extraction. However, this check does not apply to
        // an external, mock-up _resolver.
        if (!this._isResolverExternal) {
            if (!this._orchestrator || !this._orchestrator.isEntityExtractionCapable) {
                return;
            }
        }

        // As this method is TryScoreEntities, so it's best effort only, there should
        // not be any exception thrown out of this method.
        try {
            const results = await this._resolver.score(text, LabelType.Entity);
            if (!results) {
                throw new Error(`Failed scoring entities for: ${text}`);
            }

            // Add full entity recognition result as a 'entityResult' property
            recognizerResult[this.entityProperty] = results;
            if (results.length) {
                recognizerResult.entities ??= {};

                results.forEach((result: Result) => {
                    const entityType = result.label.name;

                    // add value
                    const values = recognizerResult.entities[entityType] ?? [];
                    recognizerResult.entities[entityType] = values;

                    const span = result.label.span;
                    const entityText = text.substr(span.offset, span.length);
                    values.push({
                        type: entityType,
                        score: result.score,
                        text: entityText,
                        start: span.offset,
                        end: span.offset + span.length,
                    });

                    // get/create $instance
                    recognizerResult.entities['$instance'] ??= {};
                    const instanceRoot = recognizerResult.entities['$instance'];

                    // add instanceData
                    instanceRoot[entityType] ??= [];
                    const instanceData = instanceRoot[entityType];
                    instanceData.push({
                        startIndex: span.offset,
                        endIndex: span.offset + span.length,
                        score: result.score,
                        text: entityText,
                        type: entityType,
                    });
                });
            }
        } catch {
            return;
        }
    }
}

1	/**
2	* @module botbuilder-ai-orchestrator
3	*/
4	/**
5	* Copyright (c) Microsoft Corporation. All rights reserved.
6	* Licensed under the MIT License.
7	*/
8
9	import { existsSync, readFileSync } from 'fs';	2✔
10	import { resolve } from 'path';	2✔
11	import { v4 as uuidv4 } from 'uuid';	2✔
12
13	import {	2✔
14	BoolExpression,
15	BoolExpressionConverter,
16	Expression,
17	NumberExpression,
18	NumberExpressionConverter,
19	StringExpression,
20	StringExpressionConverter,
21	} from 'adaptive-expressions';
22
23	import { AdaptiveRecognizer } from 'botbuilder-dialogs-adaptive';	2✔
24	import { Activity, RecognizerResult } from 'botbuilder-core';
25	import { Converter, ConverterFactory, DialogContext, Recognizer, RecognizerConfiguration } from 'botbuilder-dialogs';
26
27	//eslint-disable-next-line @typescript-eslint/no-require-imports
28	const oc = require('@microsoft/orchestrator-core');	2✔
29
30	export interface OrchestratorRecognizerConfiguration extends RecognizerConfiguration {
31	modelFolder?: string \| Expression \| StringExpression;
32	snapshotFile?: string \| Expression \| StringExpression;
33	disambiguationScoreThreshold?: number \| string \| Expression \| NumberExpression;
34	detectAmbiguousIntents?: boolean \| string \| Expression \| BoolExpression;
35	externalEntityRecognizer?: Recognizer;
36	}
37
38	export enum LabelType {	2✔
39	Intent = 1,	2✔
40	Entity = 2,	2✔
41	}
42
43	interface Label {
44	name: string;
45	span: {
46	offset: number;
47	length: number;
48	};
49	}
50
51	interface Result {
52	score: number;
53	closest_text: string;
54	label: Label;
55	}
56
57	interface LabelResolver {
58	score(text: string, labelType?: number): Result[];
59	}
60
61	interface Orchestrator {
62	createLabelResolver(snapshot: Uint8Array): LabelResolver;
63	}
64
65	interface OrchestratorDictionaryEntry {
66	orchestrator: Orchestrator;
67	isEntityExtractionCapable: boolean;
68	}
69
70	/**
71	* Class that represents an adaptive Orchestrator recognizer.
72	*/
73	export class OrchestratorRecognizer extends AdaptiveRecognizer implements OrchestratorRecognizerConfiguration {	2✔
74	static $kind = 'Microsoft.OrchestratorRecognizer';	2✔
75
76	/**
77	* Path to Orchestrator base model folder.
78	*/
79	modelFolder: StringExpression = new StringExpression('=settings.orchestrator.modelFolder');	18✔
80
81	/**
82	* Path to the snapshot (.blu file) to load.
83	*/
84	snapshotFile: StringExpression = new StringExpression('=settings.orchestrator.snapshotFile');	18✔
85
86	/**
87	* Threshold value to use for ambiguous intent detection. Defaults to 0.05.
88	* Recognizer returns ChooseIntent (disambiguation) if other intents are classified within this threshold of the top scoring intent.
89	*/
90	disambiguationScoreThreshold: NumberExpression = new NumberExpression(0.05);	18✔
91
92	/**
93	* Enable ambiguous intent detection. Defaults to false.
94	*/
95	detectAmbiguousIntents: BoolExpression = new BoolExpression(false);	18✔
96
97	/**
98	* The external entity recognizer.
99	*/
100	externalEntityRecognizer?: Recognizer = undefined;	18✔
101
102	/**
103	* Enable entity detection if entity model exists inside modelFolder. Defaults to true.
104	* NOTE: SHOULD consider removing this flag in the next major SDK release (V5).
105	*/
106	scoreEntities = true;	18✔
107
108	/**
109	* Intent name if ambiguous intents are detected.
110	*/
111	readonly chooseIntent = 'ChooseIntent';	18✔
112
113	/**
114	* Full intent recognition results are available under this property
115	*/
116	readonly resultProperty = 'result';	18✔
117
118	/**
119	* Full entity recognition results are available under this property
120	*/
121	readonly entityProperty = 'entityResult';	18✔
122
123	/**
124	* @param property The key of the conditional selector configuration.
125	* @returns The converter for the selector configuration.
126	*/
127	getConverter(property: keyof OrchestratorRecognizerConfiguration): Converter \| ConverterFactory {
128	switch (property) {	×
129	case 'modelFolder':	×
130	return new StringExpressionConverter();	×
131	case 'snapshotFile':
132	return new StringExpressionConverter();	×
133	case 'disambiguationScoreThreshold':
134	return new NumberExpressionConverter();	×
135	case 'detectAmbiguousIntents':
136	return new BoolExpressionConverter();	×
137	default:
138	return super.getConverter(property);	×
139	}
140	}
141
142	private readonly unknownIntentFilterScore = 0.4;	18✔
143	private static orchestratorMap = new Map<string, OrchestratorDictionaryEntry>();	2✔
144	private _orchestrator?: OrchestratorDictionaryEntry = undefined;	18✔
145	private _resolver?: LabelResolver = undefined;	18✔
146	private _isResolverExternal = false;	18✔
147
148	/**
149	* Returns an OrchestratorRecognizer instance.
150	*
151	* @param {string} modelFolder Path to NLR model.
152	* @param {string} snapshotFile Path to snapshot.
153	* @param {any} resolverExternal Orchestrator resolver to use.
154	*/
155	constructor(modelFolder?: string, snapshotFile?: string, resolverExternal?: LabelResolver) {
156	super();	18✔
157
158	if ((modelFolder && snapshotFile) \|\| resolverExternal) {	18!
159	this._initializeModel(modelFolder, snapshotFile, resolverExternal);	18✔
160	}
161	}
162
163	/**
164	* Returns a new OrchestratorRecognizer instance.
165	*
166	* @param {DialogContext} dc Context for the current dialog.
167	* @param {Partial<Activity>} activity Current activity sent from user.
168	* @param {Record<string, string>} telemetryProperties Additional properties to be logged to telemetry with event.
169	* @param {Record<string, number>} telemetryMetrics Additional metrics to be logged to telemetry with event.
170	* @returns {Promise<RecognizerResult>} Recognized result.
171	*/
172	async recognize(
173	dc: DialogContext,
174	activity: Partial<Activity>,
175	telemetryProperties?: Record<string, string>,
176	telemetryMetrics?: Record<string, number>,
177	): Promise<RecognizerResult> {
178	if (!this._resolver) {	16!
179	const modelFolder: string = this.modelFolder.getValue(dc.state);	×
180	const snapshotFile: string = this.snapshotFile.getValue(dc.state);	×
181	this._initializeModel(modelFolder, snapshotFile, undefined);	×
182	}
183
184	const text = activity.text ?? '';	16!
185	const detectAmbiguity = this.detectAmbiguousIntents.getValue(dc.state);	16✔
186
187	let recognizerResult: RecognizerResult = {	16✔
188	text,
189	intents: {},
190	entities: {},
191	};
192
193	if (!text) {	16!
194	// nothing to recognize, return empty result.
195	return recognizerResult;	×
196	}
197
198	// Score with orchestrator
199	const results = await this._resolver?.score(text);	16!
200
201	if (results?.length) {	16!
202	// Add full recognition result as a 'result' property
203	recognizerResult[this.resultProperty] = results;	16✔
204
205	const topScore = results[0].score;	16✔
206
207	// if top scoring intent is less than threshold, return None
208	if (topScore < this.unknownIntentFilterScore) {	16✔
209	// add all scores
210	recognizerResult.intents = results.reduce(function (	2✔
211	intents: { [index: string]: { score: number } },
212	result,
213	) {
214	intents[result.label.name] = { score: result.score };	6✔
215	return intents;	6✔
216	}, {});
217	recognizerResult.intents.None = { score: 1.0 };	2✔
218	} else {
219	// add all scores
220	recognizerResult.intents = results.reduce(function (	14✔
221	intents: { [index: string]: { score: number } },
222	result,
223	) {
224	intents[result.label.name] = { score: result.score };	24✔
225	return intents;	24✔
226	}, {});
227
228	// disambiguate
229	if (detectAmbiguity) {	14✔
230	const disambiguationScoreThreshold = this.disambiguationScoreThreshold.getValue(dc.state);	2✔
231	const classifyingScore = topScore - disambiguationScoreThreshold;	2✔
232	const ambiguousResults = results.filter(	2✔
233	(item: { score: number }) => item.score >= classifyingScore,	6✔
234	);
235	if (ambiguousResults.length > 1) {	2✔
236	const recognizerResults: Record<string, RecognizerResult> = ambiguousResults	2✔
237	.map(
238	(result): RecognizerResult => ({	4✔
239	text,
240	alteredText: result.closest_text,
241	entities: recognizerResult.entities,
242	intents: { [result.label.name]: { score: result.score } },
243	}),
244	)
245	.reduce((results: Record<string, RecognizerResult>, result: RecognizerResult) => {
246	const guid = uuidv4();	4✔
247	results[`${guid}`] = result;	4✔
248	return results;	4✔
249	}, {});
250
251	// replace RecognizerResult with ChooseIntent => Ambiguous recognizerResults as candidates.
252	recognizerResult = this.createChooseIntentResult(recognizerResults);	2✔
253	}
254	}
255	}
256	} else {
257	// Return 'None' if no intent matched.
258	recognizerResult.intents.None = { score: 1.0 };	×
259	}
260
261	if (this.externalEntityRecognizer) {	16✔
262	// Run external recognition
263	const externalResults = await this.externalEntityRecognizer.recognize(	2✔
264	dc,
265	activity,
266	telemetryProperties,
267	telemetryMetrics,
268	);
269	recognizerResult.entities = externalResults.entities;	2✔
270	}
271
272	await this.tryScoreEntitiesAsync(text, recognizerResult);	16✔
273
274	await dc.context.sendTraceActivity(	16✔
275	'OrchestratorRecognizer',
276	recognizerResult,
277	'OrchestratorRecognizer',
278	'Orchestrator Recognition',
279	);
280	this.trackRecognizerResult(	16✔
281	dc,
282	'OrchestratorRecognizerResult',
283	this.fillRecognizerResultTelemetryProperties(recognizerResult, telemetryProperties, dc),
284	telemetryMetrics,
285	);
286
287	return recognizerResult;	16✔
288	}
289
290	private getTopTwoIntents(result: RecognizerResult): { name: string; score: number }[] {
291	if (!result \|\| !result.intents) {	16!
292	throw new Error('result is empty');	×
293	}
294	const intents = Object.entries(result.intents)	16✔
295	.map((intent) => {
296	let score = 0;	26✔
297	if (intent[1].score) {	26✔
298	score = intent[1].score;	26✔
299	}
300	return { name: intent[0], score: +score };	26✔
301	})
302	.sort((a, b) => b.score - a.score);	14✔
303	intents.length = 2;	16✔
304
305	return intents;	16✔
306	}
307
308	/**
309	* Uses the RecognizerResult to create a list of properties to be included when tracking the result in telemetry.
310	*
311	* @param {RecognizerResult} recognizerResult Recognizer Result.
312	* @param {Record<string, string>} telemetryProperties A list of properties to append or override the properties created using the RecognizerResult.
313	* @param {DialogContext} dialogContext Dialog Context.
314	* @returns {Record<string, string>} A collection of properties that can be included when calling the TrackEvent method on the TelemetryClient.
315	*/
316	protected fillRecognizerResultTelemetryProperties(
317	recognizerResult: RecognizerResult,
318	telemetryProperties?: Record<string, string>,
319	dialogContext?: DialogContext,
320	): Record<string, string> {
321	const topTwo = this.getTopTwoIntents(recognizerResult);	16✔
322	const intent = Object.entries(recognizerResult.intents);	16✔
323	// customRecognizerProps = recognizerResult with following properties omitted:
324	// text, alteredText, intents, entities
325	// eslint-disable-next-line @typescript-eslint/no-unused-vars
326	const { text, alteredText, intents, entities, ...customRecognizerProps } = recognizerResult;	16✔
327	const properties: Record<string, string> = {	16✔
328	TopIntent: intent.length > 0 ? topTwo[0].name : '',	16!
329	TopIntentScore: intent.length > 0 ? topTwo[0].score.toString() : '',	16!
330	NextIntent: intent.length > 1 ? topTwo[1].name : '',	16✔
331	NextIntentScore: intent.length > 1 ? topTwo[1].score.toString() : '',	16✔
332	Intents: intent.length > 0 ? JSON.stringify(recognizerResult.intents) : '',	16!
333	Entities: recognizerResult.entities ? JSON.stringify(recognizerResult.entities) : '',	16!
334	AdditionalProperties: JSON.stringify(customRecognizerProps),
335	};
336
337	let logPersonalInformation =
338	this.logPersonalInformation instanceof BoolExpression	16✔
339	? this.logPersonalInformation.getValue(dialogContext.state)	16✔
340	: this.logPersonalInformation;
341	if (logPersonalInformation == undefined) logPersonalInformation = false;	16✔
342
343	if (logPersonalInformation) {	16✔
344	properties['Text'] = recognizerResult.text;	2✔
345	properties['AlteredText'] = recognizerResult.alteredText;	2✔
346	}
347
348	// Additional Properties can override "stock" properties.
349	if (telemetryProperties) {	16!
350	return Object.assign({}, properties, telemetryProperties);	×
351	}
352
353	return properties;	16✔
354	}
355
356	private _initializeModel(modelFolder?: string, snapshotFile?: string, resolverExternal?: LabelResolver): void {
357	if (this._resolver) {	18!
358	return;	×
359	}
360	if (resolverExternal) {	18✔
361	this._resolver = resolverExternal;	16✔
362	this._isResolverExternal = true;	16✔
363	return;	16✔
364	}
365
366	if (!modelFolder) {	2!
367	throw new Error('Missing "ModelFolder" information.');	×
368	}
369
370	if (!snapshotFile) {	2!
371	throw new Error('Missing "ShapshotFile" information.');	×
372	}
373
374	// Create orchestrator core
375	const fullModelFolder: string = resolve(modelFolder);	2✔
376
377	this._orchestrator = OrchestratorRecognizer.orchestratorMap.has(fullModelFolder)	2✔
378	? OrchestratorRecognizer.orchestratorMap.get(fullModelFolder)	2!
379	: ((): OrchestratorDictionaryEntry => {
380	// eslint-disable-next-line security/detect-non-literal-fs-filename
381	if (!existsSync(fullModelFolder)) {	2✔
382	throw new Error(`Model folder does not exist at ${fullModelFolder}.`);	2✔
383	}
384
385	const entityModelFolder: string = resolve(modelFolder, 'entity');	×
386	// eslint-disable-next-line security/detect-non-literal-fs-filename
387	const isEntityExtractionCapable: boolean = existsSync(entityModelFolder);	×
388	const orchestrator = new oc.Orchestrator();	×
389	if (isEntityExtractionCapable) {	×
390	if (!orchestrator.load(fullModelFolder, entityModelFolder)) {	×
391	throw new Error(	×
392	`Model load failed - model folder ${fullModelFolder}, entity model folder ${entityModelFolder}.`,
393	);
394	}
395	} else {
396	if (!orchestrator.load(fullModelFolder)) {	×
397	throw new Error(`Model load failed - model folder ${fullModelFolder}.`);	×
398	}
399	}
400	const orchestratorDictionaryEntry: OrchestratorDictionaryEntry = {	×
401	orchestrator,
402	isEntityExtractionCapable,
403	};
404	OrchestratorRecognizer.orchestratorMap.set(fullModelFolder, orchestratorDictionaryEntry);	×
405	return orchestratorDictionaryEntry;	×
406	})();
407
408	const fullSnapshotPath = resolve(snapshotFile);	×
409	// eslint-disable-next-line security/detect-non-literal-fs-filename
410	if (!existsSync(fullSnapshotPath)) {	×
411	throw new Error(`Snapshot file does not exist at ${fullSnapshotPath}.`);	×
412	}
413
414	// Load the snapshot
415	// eslint-disable-next-line security/detect-non-literal-fs-filename
UNCOV 416	const snapshot: Uint8Array = readFileSync(fullSnapshotPath);	×
417
418	// Load snapshot and create resolver
419	this._resolver = this._orchestrator?.orchestrator.createLabelResolver(snapshot);	×
420	}
421
422	private async tryScoreEntitiesAsync(text: string, recognizerResult: RecognizerResult) {
423	// It's impossible to extract entities without a _resolver object.
424	if (!this._resolver) {	16!
425	return;	×
426	}
427
428	// Entity extraction can be controlled by the ScoreEntities flag.
429	// NOTE: SHOULD consider removing this flag in the next major SDK release (V5).
430	if (!this.scoreEntities) {	16!
431	return;	×
432	}
433
434	// The following check is necessary to ensure that the _resolver object
435	// is capable of entity extraction. However, this check does not apply to
436	// an external, mock-up _resolver.
437	if (!this._isResolverExternal) {	16!
438	if (!this._orchestrator \|\| !this._orchestrator.isEntityExtractionCapable) {	×
439	return;	×
440	}
441	}
442
443	// As this method is TryScoreEntities, so it's best effort only, there should
444	// not be any exception thrown out of this method.
445	try {	16✔
446	const results = await this._resolver.score(text, LabelType.Entity);	16✔
447	if (!results) {	16✔
448	throw new Error(`Failed scoring entities for: ${text}`);	14✔
449	}
450
451	// Add full entity recognition result as a 'entityResult' property
452	recognizerResult[this.entityProperty] = results;	2✔
453	if (results.length) {	2✔
454	recognizerResult.entities ??= {};	2!
455
456	results.forEach((result: Result) => {	2✔
457	const entityType = result.label.name;	2✔
458
459	// add value
460	const values = recognizerResult.entities[entityType] ?? [];	2!
461	recognizerResult.entities[entityType] = values;	2✔
462
463	const span = result.label.span;	2✔
464	const entityText = text.substr(span.offset, span.length);	2✔
465	values.push({	2✔
466	type: entityType,
467	score: result.score,
468	text: entityText,
469	start: span.offset,
470	end: span.offset + span.length,
471	});
472
473	// get/create $instance
474	recognizerResult.entities['$instance'] ??= {};	2!
475	const instanceRoot = recognizerResult.entities['$instance'];	2✔
476
477	// add instanceData
478	instanceRoot[entityType] ??= [];	2!
479	const instanceData = instanceRoot[entityType];	2✔
480	instanceData.push({	2✔
481	startIndex: span.offset,
482	endIndex: span.offset + span.length,
483	score: result.score,
484	text: entityText,
485	type: entityType,
486	});
487	});
488	}
489	} catch {
490	return;	14✔
491	}
492	}
493	}

microsoft / botbuilder-js / 12634922999

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous