@salesforce/lds-adapters-service-einsteinllm 1.242.1 → 1.243.0

package/dist/es/es2018/service-einsteinllm.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$2, typeCheckConfig as typeCheckConfig$2 } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$3, typeCheckConfig as typeCheckConfig$3 } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -104,7 +104,7 @@ function createLink(ref) {
     };
 }
 
-function validate$7(obj, path = 'EinsteinLlmAdditionalConfigInputRepresentation') {
+function validate$9(obj, path = 'EinsteinLlmAdditionalConfigInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -187,7 +187,7 @@ function validate$7(obj, path = 'EinsteinLlmAdditionalConfigInputRepresentation'
     return v_error === undefined ? null : v_error;
 }
 
-function validate$6(obj, path = 'EinsteinLlmGenerationsInputRepresentation') {
+function validate$8(obj, path = 'EinsteinLlmGenerationsInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -195,7 +195,7 @@ function validate$6(obj, path = 'EinsteinLlmGenerationsInputRepresentation') {
         if (obj.additionalConfig !== undefined) {
             const obj_additionalConfig = obj.additionalConfig;
             const path_additionalConfig = path + '.additionalConfig';
-            const referencepath_additionalConfigValidationError = validate$7(obj_additionalConfig, path_additionalConfig);
+            const referencepath_additionalConfigValidationError = validate$9(obj_additionalConfig, path_additionalConfig);
             if (referencepath_additionalConfigValidationError !== null) {
                 let message = 'Object doesn\'t match EinsteinLlmAdditionalConfigInputRepresentation (at "' + path_additionalConfig + '")\n';
                 message += referencepath_additionalConfigValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -218,8 +218,8 @@ function validate$6(obj, path = 'EinsteinLlmGenerationsInputRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 
-const VERSION$3 = "e87ca68f9dcf9550fb4dc9fd91df91ae";
-function validate$5(obj, path = 'EinsteinLlmGenerationItemRepresentation') {
+const VERSION$4 = "e87ca68f9dcf9550fb4dc9fd91df91ae";
+function validate$7(obj, path = 'EinsteinLlmGenerationItemRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -237,10 +237,10 @@ function validate$5(obj, path = 'EinsteinLlmGenerationItemRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$5 = function EinsteinLlmGenerationItemRepresentationSelect() {
+const select$7 = function EinsteinLlmGenerationItemRepresentationSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$3,
+        version: VERSION$4,
         private: [],
         selections: [
             {
@@ -254,7 +254,7 @@ const select$5 = function EinsteinLlmGenerationItemRepresentationSelect() {
         ]
     };
 };
-function equals$3(existing, incoming) {
+function equals$4(existing, incoming) {
     const existing_parameters = existing.parameters;
     const incoming_parameters = incoming.parameters;
     if (!(existing_parameters === incoming_parameters)) {
@@ -268,8 +268,8 @@ function equals$3(existing, incoming) {
     return true;
 }
 
-const VERSION$2 = "4656c961c9d093a9e206c1db7d4de0b0";
-function validate$4(obj, path = 'WrappedMap') {
+const VERSION$3 = "4656c961c9d093a9e206c1db7d4de0b0";
+function validate$6(obj, path = 'WrappedMap') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -291,15 +291,15 @@ function validate$4(obj, path = 'WrappedMap') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const select$4 = function WrappedMapSelect() {
+const select$6 = function WrappedMapSelect() {
     return {
         kind: 'Fragment',
-        version: VERSION$2,
+        version: VERSION$3,
         private: [],
         selections: []
     };
 };
-function equals$2(existing, incoming) {
+function equals$3(existing, incoming) {
     const existing_wrappedMap = existing.wrappedMap;
     const incoming_wrappedMap = incoming.wrappedMap;
     const equals_wrappedMap_props = equalsObject(existing_wrappedMap, incoming_wrappedMap, (existing_wrappedMap_prop, incoming_wrappedMap_prop) => {
@@ -310,9 +310,9 @@ function equals$2(existing, incoming) {
     return true;
 }
 
-const TTL$1 = 100;
-const VERSION$1 = "d8abd72a42e842b253da1c38954dafbc";
-function validate$3(obj, path = 'EinsteinLlmGenerationsRepresentation') {
+const TTL$2 = 100;
+const VERSION$2 = "d8abd72a42e842b253da1c38954dafbc";
+function validate$5(obj, path = 'EinsteinLlmGenerationsRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
             return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -325,7 +325,7 @@ function validate$3(obj, path = 'EinsteinLlmGenerationsRepresentation') {
         for (let i = 0; i < obj_generations.length; i++) {
             const obj_generations_item = obj_generations[i];
             const path_generations_item = path_generations + '[' + i + ']';
-            const referencepath_generations_itemValidationError = validate$5(obj_generations_item, path_generations_item);
+            const referencepath_generations_itemValidationError = validate$7(obj_generations_item, path_generations_item);
             if (referencepath_generations_itemValidationError !== null) {
                 let message = 'Object doesn\'t match EinsteinLlmGenerationItemRepresentation (at "' + path_generations_item + '")\n';
                 message += referencepath_generations_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -336,7 +336,7 @@ function validate$3(obj, path = 'EinsteinLlmGenerationsRepresentation') {
         const path_parameters = path + '.parameters';
         let obj_parameters_union0 = null;
         const obj_parameters_union0_error = (() => {
-            const referencepath_parametersValidationError = validate$4(obj_parameters, path_parameters);
+            const referencepath_parametersValidationError = validate$6(obj_parameters, path_parameters);
             if (referencepath_parametersValidationError !== null) {
                 let message = 'Object doesn\'t match WrappedMap (at "' + path_parameters + '")\n';
                 message += referencepath_parametersValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -395,25 +395,25 @@ function validate$3(obj, path = 'EinsteinLlmGenerationsRepresentation') {
     })();
     return v_error === undefined ? null : v_error;
 }
-const RepresentationType$1 = 'EinsteinLlmGenerationsRepresentation';
-function keyBuilder$1(luvio, config) {
-    return keyPrefix + '::' + RepresentationType$1 + ':' + config.requestId;
+const RepresentationType$2 = 'EinsteinLlmGenerationsRepresentation';
+function keyBuilder$2(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.requestId;
 }
-function keyBuilderFromType$1(luvio, object) {
+function keyBuilderFromType$2(luvio, object) {
     const keyParams = {
         requestId: object.requestId
     };
-    return keyBuilder$1(luvio, keyParams);
+    return keyBuilder$2(luvio, keyParams);
 }
-function normalize$1(input, existing, path, luvio, store, timestamp) {
+function normalize$2(input, existing, path, luvio, store, timestamp) {
     return input;
 }
-const select$3 = function EinsteinLlmGenerationsRepresentationSelect() {
-    const { selections: EinsteinLlmGenerationItemRepresentation__selections, opaque: EinsteinLlmGenerationItemRepresentation__opaque, } = select$5();
-    const { selections: WrappedMap__selections, opaque: WrappedMap__opaque, } = select$4();
+const select$5 = function EinsteinLlmGenerationsRepresentationSelect() {
+    const { selections: EinsteinLlmGenerationItemRepresentation__selections, opaque: EinsteinLlmGenerationItemRepresentation__opaque, } = select$7();
+    const { selections: WrappedMap__selections, opaque: WrappedMap__opaque, } = select$6();
     return {
         kind: 'Fragment',
-        version: VERSION$1,
+        version: VERSION$2,
         private: [],
         selections: [
             {
@@ -439,7 +439,7 @@ const select$3 = function EinsteinLlmGenerationsRepresentationSelect() {
         ]
     };
 };
-function equals$1(existing, incoming) {
+function equals$2(existing, incoming) {
     const existing_requestId = existing.requestId;
     const incoming_requestId = incoming.requestId;
     if (!(existing_requestId === incoming_requestId)) {
@@ -448,7 +448,7 @@ function equals$1(existing, incoming) {
     const existing_generations = existing.generations;
     const incoming_generations = incoming.generations;
     const equals_generations_items = equalsArray(existing_generations, incoming_generations, (existing_generations_item, incoming_generations_item) => {
-        if (!(equals$3(existing_generations_item, incoming_generations_item))) {
+        if (!(equals$4(existing_generations_item, incoming_generations_item))) {
             return false;
         }
     });
@@ -460,7 +460,7 @@ function equals$1(existing, incoming) {
     if (!(existing_parameters === incoming_parameters
         || (existing_parameters != null &&
             incoming_parameters != null &&
-            equals$2(existing_parameters, incoming_parameters)))) {
+            equals$3(existing_parameters, incoming_parameters)))) {
         return false;
     }
     const existing_prompt = existing.prompt;
@@ -470,7 +470,219 @@ function equals$1(existing, incoming) {
     }
     return true;
 }
-const ingest$1 = function EinsteinLlmGenerationsRepresentationIngest(input, path, luvio, store, timestamp) {
+const ingest$2 = function EinsteinLlmGenerationsRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$5(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = TTL$2;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "EinsteinLLM", VERSION$2, RepresentationType$2, equals$2);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+}
+
+function select$4(luvio, params) {
+    return select$5();
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$4(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v60.0',
+        basePath: '/einstein/llm/prompt/generations',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'createGenerations';
+const createGenerations_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('generationsInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const createGenerations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, createGenerations_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$3(createGenerations_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_generationsInput = untrustedConfig.generationsInput;
+    const referenceEinsteinLlmGenerationsInputRepresentationValidationError = validate$8(untrustedConfig_generationsInput);
+    if (referenceEinsteinLlmGenerationsInputRepresentationValidationError === null) {
+        config.generationsInput = untrustedConfig_generationsInput;
+    }
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createGenerationsAdapterFactory = (luvio) => {
+    return function createGenerations(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, createGenerations_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createGenerations"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
+function validate$4(obj, path = 'EinsteinLlmFeedbackInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.appFeedback !== undefined) {
+            const obj_appFeedback = obj.appFeedback;
+            const path_appFeedback = path + '.appFeedback';
+            if (typeof obj_appFeedback !== 'object' || ArrayIsArray(obj_appFeedback) || obj_appFeedback === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_appFeedback + '" (at "' + path_appFeedback + '")');
+            }
+            const obj_appFeedback_keys = ObjectKeys(obj_appFeedback);
+            for (let i = 0; i < obj_appFeedback_keys.length; i++) {
+                const key = obj_appFeedback_keys[i];
+                const obj_appFeedback_prop = obj_appFeedback[key];
+                const path_appFeedback_prop = path_appFeedback + '["' + key + '"]';
+                if (typeof obj_appFeedback_prop !== 'object' || ArrayIsArray(obj_appFeedback_prop) || obj_appFeedback_prop === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_appFeedback_prop + '" (at "' + path_appFeedback_prop + '")');
+                }
+            }
+        }
+        if (obj.feedback !== undefined) {
+            const obj_feedback = obj.feedback;
+            const path_feedback = path + '.feedback';
+            if (typeof obj_feedback !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_feedback + '" (at "' + path_feedback + '")');
+            }
+        }
+        const obj_feedbackText = obj.feedbackText;
+        const path_feedbackText = path + '.feedbackText';
+        if (typeof obj_feedbackText !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_feedbackText + '" (at "' + path_feedbackText + '")');
+        }
+        const obj_generationId = obj.generationId;
+        const path_generationId = path + '.generationId';
+        if (typeof obj_generationId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_generationId + '" (at "' + path_generationId + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$1 = 100;
+const VERSION$1 = "4033328f65865dd5d80c68a7573a4522";
+function validate$3(obj, path = 'EinsteinLlmFeedbackRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_message = obj.message;
+        const path_message = path + '.message';
+        if (typeof obj_message !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$1 = 'EinsteinLlmFeedbackRepresentation';
+function keyBuilder$1(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$1 + ':' + config.message;
+}
+function keyBuilderFromType$1(luvio, object) {
+    const keyParams = {
+        message: object.message
+    };
+    return keyBuilder$1(luvio, keyParams);
+}
+function normalize$1(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$3 = function EinsteinLlmFeedbackRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$1,
+        private: [],
+        selections: [
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$1(existing, incoming) {
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    if (!(existing_message === incoming_message)) {
+        return false;
+    }
+    return true;
+}
+const ingest$1 = function EinsteinLlmFeedbackRepresentationIngest(input, path, luvio, store, timestamp) {
     if (process.env.NODE_ENV !== 'production') {
         const validateError = validate$3(input);
         if (validateError !== null) {
@@ -519,7 +731,7 @@ function createResourceRequest$1(config) {
     const headers = {};
     return {
         baseUri: '/services/data/v60.0',
-        basePath: '/einstein/llm/prompt/generations',
+        basePath: '/einstein/llm/feedback',
         method: 'post',
         body: config.body,
         urlParams: {},
@@ -529,18 +741,18 @@ function createResourceRequest$1(config) {
     };
 }
 
-const adapterName$1 = 'createGenerations';
-const createGenerations_ConfigPropertyMetadata = [
-    generateParamConfigMetadata('generationsInput', true, 2 /* Body */, 4 /* Unsupported */),
+const adapterName$1 = 'createFeedback';
+const createFeedback_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('feedbackInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
-const createGenerations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createGenerations_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$2(createGenerations_ConfigPropertyMetadata);
+const createFeedback_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createFeedback_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$3(createFeedback_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
-    const untrustedConfig_generationsInput = untrustedConfig.generationsInput;
-    const referenceEinsteinLlmGenerationsInputRepresentationValidationError = validate$6(untrustedConfig_generationsInput);
-    if (referenceEinsteinLlmGenerationsInputRepresentationValidationError === null) {
-        config.generationsInput = untrustedConfig_generationsInput;
+    const untrustedConfig_feedbackInput = untrustedConfig.feedbackInput;
+    const referenceEinsteinLlmFeedbackInputRepresentationValidationError = validate$4(untrustedConfig_feedbackInput);
+    if (referenceEinsteinLlmFeedbackInputRepresentationValidationError === null) {
+        config.feedbackInput = untrustedConfig_feedbackInput;
     }
     return config;
 }
@@ -575,12 +787,12 @@ function buildNetworkSnapshot$1(luvio, config, options) {
         throw response;
     });
 }
-const createGenerationsAdapterFactory = (luvio) => {
-    return function createGenerations(untrustedConfig) {
-        const config = validateAdapterConfig$1(untrustedConfig, createGenerations_ConfigPropertyNames);
+const createFeedbackAdapterFactory = (luvio) => {
+    return function createFeedback(untrustedConfig) {
+        const config = validateAdapterConfig$1(untrustedConfig, createFeedback_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
-            throw new Error('Invalid config for "createGenerations"');
+            throw new Error('Invalid config for "createFeedback"');
         }
         return buildNetworkSnapshot$1(luvio, config);
     };
@@ -617,7 +829,7 @@ function validate$1(obj, path = 'EinsteinPromptTemplateGenerationsInputRepresent
         if (obj.additionalConfig !== undefined) {
             const obj_additionalConfig = obj.additionalConfig;
             const path_additionalConfig = path + '.additionalConfig';
-            const referencepath_additionalConfigValidationError = validate$7(obj_additionalConfig, path_additionalConfig);
+            const referencepath_additionalConfigValidationError = validate$9(obj_additionalConfig, path_additionalConfig);
             if (referencepath_additionalConfigValidationError !== null) {
                 let message = 'Object doesn\'t match EinsteinLlmAdditionalConfigInputRepresentation (at "' + path_additionalConfig + '")\n';
                 message += referencepath_additionalConfigValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -663,7 +875,7 @@ function validate(obj, path = 'EinsteinPromptTemplateGenerationsRepresentation')
         for (let i = 0; i < obj_generations.length; i++) {
             const obj_generations_item = obj_generations[i];
             const path_generations_item = path_generations + '[' + i + ']';
-            const referencepath_generations_itemValidationError = validate$5(obj_generations_item, path_generations_item);
+            const referencepath_generations_itemValidationError = validate$7(obj_generations_item, path_generations_item);
             if (referencepath_generations_itemValidationError !== null) {
                 let message = 'Object doesn\'t match EinsteinLlmGenerationItemRepresentation (at "' + path_generations_item + '")\n';
                 message += referencepath_generations_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -674,7 +886,7 @@ function validate(obj, path = 'EinsteinPromptTemplateGenerationsRepresentation')
         const path_parameters = path + '.parameters';
         let obj_parameters_union0 = null;
         const obj_parameters_union0_error = (() => {
-            const referencepath_parametersValidationError = validate$4(obj_parameters, path_parameters);
+            const referencepath_parametersValidationError = validate$6(obj_parameters, path_parameters);
             if (referencepath_parametersValidationError !== null) {
                 let message = 'Object doesn\'t match WrappedMap (at "' + path_parameters + '")\n';
                 message += referencepath_parametersValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
@@ -752,8 +964,8 @@ function normalize(input, existing, path, luvio, store, timestamp) {
     return input;
 }
 const select$1 = function EinsteinPromptTemplateGenerationsRepresentationSelect() {
-    const { selections: EinsteinLlmGenerationItemRepresentation__selections, opaque: EinsteinLlmGenerationItemRepresentation__opaque, } = select$5();
-    const { selections: WrappedMap__selections, opaque: WrappedMap__opaque, } = select$4();
+    const { selections: EinsteinLlmGenerationItemRepresentation__selections, opaque: EinsteinLlmGenerationItemRepresentation__opaque, } = select$7();
+    const { selections: WrappedMap__selections, opaque: WrappedMap__opaque, } = select$6();
     return {
         kind: 'Fragment',
         version: VERSION,
@@ -800,7 +1012,7 @@ function equals(existing, incoming) {
     const existing_generations = existing.generations;
     const incoming_generations = incoming.generations;
     const equals_generations_items = equalsArray(existing_generations, incoming_generations, (existing_generations_item, incoming_generations_item) => {
-        if (!(equals$3(existing_generations_item, incoming_generations_item))) {
+        if (!(equals$4(existing_generations_item, incoming_generations_item))) {
             return false;
         }
     });
@@ -812,7 +1024,7 @@ function equals(existing, incoming) {
     if (!(existing_parameters === incoming_parameters
         || (existing_parameters != null &&
             incoming_parameters != null &&
-            equals$2(existing_parameters, incoming_parameters)))) {
+            equals$3(existing_parameters, incoming_parameters)))) {
         return false;
     }
     const existing_prompt = existing.prompt;
@@ -887,10 +1099,10 @@ const createGenerationsForPromptTemplate_ConfigPropertyMetadata = [
     generateParamConfigMetadata('promptTemplateGenerationsInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createGenerationsForPromptTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, createGenerationsForPromptTemplate_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$2(createGenerationsForPromptTemplate_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$3(createGenerationsForPromptTemplate_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$2(untrustedConfig, config, createGenerationsForPromptTemplate_ConfigPropertyMetadata);
+    typeCheckConfig$3(untrustedConfig, config, createGenerationsForPromptTemplate_ConfigPropertyMetadata);
     const untrustedConfig_promptTemplateGenerationsInput = untrustedConfig.promptTemplateGenerationsInput;
     const referenceEinsteinPromptTemplateGenerationsInputRepresentationValidationError = validate$1(untrustedConfig_promptTemplateGenerationsInput);
     if (referenceEinsteinPromptTemplateGenerationsInputRepresentationValidationError === null) {
@@ -940,4 +1152,4 @@ const createGenerationsForPromptTemplateAdapterFactory = (luvio) => {
     };
 };
 
-export { createGenerationsAdapterFactory, createGenerationsForPromptTemplateAdapterFactory };
+export { createFeedbackAdapterFactory, createGenerationsAdapterFactory, createGenerationsForPromptTemplateAdapterFactory };

package/dist/es/es2018/types/src/generated/adapters/createFeedback.d.ts

@@ -0,0 +1,16 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
+import { EinsteinLlmFeedbackInputRepresentation as types_EinsteinLlmFeedbackInputRepresentation_EinsteinLlmFeedbackInputRepresentation } from '../types/EinsteinLlmFeedbackInputRepresentation';
+import { ResourceRequestConfig as resources_postEinsteinLlmFeedback_ResourceRequestConfig } from '../resources/postEinsteinLlmFeedback';
+import { EinsteinLlmFeedbackRepresentation as types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation } from '../types/EinsteinLlmFeedbackRepresentation';
+export declare const adapterName = "createFeedback";
+export declare const createFeedback_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const createFeedback_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface CreateFeedbackConfig {
+    feedbackInput: types_EinsteinLlmFeedbackInputRepresentation_EinsteinLlmFeedbackInputRepresentation;
+}
+export declare const createResourceParams: (config: CreateFeedbackConfig) => resources_postEinsteinLlmFeedback_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<CreateFeedbackConfig>): adapter$45$utils_Untrusted<CreateFeedbackConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): CreateFeedbackConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: CreateFeedbackConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation, any>>;
+export declare const createFeedbackAdapterFactory: $64$luvio_engine_AdapterFactory<CreateFeedbackConfig, types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation>;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -1,2 +1,3 @@
 export { createGenerationsAdapterFactory } from '../adapters/createGenerations';
+export { createFeedbackAdapterFactory } from '../adapters/createFeedback';
 export { createGenerationsForPromptTemplateAdapterFactory } from '../adapters/createGenerationsForPromptTemplate';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -1,3 +1,4 @@
+declare let createFeedback: any;
 declare let createGenerations: any;
 declare let createGenerationsForPromptTemplate: any;
-export { createGenerations, createGenerationsForPromptTemplate, };
+export { createFeedback, createGenerations, createGenerationsForPromptTemplate, };

package/dist/es/es2018/types/src/generated/resources/postEinsteinLlmFeedback.d.ts

@@ -0,0 +1,13 @@
+import { EinsteinLlmFeedbackInputRepresentation as types_EinsteinLlmFeedbackInputRepresentation_EinsteinLlmFeedbackInputRepresentation } from '../types/EinsteinLlmFeedbackInputRepresentation';
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, FetchResponse as $64$luvio_engine_FetchResponse, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { EinsteinLlmFeedbackRepresentation as types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation } from '../types/EinsteinLlmFeedbackRepresentation';
+export interface ResourceRequestConfig {
+    body: {
+        feedbackInput: types_EinsteinLlmFeedbackInputRepresentation_EinsteinLlmFeedbackInputRepresentation;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_EinsteinLlmFeedbackRepresentation_EinsteinLlmFeedbackRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

package/dist/es/es2018/types/src/generated/types/EinsteinLlmFeedbackInputRepresentation.d.ts

@@ -0,0 +1,44 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "d8791823dc6a931709bc42ac1d0bd098";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinLlmFeedbackInputRepresentation, existing: EinsteinLlmFeedbackInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinLlmFeedbackInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinLlmFeedbackInputRepresentationNormalized, incoming: EinsteinLlmFeedbackInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinLlmFeedbackInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for Feedback with Einstein LLM
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinLlmFeedbackInputRepresentationNormalized {
+    /** app feedback map */
+    appFeedback?: {
+        [key: string]: {};
+    };
+    /** feedback */
+    feedback?: string;
+    /** Feedback Text */
+    feedbackText: string;
+    /** Generation Id - Generations.response.id */
+    generationId: string;
+    /** Feedback id */
+    id: string;
+}
+/**
+ * Input representation for Feedback with Einstein LLM
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinLlmFeedbackInputRepresentation {
+    appFeedback?: {
+        [key: string]: {};
+    };
+    feedback?: string;
+    feedbackText: string;
+    generationId: string;
+    id: string;
+}

package/dist/es/es2018/types/src/generated/types/EinsteinLlmFeedbackRepresentation.d.ts

@@ -0,0 +1,38 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "4033328f65865dd5d80c68a7573a4522";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    message: string;
+}
+export type EinsteinLlmFeedbackRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialEinsteinLlmFeedbackRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): EinsteinLlmFeedbackRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: EinsteinLlmFeedbackRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: EinsteinLlmFeedbackRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: EinsteinLlmFeedbackRepresentation, existing: EinsteinLlmFeedbackRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinLlmFeedbackRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinLlmFeedbackRepresentationNormalized, incoming: EinsteinLlmFeedbackRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinLlmFeedbackRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output of a einstein llm feedback call
+ *
+ * Keys:
+ *    message (string): message
+ */
+export interface EinsteinLlmFeedbackRepresentationNormalized {
+    /** Response text of the feedback API */
+    message: string;
+}
+/**
+ * Output of a einstein llm feedback call
+ *
+ * Keys:
+ *    message (string): message
+ */
+export interface EinsteinLlmFeedbackRepresentation {
+    message: string;
+}

package/dist/es/es2018/types/src/generated/types/EinsteinLlmFeedbackWrapperRepresentation.d.ts

@@ -0,0 +1,28 @@
+import { EinsteinLlmFeedbackInputRepresentation as EinsteinLlmFeedbackInputRepresentation_EinsteinLlmFeedbackInputRepresentation } from './EinsteinLlmFeedbackInputRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "358db59f887ee50c67f9d2d3edb01fa0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EinsteinLlmFeedbackWrapperRepresentation, existing: EinsteinLlmFeedbackWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EinsteinLlmFeedbackWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EinsteinLlmFeedbackWrapperRepresentationNormalized, incoming: EinsteinLlmFeedbackWrapperRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EinsteinLlmFeedbackWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input wrapper for feedback representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinLlmFeedbackWrapperRepresentationNormalized {
+    feedbackInput: EinsteinLlmFeedbackInputRepresentation_EinsteinLlmFeedbackInputRepresentation;
+}
+/**
+ * Input wrapper for feedback representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EinsteinLlmFeedbackWrapperRepresentation {
+    feedbackInput: EinsteinLlmFeedbackInputRepresentation_EinsteinLlmFeedbackInputRepresentation;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-service-einsteinllm",
-    "version": "1.242.1",
+    "version": "1.243.0",
     "description": "Connect family for Einstein LLM generations",
     "license": "SEE LICENSE IN LICENSE.txt",
     "main": "dist/es/es2018/service-einsteinllm.js",

package/sfdc/index.js

@@ -13,7 +13,7 @@
  */
 /* proxy-compat-disable */
 import { withDefaultLuvio } from 'force/ldsEngine';
-import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$2, typeCheckConfig as typeCheckConfig$2 } from 'force/luvioEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$3, typeCheckConfig as typeCheckConfig$3 } from 'force/luvioEngine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
@@ -113,6 +113,218 @@ function createLink(ref) {
     };
 }
 
+function validate$9(obj, path = 'EinsteinLlmFeedbackInputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        if (obj.appFeedback !== undefined) {
+            const obj_appFeedback = obj.appFeedback;
+            const path_appFeedback = path + '.appFeedback';
+            if (typeof obj_appFeedback !== 'object' || ArrayIsArray(obj_appFeedback) || obj_appFeedback === null) {
+                return new TypeError('Expected "object" but received "' + typeof obj_appFeedback + '" (at "' + path_appFeedback + '")');
+            }
+            const obj_appFeedback_keys = ObjectKeys(obj_appFeedback);
+            for (let i = 0; i < obj_appFeedback_keys.length; i++) {
+                const key = obj_appFeedback_keys[i];
+                const obj_appFeedback_prop = obj_appFeedback[key];
+                const path_appFeedback_prop = path_appFeedback + '["' + key + '"]';
+                if (typeof obj_appFeedback_prop !== 'object' || ArrayIsArray(obj_appFeedback_prop) || obj_appFeedback_prop === null) {
+                    return new TypeError('Expected "object" but received "' + typeof obj_appFeedback_prop + '" (at "' + path_appFeedback_prop + '")');
+                }
+            }
+        }
+        if (obj.feedback !== undefined) {
+            const obj_feedback = obj.feedback;
+            const path_feedback = path + '.feedback';
+            if (typeof obj_feedback !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_feedback + '" (at "' + path_feedback + '")');
+            }
+        }
+        const obj_feedbackText = obj.feedbackText;
+        const path_feedbackText = path + '.feedbackText';
+        if (typeof obj_feedbackText !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_feedbackText + '" (at "' + path_feedbackText + '")');
+        }
+        const obj_generationId = obj.generationId;
+        const path_generationId = path + '.generationId';
+        if (typeof obj_generationId !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_generationId + '" (at "' + path_generationId + '")');
+        }
+        const obj_id = obj.id;
+        const path_id = path + '.id';
+        if (typeof obj_id !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_id + '" (at "' + path_id + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+
+const TTL$2 = 100;
+const VERSION$4 = "4033328f65865dd5d80c68a7573a4522";
+function validate$8(obj, path = 'EinsteinLlmFeedbackRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_message = obj.message;
+        const path_message = path + '.message';
+        if (typeof obj_message !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_message + '" (at "' + path_message + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$2 = 'EinsteinLlmFeedbackRepresentation';
+function keyBuilder$2(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$2 + ':' + config.message;
+}
+function keyBuilderFromType$2(luvio, object) {
+    const keyParams = {
+        message: object.message
+    };
+    return keyBuilder$2(luvio, keyParams);
+}
+function normalize$2(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$7 = function EinsteinLlmFeedbackRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$4,
+        private: [],
+        selections: [
+            {
+                name: 'message',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$4(existing, incoming) {
+    const existing_message = existing.message;
+    const incoming_message = incoming.message;
+    if (!(existing_message === incoming_message)) {
+        return false;
+    }
+    return true;
+}
+const ingest$2 = function EinsteinLlmFeedbackRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$8(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = keyBuilderFromType$2(luvio, input);
+    const ttlToUse = TTL$2;
+    ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$2, "EinsteinLLM", VERSION$4, RepresentationType$2, equals$4);
+    return createLink(key);
+};
+function getTypeCacheKeys$2(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = keyBuilderFromType$2(luvio, input);
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$2,
+        mergeable: false
+    });
+}
+
+function select$6(luvio, params) {
+    return select$7();
+}
+function getResponseCacheKeys$2(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$2(storeKeyMap, luvio, response);
+}
+function ingestSuccess$2(luvio, resourceParams, response) {
+    const { body } = response;
+    const key = keyBuilderFromType$2(luvio, body);
+    luvio.storeIngest(key, ingest$2, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$6(),
+        variables: {},
+    });
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function createResourceRequest$2(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v60.0',
+        basePath: '/einstein/llm/feedback',
+        method: 'post',
+        body: config.body,
+        urlParams: {},
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const adapterName$2 = 'createFeedback';
+const createFeedback_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('feedbackInput', true, 2 /* Body */, 4 /* Unsupported */),
+];
+const createFeedback_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$2, createFeedback_ConfigPropertyMetadata);
+const createResourceParams$2 = /*#__PURE__*/ createResourceParams$3(createFeedback_ConfigPropertyMetadata);
+function typeCheckConfig$2(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_feedbackInput = untrustedConfig.feedbackInput;
+    const referenceEinsteinLlmFeedbackInputRepresentationValidationError = validate$9(untrustedConfig_feedbackInput);
+    if (referenceEinsteinLlmFeedbackInputRepresentationValidationError === null) {
+        config.feedbackInput = untrustedConfig_feedbackInput;
+    }
+    return config;
+}
+function validateAdapterConfig$2(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$2(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function buildNetworkSnapshot$2(luvio, config, options) {
+    const resourceParams = createResourceParams$2(config);
+    const request = createResourceRequest$2(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess$2(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$2(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        deepFreeze(response);
+        throw response;
+    });
+}
+const createFeedbackAdapterFactory = (luvio) => {
+    return function createFeedback(untrustedConfig) {
+        const config = validateAdapterConfig$2(untrustedConfig, createFeedback_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "createFeedback"');
+        }
+        return buildNetworkSnapshot$2(luvio, config);
+    };
+};
+
 function validate$7(obj, path = 'EinsteinLlmAdditionalConfigInputRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -543,7 +755,7 @@ const createGenerations_ConfigPropertyMetadata = [
     generateParamConfigMetadata('generationsInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createGenerations_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$1, createGenerations_ConfigPropertyMetadata);
-const createResourceParams$1 = /*#__PURE__*/ createResourceParams$2(createGenerations_ConfigPropertyMetadata);
+const createResourceParams$1 = /*#__PURE__*/ createResourceParams$3(createGenerations_ConfigPropertyMetadata);
 function typeCheckConfig$1(untrustedConfig) {
     const config = {};
     const untrustedConfig_generationsInput = untrustedConfig.generationsInput;
@@ -896,10 +1108,10 @@ const createGenerationsForPromptTemplate_ConfigPropertyMetadata = [
     generateParamConfigMetadata('promptTemplateGenerationsInput', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createGenerationsForPromptTemplate_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, createGenerationsForPromptTemplate_ConfigPropertyMetadata);
-const createResourceParams = /*#__PURE__*/ createResourceParams$2(createGenerationsForPromptTemplate_ConfigPropertyMetadata);
+const createResourceParams = /*#__PURE__*/ createResourceParams$3(createGenerationsForPromptTemplate_ConfigPropertyMetadata);
 function typeCheckConfig(untrustedConfig) {
     const config = {};
-    typeCheckConfig$2(untrustedConfig, config, createGenerationsForPromptTemplate_ConfigPropertyMetadata);
+    typeCheckConfig$3(untrustedConfig, config, createGenerationsForPromptTemplate_ConfigPropertyMetadata);
     const untrustedConfig_promptTemplateGenerationsInput = untrustedConfig.promptTemplateGenerationsInput;
     const referenceEinsteinPromptTemplateGenerationsInputRepresentationValidationError = validate$1(untrustedConfig_promptTemplateGenerationsInput);
     if (referenceEinsteinPromptTemplateGenerationsInputRepresentationValidationError === null) {
@@ -949,6 +1161,7 @@ const createGenerationsForPromptTemplateAdapterFactory = (luvio) => {
     };
 };
 
+let createFeedback;
 let createGenerations;
 let createGenerationsForPromptTemplate;
 function bindExportsTo(luvio) {
@@ -957,6 +1170,7 @@ function bindExportsTo(luvio) {
         return (config) => adapter(config).then(snapshot => snapshot.data);
     }
     return {
+        createFeedback: unwrapSnapshotData(createFeedbackAdapterFactory),
         createGenerations: unwrapSnapshotData(createGenerationsAdapterFactory),
         createGenerationsForPromptTemplate: unwrapSnapshotData(createGenerationsForPromptTemplateAdapterFactory),
         // Imperative GET Adapters
@@ -964,10 +1178,11 @@ function bindExportsTo(luvio) {
 }
 withDefaultLuvio((luvio) => {
     ({
+        createFeedback,
         createGenerations,
         createGenerationsForPromptTemplate,
     } = bindExportsTo(luvio));
 });
 
-export { createGenerations, createGenerationsForPromptTemplate };
-// version: 1.242.1-5a8ee3f4c
+export { createFeedback, createGenerations, createGenerationsForPromptTemplate };
+// version: 1.243.0-c7d8ec9e0

package/src/raml/api.raml

@@ -91,6 +91,46 @@ types:
         format: double
         type: number
         required: false # TODO Hand-rolled W-9314597
+  # TODO Hand-rolled W-8334626
+  # Need to manually wrap the input representation with what the aura controller is expecting
+  EinsteinLlmFeedbackWrapperRepresentation:
+    description: Input wrapper for feedback representation
+    type: object
+    properties:
+      feedbackInput:
+        description: Set the parameters for feedback
+        type: EinsteinLlmFeedbackInputRepresentation
+  EinsteinLlmFeedbackInputRepresentation:
+    description: Input representation for Feedback with Einstein LLM
+    type: object
+    properties:
+      appFeedback:
+        description: app feedback map
+        type: object
+        required: false # TODO Hand-rolled W-9314597
+        properties:
+          //:
+            type: object
+      feedback:
+        description: feedback
+        type: string
+        required: false # TODO Hand-rolled W-9314597
+      feedbackText:
+        description: Feedback Text
+        type: string
+      generationId:
+        description: Generation Id - Generations.response.id
+        type: string
+      id:
+        description: Feedback id
+        type: string
+  EinsteinLlmFeedbackRepresentation:
+    description: Output of a einstein llm feedback call
+    type: object
+    properties:
+      message:
+        description: Response text of the feedback API
+        type: string
   # Hand-rolled remove all EinsteinLlmEmbedding*Representation types; not in scope for current work
   EinsteinLlmGenerationItemRepresentation:
     description: Output of a einstein llm generation item response
@@ -254,6 +294,20 @@ types:
           application/json:
             type: EinsteinLlmGenerationsInputWrapperRepresentation
             (oas-body-name): generationsInput
+    /feedback:
+      post:
+        displayName: postEinsteinLlmFeedback
+        description: Send feedback for a generations.response object
+        responses:
+          '200':
+            description: Success
+            body:
+              application/json:
+                type: EinsteinLlmFeedbackRepresentation
+        body:
+          application/json:
+            type: EinsteinLlmFeedbackWrapperRepresentation
+            (oas-body-name): feedbackInput
   /prompt-templates/{promptTemplateDevName}/generations:
     post:
       displayName: postEinsteinPromptTemplateGenerations

package/src/raml/luvio.raml

@@ -15,6 +15,10 @@ types:
     (luvio.ttl): 100
     (luvio.key):
       requestId: requestId
+  EinsteinLlmFeedbackRepresentation:
+    (luvio.ttl): 100
+    (luvio.key):
+      message: message
 
 /einstein/llm/prompt/generations:
   post:
@@ -25,3 +29,8 @@ types:
   post:
     (luvio.adapter):
       name: createGenerationsForPromptTemplate
+
+/einstein/llm/feedback:
+  post:
+    (luvio.adapter):
+      name: createFeedback