@salesforce/lds-adapters-sfap-einstein-ai-gateway 0.1.0-dev1

package/dist/es/es2018/types/src/generated/adapters/adapter-utils.d.ts

@@ -0,0 +1,62 @@
+import { Adapter as $64$luvio_engine_Adapter, Snapshot as $64$luvio_engine_Snapshot, UnfulfilledSnapshot as $64$luvio_engine_UnfulfilledSnapshot, AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata } from '@luvio/engine';
+export declare const ObjectPrototypeHasOwnProperty: (v: PropertyKey) => boolean;
+declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export { ObjectCreate, ObjectKeys };
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayPrototypePush: (...items: any[]) => number;
+export interface AdapterValidationConfig {
+    displayName: string;
+    parameters: {
+        required: string[];
+        optional: string[];
+        unsupported?: string[];
+    };
+}
+/**
+ * Validates an adapter config is well-formed.
+ * @param config The config to validate.
+ * @param adapter The adapter validation configuration.
+ * @param oneOf The keys the config must contain at least one of.
+ * @throws A TypeError if config doesn't satisfy the adapter's config validation.
+ */
+export declare function validateConfig<T>(config: Untrusted<T>, adapter: AdapterValidationConfig, oneOf?: string[]): void;
+export declare function untrustedIsObject<Base>(untrusted: unknown): untrusted is Untrusted<Base>;
+export type UncoercedConfiguration<Base, Options extends {
+    [key in keyof Base]?: any;
+}> = {
+    [Key in keyof Base]?: Base[Key] | Options[Key];
+};
+export type Untrusted<Base> = Partial<Base>;
+export declare function areRequiredParametersPresent<T>(config: any, configPropertyNames: AdapterValidationConfig): config is T;
+export declare function refreshable<C, D, R>(adapter: $64$luvio_engine_Adapter<C, D>, resolve: (config: unknown) => Promise<$64$luvio_engine_Snapshot<R>>): $64$luvio_engine_Adapter<C, D>;
+export declare const SNAPSHOT_STATE_FULFILLED = "Fulfilled";
+export declare const SNAPSHOT_STATE_UNFULFILLED = "Unfulfilled";
+export declare const snapshotRefreshOptions: {
+    overrides: {
+        headers: {
+            'Cache-Control': string;
+        };
+    };
+};
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function getFetchResponseStatusText(status: number): string;
+export declare function isUnfulfilledSnapshot<T, U>(snapshot: $64$luvio_engine_Snapshot<T, U>): snapshot is $64$luvio_engine_UnfulfilledSnapshot<T, U>;
+export declare function generateParamConfigMetadata(name: string, required: boolean, resourceType: $64$luvio_engine_AdapterConfigMetadata['resourceType'], typeCheckShape: $64$luvio_engine_AdapterConfigMetadata['typeCheckShape'], isArrayShape?: boolean, coerceFn?: (v: unknown) => unknown): $64$luvio_engine_AdapterConfigMetadata;
+export declare function buildAdapterValidationConfig(displayName: string, paramsMeta: $64$luvio_engine_AdapterConfigMetadata[]): AdapterValidationConfig;
+export declare const keyPrefix = "einstein-ai-gateway";

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

