@memberjunction/core-entities 2.76.0 → 2.78.0

package/dist/generated/entity_subclasses.js

@@ -8688,6 +8688,94 @@ exports.AIPromptRunSchema = zod_1.z.object({
         * * SQL Data Type: uniqueidentifier
         * * Related Entity/Foreign Key: MJ: AI Prompt Runs (vwAIPromptRuns.ID)
         * * Description: If this run was initiated as a re-run of another prompt run, this field links back to the original run ID`),
+    ModelSelection: zod_1.z.string().nullable().describe(`
+        * * Field Name: ModelSelection
+        * * Display Name: Model Selection
+        * * SQL Data Type: nvarchar(MAX)
+        * * Description: JSON object containing detailed model selection information including all models considered, their scores, and the selection rationale`),
+    Status: zod_1.z.union([zod_1.z.literal('Pending'), zod_1.z.literal('Running'), zod_1.z.literal('Completed'), zod_1.z.literal('Failed'), zod_1.z.literal('Cancelled')]).describe(`
+        * * Field Name: Status
+        * * Display Name: Status
+        * * SQL Data Type: nvarchar(50)
+        * * Default Value: Pending
+    * * Value List Type: List
+    * * Possible Values 
+    *   * Pending
+    *   * Running
+    *   * Completed
+    *   * Failed
+    *   * Cancelled
+        * * Description: Current execution status of the prompt run. Valid values: Pending, Running, Completed, Failed, Cancelled`),
+    Cancelled: zod_1.z.boolean().describe(`
+        * * Field Name: Cancelled
+        * * Display Name: Cancelled
+        * * SQL Data Type: bit
+        * * Default Value: 0
+        * * Description: Indicates whether this prompt run was cancelled before completion`),
+    CancellationReason: zod_1.z.string().nullable().describe(`
+        * * Field Name: CancellationReason
+        * * Display Name: Cancellation Reason
+        * * SQL Data Type: nvarchar(MAX)
+        * * Description: Detailed reason for cancellation if the prompt run was cancelled. Could be user_requested, timeout, error, or resource_limit`),
+    ModelPowerRank: zod_1.z.number().nullable().describe(`
+        * * Field Name: ModelPowerRank
+        * * Display Name: Model Power Rank
+        * * SQL Data Type: int
+        * * Description: Power rank of the model that was selected for this run. Lower numbers indicate more powerful models`),
+    SelectionStrategy: zod_1.z.union([zod_1.z.literal('Default'), zod_1.z.literal('Specific'), zod_1.z.literal('ByPower')]).nullable().describe(`
+        * * Field Name: SelectionStrategy
+        * * Display Name: Selection Strategy
+        * * SQL Data Type: nvarchar(50)
+    * * Value List Type: List
+    * * Possible Values 
+    *   * Default
+    *   * Specific
+    *   * ByPower
+        * * Description: Strategy used for model selection. Valid values: Default (system default), Specific (specific models configured), ByPower (based on power ranking)`),
+    CacheHit: zod_1.z.boolean().describe(`
+        * * Field Name: CacheHit
+        * * Display Name: Cache Hit
+        * * SQL Data Type: bit
+        * * Default Value: 0
+        * * Description: Indicates whether this result was served from cache rather than executing a new model call`),
+    CacheKey: zod_1.z.string().nullable().describe(`
+        * * Field Name: CacheKey
+        * * Display Name: Cache Key
+        * * SQL Data Type: nvarchar(500)
+        * * Description: Unique key used for caching this prompt result, typically a hash of the prompt and parameters`),
+    JudgeID: zod_1.z.string().nullable().describe(`
+        * * Field Name: JudgeID
+        * * Display Name: Judge ID
+        * * SQL Data Type: uniqueidentifier
+        * * Related Entity/Foreign Key: AI Prompts (vwAIPrompts.ID)
+        * * Description: ID of the AIPrompt used as a judge to evaluate and rank multiple parallel execution results`),
+    JudgeScore: zod_1.z.number().nullable().describe(`
+        * * Field Name: JudgeScore
+        * * Display Name: Judge Score
+        * * SQL Data Type: float(53)
+        * * Description: Score assigned by the judge prompt when evaluating multiple results. Higher scores indicate better results`),
+    WasSelectedResult: zod_1.z.boolean().describe(`
+        * * Field Name: WasSelectedResult
+        * * Display Name: Was Selected Result
+        * * SQL Data Type: bit
+        * * Default Value: 0
+        * * Description: Indicates whether this result was selected as the best result when multiple models were run in parallel`),
+    StreamingEnabled: zod_1.z.boolean().describe(`
+        * * Field Name: StreamingEnabled
+        * * Display Name: Streaming Enabled
+        * * SQL Data Type: bit
+        * * Default Value: 0
+        * * Description: Indicates whether streaming was enabled for this prompt execution`),
+    FirstTokenTime: zod_1.z.number().nullable().describe(`
+        * * Field Name: FirstTokenTime
+        * * Display Name: First Token Time
+        * * SQL Data Type: int
+        * * Description: Time in milliseconds from request initiation to receiving the first token from the model`),
+    ErrorDetails: zod_1.z.string().nullable().describe(`
+        * * Field Name: ErrorDetails
+        * * Display Name: Error Details
+        * * SQL Data Type: nvarchar(MAX)
+        * * Description: Detailed error information in JSON format if the prompt execution failed, including stack traces and error codes`),
     Prompt: zod_1.z.string().describe(`
         * * Field Name: Prompt
         * * Display Name: Prompt
@@ -8712,6 +8800,10 @@ exports.AIPromptRunSchema = zod_1.z.object({
         * * Field Name: OriginalModel
         * * Display Name: Original Model
         * * SQL Data Type: nvarchar(50)`),
+    Judge: zod_1.z.string().nullable().describe(`
+        * * Field Name: Judge
+        * * Display Name: Judge
+        * * SQL Data Type: nvarchar(255)`),
 });
 /**
  * zod schema definition for the entity MJ: AI Vendor Type Definitions
@@ -21755,6 +21847,41 @@ let ConversationDetailEntity = class ConversationDetailEntity extends core_1.Bas
         return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
     }
     /**
+    * Conversation Details - Delete method override to wrap in transaction since CascadeDeletes is true.
+    * Wrapping in a transaction ensures that all cascade delete operations are handled atomically.
+    * @public
+    * @method
+    * @override
+    * @memberof ConversationDetailEntity
+    * @returns {Promise<boolean>} - true if successful, false otherwise
+    */
+    async Delete(options) {
+        if (core_1.Metadata.Provider.ProviderType === core_1.ProviderType.Database) {
+            // For database providers, use the transaction methods directly
+            const provider = core_1.Metadata.Provider;
+            try {
+                await provider.BeginTransaction();
+                const result = await super.Delete(options);
+                if (result) {
+                    await provider.CommitTransaction();
+                    return true;
+                }
+                else {
+                    await provider.RollbackTransaction();
+                    return false;
+                }
+            }
+            catch (error) {
+                await provider.RollbackTransaction();
+                throw error;
+            }
+        }
+        else {
+            // For network providers, cascading deletes are handled server-side
+            return super.Delete(options);
+        }
+    }
+    /**
     * Validate() method override for Conversation Details entity. This is an auto-generated method that invokes the generated validators for this entity for the following fields:
     * * UserRating: This rule ensures that the user rating is between 1 and 10, inclusive. Ratings below 1 or above 10 are not allowed.
     * @public
@@ -22043,6 +22170,41 @@ let ConversationEntity = class ConversationEntity extends core_1.BaseEntity {
         return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
     }
     /**
+    * Conversations - Delete method override to wrap in transaction since CascadeDeletes is true.
+    * Wrapping in a transaction ensures that all cascade delete operations are handled atomically.
+    * @public
+    * @method
+    * @override
+    * @memberof ConversationEntity
+    * @returns {Promise<boolean>} - true if successful, false otherwise
+    */
+    async Delete(options) {
+        if (core_1.Metadata.Provider.ProviderType === core_1.ProviderType.Database) {
+            // For database providers, use the transaction methods directly
+            const provider = core_1.Metadata.Provider;
+            try {
+                await provider.BeginTransaction();
+                const result = await super.Delete(options);
+                if (result) {
+                    await provider.CommitTransaction();
+                    return true;
+                }
+                else {
+                    await provider.RollbackTransaction();
+                    return false;
+                }
+            }
+            catch (error) {
+                await provider.RollbackTransaction();
+                throw error;
+            }
+        }
+        else {
+            // For network providers, cascading deletes are handled server-side
+            return super.Delete(options);
+        }
+    }
+    /**
     * * Field Name: ID
     * * Display Name: ID
     * * SQL Data Type: uniqueidentifier
@@ -34784,6 +34946,192 @@ let AIPromptRunEntity = class AIPromptRunEntity extends core_1.BaseEntity {
         this.Set('RerunFromPromptRunID', value);
     }
     /**
+    * * Field Name: ModelSelection
+    * * Display Name: Model Selection
+    * * SQL Data Type: nvarchar(MAX)
+    * * Description: JSON object containing detailed model selection information including all models considered, their scores, and the selection rationale
+    */
+    get ModelSelection() {
+        return this.Get('ModelSelection');
+    }
+    set ModelSelection(value) {
+        this.Set('ModelSelection', value);
+    }
+    /**
+    * * Field Name: Status
+    * * Display Name: Status
+    * * SQL Data Type: nvarchar(50)
+    * * Default Value: Pending
+    * * Value List Type: List
+    * * Possible Values
+    *   * Pending
+    *   * Running
+    *   * Completed
+    *   * Failed
+    *   * Cancelled
+    * * Description: Current execution status of the prompt run. Valid values: Pending, Running, Completed, Failed, Cancelled
+    */
+    get Status() {
+        return this.Get('Status');
+    }
+    set Status(value) {
+        this.Set('Status', value);
+    }
+    /**
+    * * Field Name: Cancelled
+    * * Display Name: Cancelled
+    * * SQL Data Type: bit
+    * * Default Value: 0
+    * * Description: Indicates whether this prompt run was cancelled before completion
+    */
+    get Cancelled() {
+        return this.Get('Cancelled');
+    }
+    set Cancelled(value) {
+        this.Set('Cancelled', value);
+    }
+    /**
+    * * Field Name: CancellationReason
+    * * Display Name: Cancellation Reason
+    * * SQL Data Type: nvarchar(MAX)
+    * * Description: Detailed reason for cancellation if the prompt run was cancelled. Could be user_requested, timeout, error, or resource_limit
+    */
+    get CancellationReason() {
+        return this.Get('CancellationReason');
+    }
+    set CancellationReason(value) {
+        this.Set('CancellationReason', value);
+    }
+    /**
+    * * Field Name: ModelPowerRank
+    * * Display Name: Model Power Rank
+    * * SQL Data Type: int
+    * * Description: Power rank of the model that was selected for this run. Lower numbers indicate more powerful models
+    */
+    get ModelPowerRank() {
+        return this.Get('ModelPowerRank');
+    }
+    set ModelPowerRank(value) {
+        this.Set('ModelPowerRank', value);
+    }
+    /**
+    * * Field Name: SelectionStrategy
+    * * Display Name: Selection Strategy
+    * * SQL Data Type: nvarchar(50)
+    * * Value List Type: List
+    * * Possible Values
+    *   * Default
+    *   * Specific
+    *   * ByPower
+    * * Description: Strategy used for model selection. Valid values: Default (system default), Specific (specific models configured), ByPower (based on power ranking)
+    */
+    get SelectionStrategy() {
+        return this.Get('SelectionStrategy');
+    }
+    set SelectionStrategy(value) {
+        this.Set('SelectionStrategy', value);
+    }
+    /**
+    * * Field Name: CacheHit
+    * * Display Name: Cache Hit
+    * * SQL Data Type: bit
+    * * Default Value: 0
+    * * Description: Indicates whether this result was served from cache rather than executing a new model call
+    */
+    get CacheHit() {
+        return this.Get('CacheHit');
+    }
+    set CacheHit(value) {
+        this.Set('CacheHit', value);
+    }
+    /**
+    * * Field Name: CacheKey
+    * * Display Name: Cache Key
+    * * SQL Data Type: nvarchar(500)
+    * * Description: Unique key used for caching this prompt result, typically a hash of the prompt and parameters
+    */
+    get CacheKey() {
+        return this.Get('CacheKey');
+    }
+    set CacheKey(value) {
+        this.Set('CacheKey', value);
+    }
+    /**
+    * * Field Name: JudgeID
+    * * Display Name: Judge ID
+    * * SQL Data Type: uniqueidentifier
+    * * Related Entity/Foreign Key: AI Prompts (vwAIPrompts.ID)
+    * * Description: ID of the AIPrompt used as a judge to evaluate and rank multiple parallel execution results
+    */
+    get JudgeID() {
+        return this.Get('JudgeID');
+    }
+    set JudgeID(value) {
+        this.Set('JudgeID', value);
+    }
+    /**
+    * * Field Name: JudgeScore
+    * * Display Name: Judge Score
+    * * SQL Data Type: float(53)
+    * * Description: Score assigned by the judge prompt when evaluating multiple results. Higher scores indicate better results
+    */
+    get JudgeScore() {
+        return this.Get('JudgeScore');
+    }
+    set JudgeScore(value) {
+        this.Set('JudgeScore', value);
+    }
+    /**
+    * * Field Name: WasSelectedResult
+    * * Display Name: Was Selected Result
+    * * SQL Data Type: bit
+    * * Default Value: 0
+    * * Description: Indicates whether this result was selected as the best result when multiple models were run in parallel
+    */
+    get WasSelectedResult() {
+        return this.Get('WasSelectedResult');
+    }
+    set WasSelectedResult(value) {
+        this.Set('WasSelectedResult', value);
+    }
+    /**
+    * * Field Name: StreamingEnabled
+    * * Display Name: Streaming Enabled
+    * * SQL Data Type: bit
+    * * Default Value: 0
+    * * Description: Indicates whether streaming was enabled for this prompt execution
+    */
+    get StreamingEnabled() {
+        return this.Get('StreamingEnabled');
+    }
+    set StreamingEnabled(value) {
+        this.Set('StreamingEnabled', value);
+    }
+    /**
+    * * Field Name: FirstTokenTime
+    * * Display Name: First Token Time
+    * * SQL Data Type: int
+    * * Description: Time in milliseconds from request initiation to receiving the first token from the model
+    */
+    get FirstTokenTime() {
+        return this.Get('FirstTokenTime');
+    }
+    set FirstTokenTime(value) {
+        this.Set('FirstTokenTime', value);
+    }
+    /**
+    * * Field Name: ErrorDetails
+    * * Display Name: Error Details
+    * * SQL Data Type: nvarchar(MAX)
+    * * Description: Detailed error information in JSON format if the prompt execution failed, including stack traces and error codes
+    */
+    get ErrorDetails() {
+        return this.Get('ErrorDetails');
+    }
+    set ErrorDetails(value) {
+        this.Set('ErrorDetails', value);
+    }
+    /**
     * * Field Name: Prompt
     * * Display Name: Prompt
     * * SQL Data Type: nvarchar(255)
@@ -34831,6 +35179,14 @@ let AIPromptRunEntity = class AIPromptRunEntity extends core_1.BaseEntity {
     get OriginalModel() {
         return this.Get('OriginalModel');
     }
+    /**
+    * * Field Name: Judge
+    * * Display Name: Judge
+    * * SQL Data Type: nvarchar(255)
+    */
+    get Judge() {
+        return this.Get('Judge');
+    }
 };
 exports.AIPromptRunEntity = AIPromptRunEntity;
 exports.AIPromptRunEntity = AIPromptRunEntity = __decorate([
@@ -35420,6 +35776,41 @@ let ConversationArtifactVersionEntity = class ConversationArtifactVersionEntity
         return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
     }
     /**
+    * MJ: Conversation Artifact Versions - Delete method override to wrap in transaction since CascadeDeletes is true.
+    * Wrapping in a transaction ensures that all cascade delete operations are handled atomically.
+    * @public
+    * @method
+    * @override
+    * @memberof ConversationArtifactVersionEntity
+    * @returns {Promise<boolean>} - true if successful, false otherwise
+    */
+    async Delete(options) {
+        if (core_1.Metadata.Provider.ProviderType === core_1.ProviderType.Database) {
+            // For database providers, use the transaction methods directly
+            const provider = core_1.Metadata.Provider;
+            try {
+                await provider.BeginTransaction();
+                const result = await super.Delete(options);
+                if (result) {
+                    await provider.CommitTransaction();
+                    return true;
+                }
+                else {
+                    await provider.RollbackTransaction();
+                    return false;
+                }
+            }
+            catch (error) {
+                await provider.RollbackTransaction();
+                throw error;
+            }
+        }
+        else {
+            // For network providers, cascading deletes are handled server-side
+            return super.Delete(options);
+        }
+    }
+    /**
     * Validate() method override for MJ: Conversation Artifact Versions entity. This is an auto-generated method that invokes the generated validators for this entity for the following fields:
     * * Version: This rule ensures that the version number must be greater than zero.
     * @public
@@ -35575,6 +35966,41 @@ let ConversationArtifactEntity = class ConversationArtifactEntity extends core_1
         return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
     }
     /**
+    * MJ: Conversation Artifacts - Delete method override to wrap in transaction since CascadeDeletes is true.
+    * Wrapping in a transaction ensures that all cascade delete operations are handled atomically.
+    * @public
+    * @method
+    * @override
+    * @memberof ConversationArtifactEntity
+    * @returns {Promise<boolean>} - true if successful, false otherwise
+    */
+    async Delete(options) {
+        if (core_1.Metadata.Provider.ProviderType === core_1.ProviderType.Database) {
+            // For database providers, use the transaction methods directly
+            const provider = core_1.Metadata.Provider;
+            try {
+                await provider.BeginTransaction();
+                const result = await super.Delete(options);
+                if (result) {
+                    await provider.CommitTransaction();
+                    return true;
+                }
+                else {
+                    await provider.RollbackTransaction();
+                    return false;
+                }
+            }
+            catch (error) {
+                await provider.RollbackTransaction();
+                throw error;
+            }
+        }
+        else {
+            // For network providers, cascading deletes are handled server-side
+            return super.Delete(options);
+        }
+    }
+    /**
     * * Field Name: ID
     * * Display Name: ID
     * * SQL Data Type: uniqueidentifier
@@ -36787,6 +37213,41 @@ let QueryEntity = class QueryEntity extends core_1.BaseEntity {
         return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
     }
     /**
+    * Queries - Delete method override to wrap in transaction since CascadeDeletes is true.
+    * Wrapping in a transaction ensures that all cascade delete operations are handled atomically.
+    * @public
+    * @method
+    * @override
+    * @memberof QueryEntity
+    * @returns {Promise<boolean>} - true if successful, false otherwise
+    */
+    async Delete(options) {
+        if (core_1.Metadata.Provider.ProviderType === core_1.ProviderType.Database) {
+            // For database providers, use the transaction methods directly
+            const provider = core_1.Metadata.Provider;
+            try {
+                await provider.BeginTransaction();
+                const result = await super.Delete(options);
+                if (result) {
+                    await provider.CommitTransaction();
+                    return true;
+                }
+                else {
+                    await provider.RollbackTransaction();
+                    return false;
+                }
+            }
+            catch (error) {
+                await provider.RollbackTransaction();
+                throw error;
+            }
+        }
+        else {
+            // For network providers, cascading deletes are handled server-side
+            return super.Delete(options);
+        }
+    }
+    /**
     * * Field Name: ID
     * * Display Name: ID
     * * SQL Data Type: uniqueidentifier
@@ -39651,6 +40112,41 @@ let ReportEntity = class ReportEntity extends core_1.BaseEntity {
         return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
     }
     /**
+    * Reports - Delete method override to wrap in transaction since CascadeDeletes is true.
+    * Wrapping in a transaction ensures that all cascade delete operations are handled atomically.
+    * @public
+    * @method
+    * @override
+    * @memberof ReportEntity
+    * @returns {Promise<boolean>} - true if successful, false otherwise
+    */
+    async Delete(options) {
+        if (core_1.Metadata.Provider.ProviderType === core_1.ProviderType.Database) {
+            // For database providers, use the transaction methods directly
+            const provider = core_1.Metadata.Provider;
+            try {
+                await provider.BeginTransaction();
+                const result = await super.Delete(options);
+                if (result) {
+                    await provider.CommitTransaction();
+                    return true;
+                }
+                else {
+                    await provider.RollbackTransaction();
+                    return false;
+                }
+            }
+            catch (error) {
+                await provider.RollbackTransaction();
+                throw error;
+            }
+        }
+        else {
+            // For network providers, cascading deletes are handled server-side
+            return super.Delete(options);
+        }
+    }
+    /**
     * * Field Name: ID
     * * Display Name: ID
     * * SQL Data Type: uniqueidentifier