datarobot-moderations 11.1.14__py3-none-any.whl → 11.1.16__py3-none-any.whl

datarobot_dome/constants.py

@@ -69,6 +69,8 @@ LLM_CONTEXT_COLUMN_NAME = "_LLM_CONTEXT"
 PROMPT_TOKEN_COUNT_COLUMN_NAME_FROM_USAGE = "prompt_token_count_from_usage"
 RESPONSE_TOKEN_COUNT_COLUMN_NAME_FROM_USAGE = "response_token_count_from_usage"
 
+SPAN_PREFIX = "datarobot.guard"
+
 
 class TargetType(str, Enum):
     """Target types that may be handed to moderations from DRUM -- casing must align."""

datarobot_dome/drum_integration.py

@@ -26,6 +26,7 @@ from openai.types.chat import ChatCompletionChunk
 from openai.types.chat.chat_completion import ChatCompletion
 from openai.types.chat.chat_completion import Choice
 from openai.types.chat.chat_completion_message import ChatCompletionMessage
+from opentelemetry import trace
 
 from datarobot_dome.chat_helper import add_citations_to_df
 from datarobot_dome.chat_helper import add_token_count_columns_to_df
@@ -57,6 +58,9 @@ from datarobot_dome.pipeline.vdb_pipeline import VDBPipeline
 from datarobot_dome.streaming import ModerationIterator
 from datarobot_dome.streaming import StreamingContextBuilder
 
+tracer = trace.get_tracer(__name__)
+
+
 _logger = logging.getLogger("drum_integration")
 
 
@@ -508,7 +512,7 @@ def build_predictions_df_from_completion(data, pipeline, chat_completion):
         if pipeline_interactions:
             predictions_df[AGENTIC_PIPELINE_INTERACTIONS_ATTR] = pipeline_interactions
         else:
-            predictions_df[AGENTIC_PIPELINE_INTERACTIONS_ATTR] = [np.nan] * len(predictions_df)
+            predictions_df[AGENTIC_PIPELINE_INTERACTIONS_ATTR] = [None] * len(predictions_df)
 
         source_object = chat_completion
     elif isinstance(chat_completion, Iterable):
@@ -661,6 +665,37 @@ def _is_llm_requesting_user_tool_call(completion):
     return False, completion
 
 
+def __get_otel_values(guards_list, stage, result_df):
+    guard_values = {}
+    for guard in guards_list:
+        if not guard.has_average_score_custom_metric():
+            continue
+        guard_metric_column_name = guard.get_metric_column_name(stage)
+        if guard_metric_column_name not in result_df.columns:
+            _logger.warning(f"Missing column: {guard_metric_column_name} in result_df")
+            continue
+        guard_values[guard.get_span_column_name(stage)] = result_df[
+            guard_metric_column_name
+        ].tolist()[0]
+    return guard_values
+
+
+def report_otel_evaluation_set_metric(pipeline, result_df):
+    current_span = trace.get_current_span()
+    if not current_span:
+        _logger.warning("No currently active span found to report evaluation set metric")
+        return
+
+    prompt_values = __get_otel_values(pipeline.get_prescore_guards(), GuardStage.PROMPT, result_df)
+    response_values = __get_otel_values(
+        pipeline.get_postscore_guards(), GuardStage.RESPONSE, result_df
+    )
+
+    final_value = {"prompt_guards": prompt_values, "response_guards": response_values}
+
+    current_span.set_attribute("datarobot.moderation.evaluation", json.dumps(final_value))
+
+
 def guard_chat_wrapper(
     completion_create_params, model, pipeline, drum_chat_fn, association_id=None, **kwargs
 ):