@@ -0,0 +1,37 @@
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, 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 { Localization as types_Localization_Localization } from '../types/Localization';
+import { ResourceRequestConfig as resources_postAiGptV1Embeddings_ResourceRequestConfig } from '../resources/postAiGptV1Embeddings';
+import { EmbeddingResponse as types_EmbeddingResponse_EmbeddingResponse } from '../types/EmbeddingResponse';
+export declare const adapterName = "getEmbeddings";
+export declare const getEmbeddings_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getEmbeddings_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetEmbeddingsConfig {
+    xClientFeatureId: string;
+    xSfdcAppContext?: string;
+    xLLMProvider?: string;
+    input: Array<string>;
+    model?: string;
+    enable_pii_masking?: boolean;
+    localization?: types_Localization_Localization;
+    parameters?: {
+        [key: string]: unknown;
+    };
+}
+export declare const createResourceParams: (config: GetEmbeddingsConfig) => resources_postAiGptV1Embeddings_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetEmbeddingsConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetEmbeddingsConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetEmbeddingsConfig>): adapter$45$utils_Untrusted<GetEmbeddingsConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetEmbeddingsConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetEmbeddingsConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetEmbeddingsConfig): $64$luvio_engine_Snapshot<types_EmbeddingResponse_EmbeddingResponse, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetEmbeddingsConfig, resourceParams: resources_postAiGptV1Embeddings_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_EmbeddingResponse_EmbeddingResponse>): Promise<import("@luvio/engine").FulfilledSnapshot<types_EmbeddingResponse_EmbeddingResponse, {}> | import("@luvio/engine").StaleSnapshot<types_EmbeddingResponse_EmbeddingResponse, {}> | import("@luvio/engine").PendingSnapshot<types_EmbeddingResponse_EmbeddingResponse, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetEmbeddingsConfig, resourceParams: resources_postAiGptV1Embeddings_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetEmbeddingsConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_EmbeddingResponse_EmbeddingResponse, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetEmbeddingsConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_EmbeddingResponse_EmbeddingResponse, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_EmbeddingResponse_EmbeddingResponse>): $64$luvio_engine_Snapshot<types_EmbeddingResponse_EmbeddingResponse, any>;
+export declare const getEmbeddingsAdapterFactory: $64$luvio_engine_AdapterFactory<GetEmbeddingsConfig, types_EmbeddingResponse_EmbeddingResponse>;

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

@@ -0,0 +1,32 @@
+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 { ResourceRequestConfig as resources_postAiGptV1Generations_ResourceRequestConfig } from '../resources/postAiGptV1Generations';
+import { GenerationResponse as types_GenerationResponse_GenerationResponse } from '../types/GenerationResponse';
+export declare const adapterName = "getGenerations";
+export declare const getGenerations_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const getGenerations_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetGenerationsConfig {
+    xClientFeatureId: string;
+    xSfdcAppContext?: string;
+    xLLMProvider?: string;
+    prompt: string;
+    num_generations?: number;
+    max_tokens?: number;
+    enable_pii_masking?: boolean;
+    temperature?: number;
+    stop_sequences?: Array<string>;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    model?: string;
+    parameters?: {
+        [key: string]: unknown;
+    };
+    tags?: {
+        [key: string]: unknown;
+    };
+}
+export declare const createResourceParams: (config: GetGenerationsConfig) => resources_postAiGptV1Generations_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetGenerationsConfig>): adapter$45$utils_Untrusted<GetGenerationsConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetGenerationsConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetGenerationsConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_GenerationResponse_GenerationResponse, {}> | import("@luvio/engine").StaleSnapshot<types_GenerationResponse_GenerationResponse, {}> | import("@luvio/engine").PendingSnapshot<types_GenerationResponse_GenerationResponse, any>>;
+export declare const getGenerationsAdapterFactory: $64$luvio_engine_AdapterFactory<GetGenerationsConfig, types_GenerationResponse_GenerationResponse>;

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

@@ -0,0 +1,27 @@
+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 { ResourceRequestConfig as resources_postAiGptV1Feedback_ResourceRequestConfig } from '../resources/postAiGptV1Feedback';
+import { FeedbackResponseRepresentation as types_FeedbackResponseRepresentation_FeedbackResponseRepresentation } from '../types/FeedbackResponseRepresentation';
+export declare const adapterName = "registerFeedback";
+export declare const registerFeedback_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
+export declare const registerFeedback_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface RegisterFeedbackConfig {
+    xClientFeatureId: string;
+    xSfdcAppContext?: string;
+    id: string;
+    generation_id?: string;
+    turn_id?: string;
+    app_generation_id?: string;
+    app_generation?: string;
+    feedback?: string | null;
+    feedback_text?: string;
+    source?: string;
+    app_feedback?: {
+        [key: string]: unknown;
+    };
+}
+export declare const createResourceParams: (config: RegisterFeedbackConfig) => resources_postAiGptV1Feedback_ResourceRequestConfig;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<RegisterFeedbackConfig>): adapter$45$utils_Untrusted<RegisterFeedbackConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): RegisterFeedbackConfig | null;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: RegisterFeedbackConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_FeedbackResponseRepresentation_FeedbackResponseRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_FeedbackResponseRepresentation_FeedbackResponseRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_FeedbackResponseRepresentation_FeedbackResponseRepresentation, any>>;
+export declare const registerFeedbackAdapterFactory: $64$luvio_engine_AdapterFactory<RegisterFeedbackConfig, types_FeedbackResponseRepresentation_FeedbackResponseRepresentation>;

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

