@splitsoftware/splitio-commons 3.1.0 → 3.1.1-rc.1

package/esm/sync/submitters/impressionsSubmitter.js

@@ -4,7 +4,7 @@ import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels, entityType, data) {
+export function fromImpressionsCollector(sendLabels, data) {
     var groupedByFeature = groupBy(data, 'feature');
     var dto = [];
     forOwn(groupedByFeature, function (value, name) {
@@ -20,7 +20,8 @@ export function fromImpressionsCollector(sendLabels, entityType, data) {
                     b: entry.bucketingKey,
                     pt: entry.pt,
                     properties: entry.properties,
-                    et: entityType, // Definition type
+                    // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+                    et: entry.entityType, // Definition type
                 };
             })
         });
@@ -31,9 +32,9 @@ export function fromImpressionsCollector(sendLabels, entityType, data) {
  * Submitter that periodically posts impressions data
  */
 export function impressionsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.serviceApi.postTestImpressionsBulk, impressions = params.storage.impressions, entityType = params.entityType;
+    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.serviceApi.postTestImpressionsBulk, impressions = params.storage.impressions;
     // retry impressions only once.
-    var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled, entityType), 1);
+    var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
     // register impressions submitter to be executed when impressions cache is full
     impressions.setOnFullQueueCb(function () {
         if (syncTask.isRunning()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.0",
+  "version": "3.1.1-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -215,6 +215,9 @@ export interface IRBSegment extends TargetingEntity {
   } | null
 }
 
+export type ConfigType = 'standard' | 'ai';
+export type ConfigSubtype = 'llm_call';
+
 export interface IDefinition extends TargetingEntity {
   trafficTypeName: string;
   sets?: string[] | null;
@@ -231,6 +234,10 @@ export interface IDefinition extends TargetingEntity {
   configurations?: {
     [treatmentName: string]: string | SplitIO.JsonObject
   } | null;
+  /** Definition classification. Absent means a feature flag. */
+  type?: ConfigType;
+  /** Only meaningful when `type === 'AI'`. */
+  subtype?: ConfigSubtype;
 }
 
 /** Interface of the parsed JSON response of `/splitChanges` */

package/src/evaluator/Engine.ts

@@ -7,12 +7,12 @@ import { CONTROL } from '../utils/constants';
 import { IDefinition, MaybeThenable } from '../dtos/types';
 import SplitIO from '../../types/splitio';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluation, IEvaluationResult, IDefinitionEvaluator } from './types';
+import { IEvaluation, IDefinitionEvaluator } from './types';
 import { ILogger } from '../logger/types';
 import { ENGINE_DEFAULT } from '../logger/constants';
 import { prerequisitesMatcherContext } from './matchers/prerequisites';
 
-function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
+function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluation {
   return {
     treatment: get(result, 'treatment', defaultTreatment),
     label: get(result, 'label', NO_CONDITION_MATCH)
@@ -29,7 +29,7 @@ export function engineParser(log: ILogger, split: IDefinition, storage: IStorage
 
   return {
 
-    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: IDefinitionEvaluator): MaybeThenable<IEvaluationResult> {
+    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: IDefinitionEvaluator): MaybeThenable<IEvaluation> {
 
       const parsedKey = keyParser(key);
 

package/src/evaluator/condition/index.ts

@@ -29,9 +29,9 @@ export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.S
     // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
     if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation!, key.bucketingKey, trafficAllocationSeed!)) {
       return {
-        treatment: undefined, // treatment value is assigned later
+        // treatment value is assigned later, at Engine's evaluationResult
         label: NOT_IN_SPLIT
-      };
+      } as IEvaluation;
     }
 
     // matcherEvaluator could be Async, this relays on matchers return value, so we need

package/src/evaluator/index.ts

@@ -4,11 +4,12 @@ import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_NOT_FOUND } from '../utils/la
 import { CONTROL } from '../utils/constants';
 import { IDefinition, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluationResult } from './types';
+import { IEvaluation } from './types';
 import SplitIO from '../../types/splitio';
 import { ILogger } from '../logger/types';
 import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 const EVALUATION_EXCEPTION = {
   treatment: CONTROL,
@@ -23,7 +24,7 @@ const EVALUATION_DEFINITION_NOT_FOUND = {
 };
 
 function treatmentsException(definitionNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
+  const evaluations: Record<string, IEvaluation> = {};
   definitionNames.forEach(definitionName => {
     evaluations[definitionName] = EVALUATION_EXCEPTION;
   });
@@ -36,8 +37,7 @@ export function evaluateFeature(
   definitionName: string,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   let definition;
 
   try {
@@ -47,29 +47,14 @@ export function evaluateFeature(
     return EVALUATION_EXCEPTION;
   }
 
-  if (thenable(definition)) {
-    return definition.then((definition) => getEvaluation(
-      log,
-      key,
-      definition,
-      attributes,
-      storage,
-      options,
-    )).catch(
-      // Exception on async storage. For example, when the storage is redis or
-      // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-      () => EVALUATION_EXCEPTION
-    );
-  }
-
-  return getEvaluation(
-    log,
-    key,
-    definition,
-    attributes,
-    storage,
-    options,
-  );
+  return thenable(definition) ?
+    definition.then((definition) => getEvaluation(log, key, definition, attributes, storage))
+      .catch(
+        // Exception on async storage. For example, when the storage is redis or
+        // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
+        () => EVALUATION_EXCEPTION
+      ) :
+    getEvaluation(log, key, definition, attributes, storage);
 }
 
 export function evaluateFeatures(
@@ -78,8 +63,7 @@ export function evaluateFeatures(
   definitionNames: string[],
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
+): MaybeThenable<Record<string, IEvaluation>> {
   let definitions;
 
   try {
@@ -90,13 +74,13 @@ export function evaluateFeatures(
   }
 
   return thenable(definitions) ?
-    definitions.then(definitions => getEvaluations(log, key, definitionNames, definitions, attributes, storage, options))
-      .catch(() => {
+    definitions.then(definitions => getEvaluations(log, key, definitionNames, definitions, attributes, storage))
+      .catch(
         // Exception on async storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-        return treatmentsException(definitionNames);
-      }) :
-    getEvaluations(log, key, definitionNames, definitions, attributes, storage, options);
+        () => treatmentsException(definitionNames)
+      ) :
+    getEvaluations(log, key, definitionNames, definitions, attributes, storage);
 }
 
 export function evaluateFeaturesByFlagSets(
@@ -106,8 +90,7 @@ export function evaluateFeaturesByFlagSets(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   method: string,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
+): MaybeThenable<Record<string, IEvaluation>> {
   let storedFlagNames: MaybeThenable<Set<string>[]>;
 
   function evaluate(featureFlagsByFlagSets: Set<string>[]) {
@@ -122,7 +105,7 @@ export function evaluateFeaturesByFlagSets(
     }
 
     return featureFlags.size ?
-      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage, options) :
+      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
       {};
   }
 
@@ -137,9 +120,7 @@ export function evaluateFeaturesByFlagSets(
   // evaluate related features
   return thenable(storedFlagNames) ?
     storedFlagNames.then((storedFlagNames) => evaluate(storedFlagNames))
-      .catch(() => {
-        return {};
-      }) :
+      .catch(() => ({})) :
     evaluate(storedFlagNames);
 }
 
@@ -149,31 +130,15 @@ function getEvaluation(
   definition: IDefinition | null,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
 
   if (definition) {
     const split = engineParser(log, definition, storage);
     const evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
-    // If the storage is async and the evaluated definition uses segments or dependencies, evaluation is thenable
-    if (thenable(evaluation)) {
-      return evaluation.then(result => {
-        result.changeNumber = definition.changeNumber;
-        result.config = definition.configurations && definition.configurations[result.treatment] || null;
-        // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-        result.impressionsDisabled = options?.impressionsDisabled || definition.impressionsDisabled;
-
-        return result;
-      });
-    } else {
-      evaluation.changeNumber = definition.changeNumber;
-      evaluation.config = definition.configurations && definition.configurations[evaluation.treatment] || null;
-      // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-      evaluation.impressionsDisabled = options?.impressionsDisabled || definition.impressionsDisabled;
-    }
-
-    return evaluation;
+    return thenable(evaluation) ?
+      evaluation.then(result => objectAssign(result, { definition })) :
+      objectAssign(evaluation, { definition });
   }
 
   return EVALUATION_DEFINITION_NOT_FOUND;
@@ -186,26 +151,16 @@ function getEvaluations(
   definitions: Record<string, IDefinition | null>,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
-  const result: Record<string, IEvaluationResult> = {};
+): MaybeThenable<Record<string, IEvaluation>> {
+  const result: Record<string, IEvaluation> = {};
   const thenables: Promise<void>[] = [];
   definitionNames.forEach(definitionName => {
-    const evaluation = getEvaluation(
-      log,
-      key,
-      definitions[definitionName],
-      attributes,
-      storage,
-      options
-    );
-    if (thenable(evaluation)) {
+    const evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage);
+    thenable(evaluation) ?
       thenables.push(evaluation.then(res => {
         result[definitionName] = res;
-      }));
-    } else {
+      })) :
       result[definitionName] = evaluation;
-    }
   });
 
   return thenables.length > 0 ? Promise.all(thenables).then(() => result) : result;
@@ -214,7 +169,7 @@ function getEvaluations(
 export function evaluateDefaultTreatment(
   definitionName: string,
   storage: IStorageSync | IStorageAsync,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   let definition;
 
   try {
@@ -230,13 +185,12 @@ export function evaluateDefaultTreatment(
 
 function getDefaultTreatment(
   definition: IDefinition | null,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   if (definition) {
     return {
       treatment: definition.defaultTreatment,
       label: NO_CONDITION_MATCH, // "default rule"
-      config: definition.configurations && definition.configurations[definition.defaultTreatment] || null,
-      changeNumber: definition.changeNumber
+      definition,
     };
   }
 

package/src/evaluator/types.ts

@@ -1,4 +1,4 @@
-import { IBetweenMatcherData, IBetweenStringMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
+import { IBetweenMatcherData, IBetweenStringMatcherData, IDefinition, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import SplitIO from '../../types/splitio';
 import { ILogger } from '../logger/types';
@@ -19,14 +19,11 @@ export interface IMatcherDto {
 }
 
 export interface IEvaluation {
-  treatment?: string,
+  treatment: string,
   label: string,
-  changeNumber?: number,
-  config?: string | null | SplitIO.JsonObject
+  definition?: IDefinition
 }
 
-export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }
-
 export type IDefinitionEvaluator = (log: ILogger, key: SplitIO.SplitKey, definitionName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
 export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>

package/src/listeners/browser.ts

@@ -28,14 +28,14 @@ export class BrowserSignalListener implements ISignalListener {
   private serviceApi: IServiceApi;
   private fromImpressionsCollector: (data: SplitIO.ImpressionDTO[]) => ImpressionsPayload;
 
-  constructor({ syncManager, settings, storage, serviceApi, entityType }: ISdkFactoryContextSync) {
+  constructor({ syncManager, settings, storage, serviceApi }: ISdkFactoryContextSync) {
     this.syncManager = syncManager;
     this.settings = settings;
     this.storage = storage;
     this.serviceApi = serviceApi;
     this.flushData = this.flushData.bind(this);
     this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
-    this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled, entityType);
+    this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
   }
 
   /**

package/src/sdkClient/client.ts

@@ -4,7 +4,7 @@ import { getMatching, getBucketing } from '../utils/key';
 import { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS } from '../utils/constants';
-import { IEvaluationResult } from '../evaluator/types';
+import { IEvaluation } from '../evaluator/types';
 import SplitIO from '../../types/splitio';
 import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
@@ -16,17 +16,17 @@ import { trackMethodFactory } from './trackMethod';
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
 function treatmentsNotReady(featureFlagNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
+  const evaluations: Record<string, IEvaluation> = {};
   featureFlagNames.forEach(featureFlagName => {
     evaluations[featureFlagName] = treatmentNotReady;
   });
   return evaluations;
 }
 
-export function stringify(options?: SplitIO.EvaluationOptions) {
-  if (options && options.properties) {
+export function stringify(properties?: SplitIO.Properties) {
+  if (properties) {
     try {
-      return JSON.stringify(options.properties);
+      return JSON.stringify(properties);
     } catch { /* JSON.stringify should never throw with validated options, but handling just in case */ }
   }
 }
@@ -42,9 +42,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENT) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
-    const wrapUp = (evaluationResult: IEvaluationResult) => {
+    const wrapUp = (evaluationResult: IEvaluation) => {
       const queue: ImpressionDecorated[] = [];
-      const treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
+      const treatment = processEvaluation(evaluationResult, featureFlagName, key, withConfig, methodName, queue, options);
       impressionsTracker.track(queue, attributes);
 
       stopTelemetryTracker(queue[0] && queue[0].imp.label);
@@ -52,7 +52,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluation = readinessManager.isReadyFromCache() ?
-      evaluateFeature(log, key, featureFlagName, attributes, storage, options) :
+      evaluateFeature(log, key, featureFlagName, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentNotReady) :
         treatmentNotReady;
@@ -67,12 +67,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENTS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluation>) => {
       const queue: ImpressionDecorated[] = [];
       const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
       Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -81,7 +80,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReadyFromCache() ?
-      evaluateFeatures(log, key, featureFlagNames, attributes, storage, options) :
+      evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentsNotReady(featureFlagNames)) :
         treatmentsNotReady(featureFlagNames);
@@ -96,12 +95,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS, methodName = GET_TREATMENTS_BY_FLAG_SETS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(method);
 
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluation>) => {
       const queue: ImpressionDecorated[] = [];
       const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
       Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -110,7 +108,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName, options) :
+      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
       isAsync ?
         Promise.resolve({}) :
         {};
@@ -132,19 +130,20 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
   // Internal function
   function processEvaluation(
-    evaluation: IEvaluationResult,
+    evaluation: IEvaluation,
     featureFlagName: string,
     key: SplitIO.SplitKey,
-    properties: string | undefined,
     withConfig: boolean,
     invokingMethodName: string,
-    queue: ImpressionDecorated[]
+    queue: ImpressionDecorated[],
+    options: SplitIO.EvaluationOptions = {}
   ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    const { changeNumber, impressionsDisabled } = evaluation;
-    let { treatment, label, config = null } = evaluation;
+    const { definition } = evaluation;
+    let { treatment, label } = evaluation;
+    let config = definition?.configurations?.[treatment] || null;
 
     if (treatment === CONTROL) {
       const fallbackTreatment = fallbackCalculator(featureFlagName, label);
@@ -163,10 +162,10 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
           time: Date.now(),
           bucketingKey,
           label,
-          changeNumber: changeNumber as number,
-          properties
-        },
-        disabled: impressionsDisabled
+          changeNumber: definition!.changeNumber,
+          properties: stringify(options.properties)
+        }, // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
+        disabled: options.impressionsDisabled || definition!.impressionsDisabled
       });
     }
 

package/src/sdkFactory/types.ts

@@ -43,9 +43,6 @@ export interface IPlatform {
   SignalListener?: new (params: ISdkFactoryContext) => ISignalListener, // Used by BrowserSignalListener
 }
 
-// Definition type
-export type EntityType = 'config' | 'flag';
-
 export interface ISdkFactoryContext {
   platform: IPlatform,
   sdkReadinessManager: ISdkReadinessManager,
@@ -59,7 +56,6 @@ export interface ISdkFactoryContext {
   syncManager?: ISyncManager,
   clients: Record<string, SplitIO.IBasicClient>,
   fallbackCalculator: IFallbackCalculator,
-  entityType?: EntityType
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {

package/src/services/authProvider.ts

@@ -28,7 +28,7 @@ export function authProviderFactory(settings: ISettings, splitHttpClient: ISplit
   const { urls, log } = settings;
 
   function fetchAuth() {
-    let url = `${urls.auth}/api/v3/auth?capabilities=config`;
+    let url = `${urls.auth}/api/v3/auth?capabilities=config,aiconfig`;
     return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
   }
 

package/src/storages/utils.ts

@@ -31,6 +31,7 @@ export function impressionsToJSON(impressions: SplitIO.ImpressionDTO[], metadata
         m: impression.time,
         pt: impression.pt,
         properties: impression.properties
+        // @TODO set entityType
       }
     };
 

package/src/sync/submitters/impressionsSubmitter.ts

@@ -3,12 +3,12 @@ import SplitIO from '../../../types/splitio';
 import { submitterFactory } from './submitter';
 import { ImpressionsPayload } from './types';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
-import { EntityType, ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels: boolean, entityType: EntityType | undefined, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
+export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
   let groupedByFeature = groupBy(data, 'feature');
   let dto: ImpressionsPayload = [];
 
@@ -25,7 +25,8 @@ export function fromImpressionsCollector(sendLabels: boolean, entityType: Entity
           b: entry.bucketingKey, // Bucketing Key
           pt: entry.pt, // Previous time
           properties: entry.properties, // Properties
-          et: entityType, // Definition type
+          // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+          et: entry.entityType, // Definition type
         };
       })
     });
@@ -42,12 +43,11 @@ export function impressionsSubmitterFactory(params: ISdkFactoryContextSync) {
   const {
     settings: { log, scheduler: { impressionsRefreshRate }, core: { labelsEnabled } },
     serviceApi: { postTestImpressionsBulk },
-    storage: { impressions },
-    entityType
+    storage: { impressions }
   } = params;
 
   // retry impressions only once.
-  const syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled, entityType), 1);
+  const syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
 
   // register impressions submitter to be executed when impressions cache is full
   impressions.setOnFullQueueCb(() => {

package/src/sync/submitters/types.ts

@@ -2,7 +2,8 @@
 import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
-import { EntityType } from '../../sdkFactory/types';
+
+type EntityType = 'config' | 'flag' | 'ai-config';
 
 type ImpressionPayload = {
   /** Matching Key */