@@ -723,6 +758,7 @@ def guard_chat_wrapper(
             completion = _set_moderation_attribute_to_completion(
                 pipeline, chat_completion, result_df, association_id=association_id
             )
+            report_otel_evaluation_set_metric(pipeline, result_df)
             return completion
 
     replaced_prompt_column_name = f"replaced_{prompt_column_name}"
@@ -802,6 +838,7 @@ def guard_chat_wrapper(
     ) / result_df.shape[0]
 
     response_message, finish_reason = get_response_message_and_finish_reason(pipeline, postscore_df)
+    report_otel_evaluation_set_metric(pipeline, result_df)
 
     final_completion = build_non_streaming_chat_completion(
         response_message, finish_reason, extra_attributes

datarobot_dome/guard.py

@@ -35,6 +35,7 @@ from datarobot_dome.constants import FAITHFULLNESS_COLUMN_NAME
 from datarobot_dome.constants import NEMO_GUARD_COLUMN_NAME
 from datarobot_dome.constants import NEMO_GUARDRAILS_DIR
 from datarobot_dome.constants import ROUGE_1_COLUMN_NAME
+from datarobot_dome.constants import SPAN_PREFIX
 from datarobot_dome.constants import TASK_ADHERENCE_SCORE_COLUMN_NAME
 from datarobot_dome.constants import TOKEN_COUNT_COLUMN_NAME
 from datarobot_dome.constants import AwsModel
@@ -48,11 +49,13 @@ from datarobot_dome.constants import GuardStage
 from datarobot_dome.constants import GuardTimeoutAction
 from datarobot_dome.constants import GuardType
 from datarobot_dome.constants import OOTBType
+from datarobot_dome.guard_helpers import DEFAULT_OPEN_AI_API_VERSION
 from datarobot_dome.guard_helpers import ModerationDeepEvalLLM
 from datarobot_dome.guard_helpers import get_azure_openai_client
 from datarobot_dome.guard_helpers import get_chat_nvidia_llm
 from datarobot_dome.guard_helpers import get_datarobot_endpoint_and_token
-from datarobot_dome.guard_helpers import try_to_fallback_to_llm_gateway
+from datarobot_dome.guard_helpers import get_llm_gateway_client
+from datarobot_dome.guard_helpers import use_llm_gateway_inference
 from datarobot_dome.guards.guard_llm_mixin import GuardLLMMixin
 
 MAX_GUARD_NAME_LENGTH = 255
@@ -141,6 +144,7 @@ guard_intervention_trafaret = t.Dict(
 additional_guard_config_trafaret = t.Dict(
     {
         t.Key("cost", to_name="cost", optional=True): t.Or(cost_metric_trafaret, t.Null),
+        t.Key("tool_call", to_name="tool_call", optional=True): t.Or(t.Any(), t.Null),
     }
 )
 
@@ -366,6 +370,21 @@ class Guard(ABC):
     def get_comparand(self):
         return self.intervention.threshold
 
+    def get_enforced_span_attribute_name(self, stage):
+        intervention_action = self.get_intervention_action()
+        if intervention_action in [GuardAction.BLOCK, GuardAction.REPORT]:
+            return f"{SPAN_PREFIX}.{stage.lower()}.{intervention_action}ed"
+        elif intervention_action == GuardAction.REPLACE:
+            return f"{SPAN_PREFIX}.{stage.lower()}.replaced"
+        else:
+            raise NotImplementedError
+
+    def get_span_column_name(self, _):
+        raise NotImplementedError
+
+    def get_span_attribute_name(self, _):
+        raise NotImplementedError
+
 
 class GuardModelInfo:
     def __init__(self, model_config: dict):
@@ -434,6 +453,15 @@ class ModelGuard(Guard):
             raise NotImplementedError("Missing model_info for model guard")
         return self.get_stage_str(stage) + "_" + self._model_info.target_name
 
+    def get_span_column_name(self, _):
+        if self.model_info is None:
+            raise NotImplementedError("Missing model_info for model guard")
+        # Typically 0th index is the target name
+        return self._model_info.target_name.split("_")[0]
+
+    def get_span_attribute_name(self, stage):
+        return f"{SPAN_PREFIX}.{stage.lower()}.{self.get_span_column_name(stage)}"
+
     def has_average_score_custom_metric(self) -> bool:
         """A couple ModelGuard types do not have an average score metric"""
         return self.model_info.target_type not in [
@@ -459,12 +487,18 @@ class NeMoGuard(Guard, GuardLLMMixin):
         self.openai_api_base = config.get("openai_api_base")
         self.openai_deployment_id = config.get("openai_deployment_id")
         llm_id = None
+        credentials = None
+        use_llm_gateway = use_llm_gateway_inference(self._llm_type)
         try:
             self.openai_api_key = self.get_openai_api_key(config, self._llm_type)
             if self._llm_type != GuardLLMType.NIM and self.openai_api_key is None:
                 raise ValueError("OpenAI API key is required for NeMo Guardrails")
 
             if self.llm_type == GuardLLMType.OPENAI:
+                credentials = {
+                    "credential_type": "openai",
+                    "api_key": self.openai_api_key,
+                }
                 os.environ["OPENAI_API_KEY"] = self.openai_api_key
                 llm = None
             elif self.llm_type == GuardLLMType.AZURE_OPENAI:
@@ -472,6 +506,12 @@ class NeMoGuard(Guard, GuardLLMMixin):
                     raise ValueError("Azure OpenAI API base url is required for LLM Guard")
                 if self.openai_deployment_id is None:
                     raise ValueError("Azure OpenAI deployment ID is required for LLM Guard")
+                credentials = {
+                    "credential_type": "azure_openai",
+                    "api_base": self.openai_api_base,
+                    "api_version": DEFAULT_OPEN_AI_API_VERSION,
+                    "api_key": self.openai_api_key,
+                }
                 azure_openai_client = get_azure_openai_client(
                     openai_api_key=self.openai_api_key,
                     openai_api_base=self.openai_api_base,
@@ -512,15 +552,20 @@ class NeMoGuard(Guard, GuardLLMMixin):
                 raise ValueError(f"Invalid LLMType: {self.llm_type}")
 
         except Exception as e:
-            llm = try_to_fallback_to_llm_gateway(
-                # Currently only OPENAI and AZURE_OPENAI are supported by NeMoGuard
-                # For Bedrock and Vertex the model in the config is actually the LLM ID
-                # For OpenAI we use the default model defined in get_llm_gateway_client
-                # For Azure we use the deployment ID
+            # no valid user credentials provided, raise if not using LLM Gateway
+            credentials = None
+            if not use_llm_gateway:
+                raise e
+
+        if use_llm_gateway:
+            # Currently only OPENAI and AZURE_OPENAI are supported by NeMoGuard
+            # For Bedrock and Vertex the model in the config is actually the LLM ID
+            # For OpenAI we use the default model defined in get_llm_gateway_client
+            # For Azure we use the deployment ID
+            llm = get_llm_gateway_client(
                 llm_id=llm_id,
                 openai_deployment_id=self.openai_deployment_id,
-                llm_type=self.llm_type,
-                e=e,
+                credentials=credentials,
             )
 
         # Use guard stage to determine whether to read from prompt/response subdirectory
@@ -566,6 +611,19 @@ class OOTBGuard(Guard):
         else:
             raise NotImplementedError(f"No metric column name defined for {self._ootb_type} guard")
 
+    def get_span_column_name(self, _):
+        if self._ootb_type == OOTBType.TOKEN_COUNT:
+            return TOKEN_COUNT_COLUMN_NAME
+        elif self._ootb_type == OOTBType.ROUGE_1:
+            return ROUGE_1_COLUMN_NAME
+        elif self._ootb_type == OOTBType.CUSTOM_METRIC:
+            return self.name
+        else:
+            raise NotImplementedError(f"No span attribute name defined for {self._ootb_type} guard")
+
+    def get_span_attribute_name(self, stage):
+        return f"{SPAN_PREFIX}.{stage.lower()}.{self.get_span_column_name(stage)}"
+
 
 class OOTBCostMetric(OOTBGuard):
     def __init__(self, config, stage):
@@ -603,6 +661,12 @@ class OOTBCostMetric(OOTBGuard):
             ),
         }
 
+    def get_span_column_name(self, _):
+        return f"{COST_COLUMN_NAME}.{self.currency.lower()}"
+
+    def get_span_attribute_name(self, _):
+        return f"{SPAN_PREFIX}.{self._stage.lower()}.{self.get_span_column_name(_)}"
+
 
 class FaithfulnessGuard(OOTBGuard, GuardLLMMixin):
     def __init__(self, config: dict, stage=None):
@@ -624,6 +688,12 @@ class FaithfulnessGuard(OOTBGuard, GuardLLMMixin):
     def faithfulness_evaluator(self):
         return self._evaluator
 
+    def get_span_column_name(self, _):
+        return FAITHFULLNESS_COLUMN_NAME
+
+    def get_span_attribute_name(self, _):
+        return f"{SPAN_PREFIX}.{self._stage.lower()}.{self.get_span_column_name(_)}"
+
 
 class AgentGoalAccuracyGuard(OOTBGuard, GuardLLMMixin):
     def __init__(self, config: dict, stage=None):
@@ -645,6 +715,12 @@ class AgentGoalAccuracyGuard(OOTBGuard, GuardLLMMixin):
     def accuracy_scorer(self):
         return self.scorer
 
+    def get_span_column_name(self, _):
+        return AGENT_GOAL_ACCURACY_COLUMN_NAME
+
+    def get_span_attribute_name(self, _):
+        return f"{SPAN_PREFIX}.{self._stage.lower()}.{self.get_span_column_name(_)}"
+
 
 class TaskAdherenceGuard(OOTBGuard, GuardLLMMixin):
     def __init__(self, config: dict, stage=None):
@@ -666,6 +742,12 @@ class TaskAdherenceGuard(OOTBGuard, GuardLLMMixin):
     def task_adherence_scorer(self):
         return self.scorer
 
+    def get_span_column_name(self, _):
+        return TASK_ADHERENCE_SCORE_COLUMN_NAME
+
+    def get_span_attribute_name(self, _):
+        return f"{SPAN_PREFIX}.{self._stage.lower()}.{self.get_span_column_name(_)}"
+
 
 class GuardFactory:
     @classmethod

datarobot_dome/guard_executor.py

@@ -34,7 +34,6 @@ from datarobot_dome.constants import ModerationEventTypes
 from datarobot_dome.constants import OOTBType
 from datarobot_dome.guard import AgentGoalAccuracyGuard
 from datarobot_dome.guard import FaithfulnessGuard
-from datarobot_dome.guard import Guard
 from datarobot_dome.guard import ModelGuard
 from datarobot_dome.guard import NeMoGuard
 from datarobot_dome.guard import OOTBCostMetric
@@ -113,6 +112,25 @@ class AsyncGuardExecutor:
             span.set_attribute("datarobot.moderation.guard.latency", latency)
             if guard.has_latency_custom_metric():
                 self.pipeline.report_guard_latency(guard, latency)
+            if guard.has_average_score_custom_metric():
+                metric_column_name = guard.get_metric_column_name(stage)
+                if metric_column_name in df.columns:
+                    span.set_attribute(
+                        guard.get_span_attribute_name(stage),
+                        df[metric_column_name].tolist()[0],
+                    )
+            if guard.get_intervention_action():
+                (
+                    enforced_column_name,
+                    _,
+                    _,
+                ) = self._get_enforced_and_action_column_names(
+                    guard.get_intervention_action(), self.pipeline.get_input_column(stage)
+                )
+                span.set_attribute(
+                    guard.get_enforced_span_attribute_name(stage),
+                    df[enforced_column_name].tolist()[0],
+                )
 
         return df, latency
 
@@ -204,7 +222,7 @@ class AsyncGuardExecutor:
             # and "Response_toxicity_toxic_PREDICTION", if toxicity is configured for both
             # prompts and responses
             copy_df.rename(
-                columns={metric_column: Guard.get_stage_str(stage) + "_" + metric_column},
+                columns={metric_column: guard.get_metric_column_name(stage)},
                 inplace=True,
             )
         except Exception as ex:

datarobot_dome/guard_helpers.py

@@ -47,7 +47,7 @@ from datarobot_dome.llm import DataRobotLLM
 # but for ROUGE-1 guard, UI allows the user to configure value between
 # 0 and 1, so making scaling factor 1.
 SCALING_FACTOR = 1
-DEFAULT_OPEN_AI_API_VERSION = "2023-03-15-preview"
+DEFAULT_OPEN_AI_API_VERSION = "2024-10-21"
 
 _logger = logging.getLogger(LOGGER_NAME_PREFIX + ".guard_helpers")
 
@@ -195,8 +195,10 @@ def get_llm_gateway_client(
     model: str | None = None,
     llm_id: str | None = None,
     openai_deployment_id: str | None = None,
+    credentials: dict | None = None,
 ) -> ChatOpenAI:
     """The LLM gateway client enables chat completions with DR provided credentials and metering.
+    User provided credentials are optional and passed to the completion request as json string.
 
     Providing model is always required due to openai's chat api.
     llm_id and deployment_id override model if provided.
@@ -208,7 +210,8 @@ def get_llm_gateway_client(
         model=model or "azure/gpt-4o",
         api_key=datarobot_api_token,
         base_url=f"{datarobot_endpoint}/genai/llmgw",
-        max_retries=0,  # retries are handled by the LLM Gateway
+        # retries are handled by the LLM Gateway
+        max_retries=0,
         default_headers={
             # used for metering
             "Client-Id": "moderations",
@@ -217,28 +220,24 @@ def get_llm_gateway_client(
             # optional model overrides
             "deployment_id": openai_deployment_id,
             "llm_id": llm_id,
+            # optional user provided credentials
+            "credential_json": json.dumps(credentials) if credentials else None,
         },
     )
     return client
 
 
-def try_to_fallback_to_llm_gateway(
-    llm_id: str | None,
-    openai_deployment_id: str | None,
-    llm_type: GuardLLMType,
-    e: Exception,
-) -> ChatOpenAI:
-    # USE the LLM gateway if its runtime parameter is available and enabled
-    # DO NOT USE the gateway if user provided credentials are specified
-    # which is the case if no exception was raised trying to create the LLM
-    # DATAROBOT and NIM LLM types are not supported by the gateway
-    if not json.loads(os.environ.get("ENABLE_LLM_GATEWAY_INFERENCE", "false")) or llm_type in [
+def use_llm_gateway_inference(llm_type: GuardLLMType):
+    """
+    USE the LLM gateway if its runtime parameter is available and enabled
+    DATAROBOT and NIM LLM types are not supported by the gateway
+    """
+    if json.loads(os.environ.get("ENABLE_LLM_GATEWAY_INFERENCE", "false")) and llm_type not in [
         GuardLLMType.DATAROBOT,
         GuardLLMType.NIM,
     ]:
-        raise e
-    llm = get_llm_gateway_client(llm_id=llm_id, openai_deployment_id=openai_deployment_id)
-    return llm
+        return True
+    return False
 
 
 def get_azure_openai_client(
@@ -400,7 +399,7 @@ def calculate_agent_goal_accuracy(
     interactions: str,
     response: str,
 ):
-    if interactions is None:
+    if interactions is None or interactions == "":
         # If interactions are missing - we use prompt and response to gauge the
         # goal accuracy
         sample = MultiTurnSample(

datarobot_dome/guards/guard_llm_mixin.py

@@ -22,11 +22,13 @@ from datarobot_dome.constants import SECRET_DEFINITION_PREFIX
 from datarobot_dome.constants import GuardLLMType
 from datarobot_dome.constants import GuardType
 from datarobot_dome.constants import OOTBType
+from datarobot_dome.guard_helpers import DEFAULT_OPEN_AI_API_VERSION
 from datarobot_dome.guard_helpers import get_azure_openai_client
 from datarobot_dome.guard_helpers import get_bedrock_client
 from datarobot_dome.guard_helpers import get_datarobot_llm
+from datarobot_dome.guard_helpers import get_llm_gateway_client
 from datarobot_dome.guard_helpers import get_vertex_client
-from datarobot_dome.guard_helpers import try_to_fallback_to_llm_gateway
+from datarobot_dome.guard_helpers import use_llm_gateway_inference
 
 basic_credential_trafaret = t.Dict(
     {
@@ -156,6 +158,8 @@ class GuardLLMMixin:
         openai_api_base = config.get("openai_api_base")
         openai_deployment_id = config.get("openai_deployment_id")
         llm_id = None
+        credentials = None
+        use_llm_gateway = use_llm_gateway_inference(llm_type)
         try:
             if llm_type in [GuardLLMType.OPENAI, GuardLLMType.AZURE_OPENAI]:
                 openai_api_key = self.get_openai_api_key(config, llm_type)
@@ -163,6 +167,10 @@ class GuardLLMMixin:
                     raise ValueError("OpenAI API key is required for Faithfulness guard")
 
                 if llm_type == GuardLLMType.OPENAI:
+                    credentials = {
+                        "credential_type": "openai",
+                        "api_key": openai_api_key,
+                    }
                     os.environ["OPENAI_API_KEY"] = openai_api_key
                     llm = "default"
                 elif llm_type == GuardLLMType.AZURE_OPENAI:
@@ -170,6 +178,12 @@ class GuardLLMMixin:
                         raise ValueError("OpenAI API base url is required for LLM Guard")
                     if openai_deployment_id is None:
                         raise ValueError("OpenAI deployment ID is required for LLM Guard")
+                    credentials = {
+                        "credential_type": "azure_openai",
+                        "api_key": openai_api_key,
+                        "api_base": openai_api_base,
+                        "api_version": DEFAULT_OPEN_AI_API_VERSION,
+                    }
                     azure_openai_client = get_azure_openai_client(
                         openai_api_key=openai_api_key,
                         openai_api_base=openai_api_base,
@@ -182,9 +196,15 @@ class GuardLLMMixin:
                     raise ValueError("Google model is required for LLM Guard")
                 if config.get("google_region") is None:
                     raise ValueError("Google region is required for LLM Guard")
+                service_account_info = self.get_google_service_account(config)
+                credentials = {
+                    "credential_type": "google_vertex_ai",
+                    "region": config["google_region"],
+                    "service_account_info": service_account_info,
+                }
                 llm = get_vertex_client(
                     google_model=llm_id,
-                    google_service_account=self.get_google_service_account(config),
+                    google_service_account=service_account_info,
                     google_region=config["google_region"],
                 )
             elif llm_type == GuardLLMType.AMAZON:
@@ -194,6 +214,13 @@ class GuardLLMMixin:
                 if config.get("aws_region") is None:
                     raise ValueError("AWS region is required for LLM Guard")
                 credential_config = self.get_aws_account(config)
+                credentials = {
+                    "credential_type": "amazon_bedrock",
+                    "access_key_id": credential_config["aws_access_key_id"],
+                    "secret_access_key": credential_config["aws_secret_access_key"],
+                    "session_token": credential_config["aws_session_token"],
+                    "region": config["aws_region"],
+                }
                 llm = get_bedrock_client(
                     aws_model=llm_id,
                     aws_access_key_id=credential_config["aws_access_key_id"],
@@ -219,14 +246,19 @@ class GuardLLMMixin:
                 raise ValueError(f"Invalid LLMType: {llm_type}")
 
         except Exception as e:
-            llm = try_to_fallback_to_llm_gateway(
-                # For Bedrock and Vertex the model in the config is actually the LLM ID
-                # For OpenAI we use the default model defined in get_llm_gateway_client
-                # For Azure we use the deployment ID
+            # no valid user credentials provided, raise if not using LLM Gateway
+            credentials = None
+            if not use_llm_gateway:
+                raise e
+
+        if use_llm_gateway:
+            # For Bedrock and Vertex the model in the config is actually the LLM ID
+            # For OpenAI we use the default model defined in get_llm_gateway_client
+            # For Azure we use the deployment ID
+            llm = get_llm_gateway_client(
                 llm_id=llm_id,
                 openai_deployment_id=openai_deployment_id,
-                llm_type=llm_type,
-                e=e,
+                credentials=credentials,
             )
 
         return llm

{datarobot_moderations-11.1.14.dist-info → datarobot_moderations-11.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datarobot-moderations
-Version: 11.1.14
+Version: 11.1.16
 Summary: DataRobot Monitoring and Moderation framework
 License: DataRobot Tool and Utility Agreement
 Author: DataRobot

{datarobot_moderations-11.1.14.dist-info → datarobot_moderations-11.1.16.dist-info}/RECORD

@@ -1,13 +1,13 @@
 datarobot_dome/__init__.py,sha256=B5Rx8_CNCNsOpxBbRj27XOXCfRZmvmrAR-NzlzIKnDw,583
 datarobot_dome/async_http_client.py,sha256=wkB4irwvnchNGzO1bk2C_HWM-GOSB3AUn5TXKl-X0ZI,9649
 datarobot_dome/chat_helper.py,sha256=BzvtUyZSZxzOqq-5a2wQKhHhr2kMlcP1MFrHaDAeD_o,9671
-datarobot_dome/constants.py,sha256=vDU7En5Nd1bbfRIr02ReFtzZDqEg4RGCT7gdw3P0LO0,9007
-datarobot_dome/drum_integration.py,sha256=gRn2sQCmRs0RH0tVOdHX6amxGEX1R6WqEtOF2zdBtC4,40693
-datarobot_dome/guard.py,sha256=afcJSSo509aHHvM6nm-QTKzQjuWE7VzgpihenDaAf3w,29921
-datarobot_dome/guard_executor.py,sha256=9SuefqQRpJ_4fFm62YOPixg0Fi9z-mzR5eMPeknBT2Y,34642
-datarobot_dome/guard_helpers.py,sha256=VkNaoMAWAEggodpl7KmWZTM6H9H6e9Ny3Rl2HBXZnfM,16353
+datarobot_dome/constants.py,sha256=mnSa8rUAha4XlsS2lwPmFCkH2RzfSL_MMkErsWHqIbA,9040
+datarobot_dome/drum_integration.py,sha256=nULpLYVMiS5vihfNUyuq-nvZpgXrQibQbVu2UMAscu8,42102
+datarobot_dome/guard.py,sha256=1INYx17n9ToiB5bzI-jIReUUuqkK_ucxpOx4jQLts6g,33264
+datarobot_dome/guard_executor.py,sha256=AOI8MZeZETHMoFgBePe0wa2vE9d2975MYQnEDHLZL7s,35462
+datarobot_dome/guard_helpers.py,sha256=Bfdi8gow2_TAVzRHYUDqEfcG5bWx2KR1dnpxt9E850Y,16311
 datarobot_dome/guards/__init__.py,sha256=B5Rx8_CNCNsOpxBbRj27XOXCfRZmvmrAR-NzlzIKnDw,583
-datarobot_dome/guards/guard_llm_mixin.py,sha256=ON-zuVL3xhQmXv0rFkalWrW_Q67Wwya2IQerHO8WkKU,10694
+datarobot_dome/guards/guard_llm_mixin.py,sha256=VovlpNZjWIGamF4SSvLF5lzOFyApH5IoOiB_qtCmRg0,12216
 datarobot_dome/llm.py,sha256=L02OvTrflmD34-FrfXebfF-zzKTeuin7fpne1Cl5psg,5719
 datarobot_dome/metrics/__init__.py,sha256=B5Rx8_CNCNsOpxBbRj27XOXCfRZmvmrAR-NzlzIKnDw,583
 datarobot_dome/metrics/citation_metrics.py,sha256=q0hTMWuk6wy_jqk2UjFPON3kU94HN3W2vxr9giJ8O8E,3544
@@ -18,6 +18,6 @@ datarobot_dome/pipeline/llm_pipeline.py,sha256=fOp_OJnQMDUJH-LKv12kEqli-EqfHjAiS
 datarobot_dome/pipeline/pipeline.py,sha256=_pZ_4K2LMnfYCYj_ur9EwJzo3T-pbO6lFYz1O-_3uQ4,16491
 datarobot_dome/pipeline/vdb_pipeline.py,sha256=WTOGn1qe_ZvEcdlvHgeXxl2xTqp7GjfL13c6S-FmAfM,5146
 datarobot_dome/streaming.py,sha256=6nYvh6SoxPRLfO6GGdEoHsQuyLP9oX1lDMe8IeGo4lw,17801
-datarobot_moderations-11.1.14.dist-info/METADATA,sha256=39J7-G34lxk7ULqxroi3K0RekSNmaiCnPW5OvvMzWDk,4827
-datarobot_moderations-11.1.14.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-datarobot_moderations-11.1.14.dist-info/RECORD,,
+datarobot_moderations-11.1.16.dist-info/METADATA,sha256=WBOhNlF-pwpbJ2PvlkhwqlKbF3vtWkbNdu6vjqvmvaQ,4827
+datarobot_moderations-11.1.16.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+datarobot_moderations-11.1.16.dist-info/RECORD,,