@@ -0,0 +1,3 @@
+export { getGenerationsAdapterFactory } from '../adapters/getGenerations';
+export { registerFeedbackAdapterFactory } from '../adapters/registerFeedback';
+export { getEmbeddingsAdapterFactory } from '../adapters/getEmbeddings';

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

@@ -0,0 +1,5 @@
+declare let getEmbeddings: any;
+declare let getGenerations: any;
+declare let registerFeedback: any;
+declare let getEmbeddings_imperative: any;
+export { getEmbeddings, getGenerations, registerFeedback, getEmbeddings_imperative };

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

@@ -0,0 +1,27 @@
+import { Localization as types_Localization_Localization } from '../types/Localization';
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { EmbeddingResponse as types_EmbeddingResponse_EmbeddingResponse } from '../types/EmbeddingResponse';
+export interface ResourceRequestConfig {
+    body: {
+        input: Array<string>;
+        model?: string;
+        enable_pii_masking?: boolean;
+        localization?: types_Localization_Localization;
+        parameters?: {
+            [key: string]: unknown;
+        };
+    };
+    headers: {
+        xClientFeatureId: string;
+        xSfdcAppContext?: string;
+        xLLMProvider?: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_EmbeddingResponse_EmbeddingResponse): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_EmbeddingResponse_EmbeddingResponse>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_EmbeddingResponse_EmbeddingResponse>): $64$luvio_engine_FulfilledSnapshot<types_EmbeddingResponse_EmbeddingResponse, {}> | $64$luvio_engine_StaleSnapshot<types_EmbeddingResponse_EmbeddingResponse, {}> | $64$luvio_engine_PendingSnapshot<types_EmbeddingResponse_EmbeddingResponse, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_EmbeddingResponse_EmbeddingResponse>): $64$luvio_engine_ErrorSnapshot;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,26 @@
+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 { FeedbackResponseRepresentation as types_FeedbackResponseRepresentation_FeedbackResponseRepresentation } from '../types/FeedbackResponseRepresentation';
+export interface ResourceRequestConfig {
+    body: {
+        id: string;
+        generation_id?: string;
+        turn_id?: string;
+        app_generation_id?: string;
+        app_generation?: string;
+        feedback?: string | null;
+        feedback_text?: string;
+        source?: string;
+        app_feedback?: {
+            [key: string]: unknown;
+        };
+    };
+    headers: {
+        xClientFeatureId: string;
+        xSfdcAppContext?: string;
+    };
+}
+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_FeedbackResponseRepresentation_FeedbackResponseRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_FeedbackResponseRepresentation_FeedbackResponseRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_FeedbackResponseRepresentation_FeedbackResponseRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_FeedbackResponseRepresentation_FeedbackResponseRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_FeedbackResponseRepresentation_FeedbackResponseRepresentation, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,31 @@
+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 { GenerationResponse as types_GenerationResponse_GenerationResponse } from '../types/GenerationResponse';
+export interface ResourceRequestConfig {
+    body: {
+        prompt: string;
+        num_generations?: number;
+        max_tokens?: number;
+        enable_pii_masking?: boolean;
+        temperature?: number;
+        stop_sequences?: Array<string>;
+        frequency_penalty?: number;
+        presence_penalty?: number;
+        model?: string;
+        parameters?: {
+            [key: string]: unknown;
+        };
+        tags?: {
+            [key: string]: unknown;
+        };
+    };
+    headers: {
+        xClientFeatureId: string;
+        xSfdcAppContext?: string;
+        xLLMProvider?: string;
+    };
+}
+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_GenerationResponse_GenerationResponse): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_GenerationResponse_GenerationResponse>): $64$luvio_engine_FulfilledSnapshot<types_GenerationResponse_GenerationResponse, {}> | $64$luvio_engine_StaleSnapshot<types_GenerationResponse_GenerationResponse, {}> | $64$luvio_engine_PendingSnapshot<types_GenerationResponse_GenerationResponse, any>;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

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

@@ -0,0 +1,46 @@
+import { ContentQualityRepresentation as ContentQualityRepresentation_ContentQualityRepresentation } from './ContentQualityRepresentation';
+import { SafetyScoreRepresentation as SafetyScoreRepresentation_SafetyScoreRepresentation } from './SafetyScoreRepresentation';
+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 = "1e9c085ad08e9693cfb05fefdf1c912f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ChatMessage, existing: ChatMessageNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ChatMessageNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ChatMessageNormalized, incoming: ChatMessageNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ChatMessage, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a message in a conversation.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ChatMessageNormalized {
+    /** The content of the message. */
+    content: string;
+    generation_content_quality?: ContentQualityRepresentation_ContentQualityRepresentation;
+    generation_safety_score?: SafetyScoreRepresentation_SafetyScoreRepresentation;
+    /** Generation ID. This value is required to register feedback. */
+    id?: string;
+    /** Any provider-specific attributes included as part of this object. */
+    parameters?: {};
+    /** Persona that sent the message. */
+    role: string;
+    /** Timestamp when the message was sent. */
+    timestamp?: number;
+}
+/**
+ * Representation of a message in a conversation.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ChatMessage {
+    content: string;
+    generation_content_quality?: ContentQualityRepresentation_ContentQualityRepresentation;
+    generation_safety_score?: SafetyScoreRepresentation_SafetyScoreRepresentation;
+    id?: string;
+    parameters?: {};
+    role: string;
+    timestamp?: number;
+}

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

@@ -0,0 +1,28 @@
+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 = "1536a256eead5e0f6ed4af90b4a4e6f0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ContentQualityRepresentation, existing: ContentQualityRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ContentQualityRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ContentQualityRepresentationNormalized, incoming: ContentQualityRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ContentQualityRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Data generated by the Trust Layer for content safety and quality (e.g., scores, explanations)
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ContentQualityRepresentationNormalized {
+    /** True if the overall safety score exceeds threshold, false otherwise. Null value indicates safety score call failed */
+    is_toxicity_detected?: boolean;
+}
+/**
+ * Data generated by the Trust Layer for content safety and quality (e.g., scores, explanations)
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ContentQualityRepresentation {
+    is_toxicity_detected?: boolean;
+}

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

@@ -0,0 +1,31 @@
+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 = "46511fb00c7b27e721876696d39287a1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ConversationalMemorySettings, existing: ConversationalMemorySettingsNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ConversationalMemorySettingsNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ConversationalMemorySettingsNormalized, incoming: ConversationalMemorySettingsNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ConversationalMemorySettings, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Settings that can be configured for conversational memory
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ConversationalMemorySettingsNormalized {
+    /** Maximum number of turns to be included in the context provided to the LLM. To be used with last_n_turns strategy. */
+    max_turns?: number;
+    /** The strategy to use when providing conversational context to the LLM. */
+    strategy?: string;
+}
+/**
+ * Settings that can be configured for conversational memory
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ConversationalMemorySettings {
+    max_turns?: number;
+    strategy?: string;
+}

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

@@ -0,0 +1,53 @@
+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 = "d891809c33ff046b1a16c0b83dc83924";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EmbeddingErrorRepresentation, existing: EmbeddingErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EmbeddingErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EmbeddingErrorRepresentationNormalized, incoming: EmbeddingErrorRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EmbeddingErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmbeddingErrorRepresentationNormalized {
+    /** Error code to map the error message */
+    error_code: string;
+    /** Exception error message. */
+    message: string;
+    /** The messageCode field is a specification of the error and uniquely identifies an error message. */
+    message_code: string;
+    /** The parameters field is a collection of name-value pairs where each item in the collection represents a parameter leveraged in the error message. */
+    parameters?: Array<{
+        name?: string;
+        value?: string;
+    }>;
+    /** The targets field is a collection of references that represent the specific occurrence of the problem. */
+    target?: Array<{
+        reference?: string;
+        /** FIELD | QUERY_PARAMETER | HTTP_HEADER */
+        type?: string;
+    }>;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmbeddingErrorRepresentation {
+    error_code: string;
+    message: string;
+    message_code: string;
+    parameters?: Array<{
+        name?: string;
+        value?: string;
+    }>;
+    target?: Array<{
+        reference?: string;
+        type?: string;
+    }>;
+}

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

@@ -0,0 +1,44 @@
+import { Localization as Localization_Localization } from './Localization';
+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 = "5f7a356db0f96fc5c23a77c522654ba8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EmbeddingRequest, existing: EmbeddingRequestNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EmbeddingRequestNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EmbeddingRequestNormalized, incoming: EmbeddingRequestNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EmbeddingRequest, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmbeddingRequestNormalized {
+    /** Indicates whether to mask personally identifiable information (PII) in the prompt. Defaults to `false`. */
+    enable_pii_masking?: boolean;
+    /** Input text used for generating an embedding. Data is encoded as an array of strings. */
+    input: Array<string>;
+    localization?: Localization_Localization;
+    /** The model to be used for generating the embedding. Defaults to a provider-specific model. */
+    model?: string;
+    /** Dictionary of any other parameters that are required by the specified provider. Values are passed as is to the provider so that the request can include parameters that are unique to a provider. */
+    parameters?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmbeddingRequest {
+    enable_pii_masking?: boolean;
+    input: Array<string>;
+    localization?: Localization_Localization;
+    model?: string;
+    parameters?: {
+        [key: string]: unknown;
+    };
+}

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

@@ -0,0 +1,37 @@
+import { Embeddings as Embeddings_Embeddings } from './Embeddings';
+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 TTL = 100;
+export declare const VERSION = "93a316d52ad6c5e482831b43f15666b9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: EmbeddingResponse, existing: EmbeddingResponseNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EmbeddingResponseNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EmbeddingResponseNormalized, incoming: EmbeddingResponseNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: EmbeddingResponse, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmbeddingResponseNormalized {
+    /** Array of `Embeddings` in the response. */
+    embeddings?: Array<Embeddings_Embeddings>;
+    /** Any provider-specific attributes are included as part of this object. */
+    parameters?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmbeddingResponse {
+    embeddings?: Array<Embeddings_Embeddings>;
+    parameters?: {
+        [key: string]: unknown;
+    };
+}

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

@@ -0,0 +1,31 @@
+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 = "9e6bda93c37ac7a0994be9a1413932c6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: Embeddings, existing: EmbeddingsNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): EmbeddingsNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: EmbeddingsNormalized, incoming: EmbeddingsNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: Embeddings, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Embedding of the text.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface EmbeddingsNormalized {
+    /** Embedding of the text. Data is specified as an array of numbers. */
+    embedding?: Array<number>;
+    /** Index of the input text to which the embedding belongs. */
+    index?: number;
+}
+/**
+ * Embedding of the text.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface Embeddings {
+    embedding?: Array<number>;
+    index?: number;
+}

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

@@ -0,0 +1,28 @@
+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 = "1919ed177b4c2a844b3e40c005132835";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: Error, existing: ErrorNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ErrorNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ErrorNormalized, incoming: ErrorNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: Error, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ErrorNormalized {
+    /** Exception error message. */
+    message: string;
+}
+/**
+ *
+ *
+ * Keys:
+ *    (none)
+ */
+export interface Error {
+    message: string;
+}

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

@@ -0,0 +1,28 @@
+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 = "94a6a56cde831f2a2516f43ffee60aad";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FeedbackErrorRepresentation, existing: FeedbackErrorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FeedbackErrorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FeedbackErrorRepresentationNormalized, incoming: FeedbackErrorRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FeedbackErrorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Feedback Error Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FeedbackErrorRepresentationNormalized {
+    /** Exception error message */
+    message: string;
+}
+/**
+ * Feedback Error Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FeedbackErrorRepresentation {
+    message: string;
+}