language-model-common 2.0.76__tar.gz → 2.0.77__tar.gz

{language_model_common-2.0.76/language_model_common.egg-info → language_model_common-2.0.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 2.0.76
+Version: 2.0.77
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0

language_model_common-2.0.77/VERSION

@@ -0,0 +1 @@
+2.0.77

{language_model_common-2.0.76 → language_model_common-2.0.77/language_model_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: language-model-common
-Version: 2.0.76
+Version: 2.0.77
 Summary: Provides the underlying framework to enhance langchain and add loading configurations
 Author-email: Imran Qureshi <imran.qureshi@bwell.com>
 License: Apache-2.0

{language_model_common-2.0.76 → language_model_common-2.0.77}/language_model_common.egg-info/SOURCES.txt

@@ -128,6 +128,12 @@ languagemodelcommon/ocr/ocr_extractor.py
 languagemodelcommon/ocr/ocr_extractor_factory.py
 languagemodelcommon/persistence/__init__.py
 languagemodelcommon/persistence/persistence_factory.py
+languagemodelcommon/pipeline/__init__.py
+languagemodelcommon/pipeline/context.py
+languagemodelcommon/pipeline/pipeline.py
+languagemodelcommon/pipeline/step.py
+languagemodelcommon/pipeline/output/__init__.py
+languagemodelcommon/pipeline/steps/__init__.py
 languagemodelcommon/schema/__init__.py
 languagemodelcommon/schema/openai/__init__.py
 languagemodelcommon/schema/openai/completions.py
@@ -178,6 +184,9 @@ languagemodelcommon/utilities/message_preprocessing/message_preprocessor.py
 languagemodelcommon/utilities/openai/__init__.py
 languagemodelcommon/utilities/openai/responses_api_converter.py
 languagemodelcommon/utilities/security/__init__.py
+languagemodelcommon/utilities/security/normalize.py
+languagemodelcommon/utilities/security/off_topic_detector.py
+languagemodelcommon/utilities/security/prompt_extraction_detector.py
 languagemodelcommon/utilities/security/prompt_sanitizer.py
 languagemodelcommon/utilities/slash_command/__init__.py
 languagemodelcommon/utilities/slash_command/slash_command_handler.py

language_model_common-2.0.77/languagemodelcommon/pipeline/context.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, AsyncGenerator
+
+from langchain_core.messages import AnyMessage
+from langchain_core.runnables import RunnableConfig
+from langgraph.graph.state import CompiledStateGraph
+
+from languagemodelcommon.state.messages_state import MyMessagesState
+from languagemodelcommon.structures.openai.request.chat_request_wrapper import (
+    ChatRequestWrapper,
+)
+from languagemodelcommon.utilities.request_information import RequestInformation
+
+
+@dataclass
+class PipelineContext:
+    """Shared mutable state that flows through all pipeline steps."""
+
+    chat_request_wrapper: ChatRequestWrapper
+    request: Any = None
+
+    request_information: RequestInformation | None = None
+
+    messages: list[AnyMessage] = field(default_factory=list)
+    prior_messages: list[AnyMessage] = field(default_factory=list)
+    previous_context: dict[str, Any] | None = None
+
+    state: MyMessagesState | None = None
+    config: RunnableConfig | None = None
+    graph: CompiledStateGraph[MyMessagesState] | None = None
+
+    content_stream: AsyncGenerator[str, None] | None = None
+
+    accumulated_content: str = ""
+    response_messages: list[AnyMessage] = field(default_factory=list)
+
+    conversation_id: str = ""
+    user_id: str = ""

language_model_common-2.0.77/languagemodelcommon/pipeline/pipeline.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, AsyncGenerator, Protocol
+
+from languagemodelcommon.pipeline.context import PipelineContext
+from languagemodelcommon.pipeline.step import PipelineStep
+
+logger = logging.getLogger(__name__)
+
+
+class OutputStep(Protocol):
+    def format_response(self, *, context: PipelineContext) -> Any: ...
+    def stream_response(
+        self, *, context: PipelineContext
+    ) -> AsyncGenerator[str, None]: ...
+    def format_error(self, *, context: PipelineContext, error: Exception) -> Any: ...
+
+
+class Pipeline:
+    """Runs an ordered list of steps against a shared PipelineContext."""
+
+    def __init__(
+        self,
+        *,
+        pre_execution_steps: list[PipelineStep],
+        execution_step: PipelineStep,
+        post_execution_steps: list[PipelineStep],
+        output_step: OutputStep,
+    ) -> None:
+        self._pre_execution_steps = pre_execution_steps
+        self._execution_step = execution_step
+        self._post_execution_steps = post_execution_steps
+        self._output_step = output_step
+
+    async def run_non_streaming(self, *, context: PipelineContext) -> Any:
+        try:
+            for step in self._pre_execution_steps:
+                await step.run(context=context)
+            await self._execution_step.run(context=context)
+            await self._drain_stream(context=context)
+            for step in self._post_execution_steps:
+                await step.run(context=context)
+            return self._output_step.format_response(context=context)
+        except Exception as e:
+            return self._output_step.format_error(context=context, error=e)
+
+    @staticmethod
+    async def _drain_stream(*, context: PipelineContext) -> None:
+        """Consume content_stream fully, populating accumulated_content and response_messages."""
+        if context.content_stream is None:
+            return
+        import json as _json
+
+        from langchain_core.messages import AIMessage
+
+        async for chunk in context.content_stream:
+            for line in chunk.strip().splitlines():
+                if not line.startswith("data: "):
+                    continue
+                payload = line[6:]
+                if payload == "[DONE]":
+                    continue
+                try:
+                    event = _json.loads(payload)
+                    if "delta" in event and isinstance(event["delta"], str):
+                        context.accumulated_content += event["delta"]
+                    elif (
+                        "choices" in event
+                        and event["choices"]
+                        and "delta" in event["choices"][0]
+                    ):
+                        delta_content = event["choices"][0]["delta"].get("content", "")
+                        if delta_content:
+                            context.accumulated_content += delta_content
+                except (ValueError, KeyError, IndexError):
+                    # Non-content SSE events (tool calls, metadata) don't match
+                    # either delta format — safe to skip during stream draining.
+                    logger.debug(
+                        "Skipping non-content SSE event during drain: %s", payload[:100]
+                    )
+        if context.accumulated_content:
+            context.response_messages = [AIMessage(content=context.accumulated_content)]
+
+    async def run_streaming(
+        self, *, context: PipelineContext
+    ) -> AsyncGenerator[Any, None]:
+        try:
+            for step in self._pre_execution_steps:
+                await step.run(context=context)
+            await self._execution_step.run(context=context)
+        except Exception as e:
+            yield self._output_step.format_error(context=context, error=e)
+            return
+
+        async for chunk in self._output_step.stream_response(context=context):
+            yield chunk
+
+        for step in self._post_execution_steps:
+            await step.run(context=context)

language_model_common-2.0.77/languagemodelcommon/pipeline/step.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from languagemodelcommon.pipeline.context import PipelineContext
+
+
+class PipelineStep(Protocol):
+    """Protocol for a single step in the request processing pipeline."""
+
+    async def run(self, *, context: PipelineContext) -> None: ...

language_model_common-2.0.77/languagemodelcommon/utilities/security/normalize.py

@@ -0,0 +1,100 @@
+"""Input normalization for security detection.
+
+Centralizes Unicode normalization, zero-width stripping, and homoglyph
+mapping so both prompt_extraction_detector and off_topic_detector apply
+consistent pre-processing before regex matching.
+"""
+
+import re
+import unicodedata
+
+REFUSAL_MESSAGE = (
+    "I'm here to help you with your medical records. What can I help you with?"
+)
+
+
+_ZERO_WIDTH_RE = re.compile(
+    "[​‌‍‎‏⁠⁡⁢⁣⁤­]"  # nosec B613
+)
+
+# Cyrillic/Greek characters that visually resemble Latin letters.
+# Covers the practical attack surface for trigger words in our patterns.
+_HOMOGLYPH_MAP: dict[str, str] = {
+    # Cyrillic -> Latin
+    "А": "A",  # А
+    "В": "B",  # В
+    "С": "C",  # С
+    "Е": "E",  # Е
+    "Н": "H",  # Н
+    "К": "K",  # К
+    "М": "M",  # М
+    "О": "O",  # О
+    "Р": "P",  # Р
+    "Т": "T",  # Т
+    "Х": "X",  # Х
+    "а": "a",  # а
+    "е": "e",  # е
+    "о": "o",  # о
+    "р": "p",  # р
+    "с": "c",  # с
+    "у": "y",  # у
+    "х": "x",  # х
+    "ѕ": "s",  # ѕ
+    "і": "i",  # і
+    "ј": "j",  # ј
+    "һ": "h",  # һ
+    "ӏ": "l",  # ӏ
+    # Greek -> Latin
+    "Α": "A",  # Α
+    "Β": "B",  # Β
+    "Ε": "E",  # Ε
+    "Η": "H",  # Η
+    "Ι": "I",  # Ι
+    "Κ": "K",  # Κ
+    "Μ": "M",  # Μ
+    "Ν": "N",  # Ν
+    "Ο": "O",  # Ο
+    "Ρ": "P",  # Ρ
+    "Τ": "T",  # Τ
+    "Υ": "Y",  # Υ
+    "Χ": "X",  # Χ
+    "α": "a",  # α (borderline but used in attacks)
+    "ο": "o",  # ο
+    "ρ": "p",  # ρ (lowercase rho)
+    # Fullwidth Latin -> ASCII Latin
+    # NFKC handles most of these, but belt-and-suspenders for the critical ones
+    "ａ": "a",
+    "ｂ": "b",
+    "ｃ": "c",
+    "ｄ": "d",
+    "ｅ": "e",
+    "ｉ": "i",
+    "ｌ": "l",
+    "ｍ": "m",
+    "ｎ": "n",
+    "ｏ": "o",
+    "ｐ": "p",
+    "ｒ": "r",
+    "ｓ": "s",
+    "ｔ": "t",
+    "ｕ": "u",
+    "ｙ": "y",
+}
+
+_HOMOGLYPH_TRANS = str.maketrans(_HOMOGLYPH_MAP)
+
+
+def normalize_for_detection(*, text: str) -> str:
+    """Normalize user input for security pattern matching.
+
+    Applies in order:
+    1. NFKC Unicode normalization (collapses compatibility equivalents)
+    2. Zero-width character removal
+    3. Homoglyph transliteration (Cyrillic/Greek -> Latin)
+    4. Whitespace collapse
+    """
+    result = unicodedata.normalize("NFKC", text)
+    result = _ZERO_WIDTH_RE.sub("", result)
+    result = result.translate(_HOMOGLYPH_TRANS)
+    result = re.sub(r"\s+", " ", result)
+    return result

language_model_common-2.0.77/languagemodelcommon/utilities/security/off_topic_detector.py

@@ -0,0 +1,96 @@
+"""Detection of off-topic and encoding-based content manipulation attempts."""
+
+import re
+from typing import Optional
+
+from languagemodelcommon.utilities.security.normalize import (
+    REFUSAL_MESSAGE,
+    normalize_for_detection,
+)
+
+
+ENCODING_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(
+        r"\b(decode|encode|convert|translate|interpret)\b.*\b(ascii|base64|hex|binary|unicode|rot13|utf|latin)\b",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"\b(ascii|base64|hex|binary|unicode|rot13|utf|latin)\b.*\b(decode|encode|convert|translate|interpret)\b",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"\b(what(\'s| is| does))\b.*\b(in ascii|in base64|in hex|in binary)\b",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"(\b\d{2,3}\b[\s,]+){5,}",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"\b(respond|answer|reply|output)\b.*\b(in ascii|in base64|in hex|in binary|encoded)\b",
+        re.IGNORECASE,
+    ),
+]
+
+OFFENSIVE_CONTENT_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(
+        r"\b(is\s+(it|this|that)\s+)?(a\s+)?(derogatory|offensive|slur|racial|racist|sexist|hate)\s*(term|word|phrase|language)?\b",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"\b(what|why)\b.*\b(derogatory|offensive|slur|racist|sexist)\b",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"\b(explain|define|tell me about)\b.*\b(slur|derogatory|hate speech|offensive term)\b",
+        re.IGNORECASE,
+    ),
+]
+
+
+class OffTopicAttempt(Exception):
+    """Raised when an off-topic manipulation attempt is detected."""
+
+    def __init__(self, *, category: str) -> None:
+        self.category = category
+        super().__init__(REFUSAL_MESSAGE)
+
+
+def detect_encoding_manipulation(*, text: str) -> Optional[str]:
+    """Check if user input attempts encoding-based content manipulation.
+
+    Returns the matched pattern description if detected, None otherwise.
+    """
+    for pattern in ENCODING_PATTERNS:
+        if pattern.search(text):
+            return pattern.pattern
+    return None
+
+
+def detect_offensive_content_request(*, text: str) -> Optional[str]:
+    """Check if user input requests discussion of offensive language.
+
+    Returns the matched pattern description if detected, None otherwise.
+    """
+    for pattern in OFFENSIVE_CONTENT_PATTERNS:
+        if pattern.search(text):
+            return pattern.pattern
+    return None
+
+
+def detect_off_topic_manipulation(*, text: str) -> Optional[str]:
+    """Check for any off-topic manipulation attempt (encoding or offensive content).
+
+    Returns the category of detection if found, None otherwise.
+    """
+    cleaned = normalize_for_detection(text=text)
+
+    result = detect_encoding_manipulation(text=cleaned)
+    if result:
+        return "encoding_manipulation"
+
+    result = detect_offensive_content_request(text=cleaned)
+    if result:
+        return "offensive_content_request"
+
+    return None

language_model_common-2.0.77/languagemodelcommon/utilities/security/prompt_extraction_detector.py

@@ -0,0 +1,69 @@
+"""Detection of prompt extraction and system instruction disclosure attempts."""
+
+import re
+from typing import Optional
+
+from languagemodelcommon.utilities.security.normalize import (
+    REFUSAL_MESSAGE,
+    normalize_for_detection,
+)
+
+
+class PromptExtractionAttempt(Exception):
+    """Raised when a prompt extraction attempt is detected in user input."""
+
+    def __init__(self) -> None:
+        super().__init__(REFUSAL_MESSAGE)
+
+
+PROMPT_EXTRACTION_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(
+        r"\b(repeat|output|print|show|display|reveal|disclose|give me|write out|put)\b"
+        r".*\b(system prompt|system instructions?|your instructions?|your prompt|the prompt|system message|your configuration|your rules)\b",
+        re.IGNORECASE | re.DOTALL,
+    ),
+    re.compile(
+        r"\b(what are|tell me|share)\b.*\b(your system instructions?|your system prompt|your prompt|your rules|your system message)\b",
+        re.IGNORECASE | re.DOTALL,
+    ),
+    re.compile(
+        r"\b(text|everything|all)\s+(above|before this)\b",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"\bcode\s*block\b.*\b(above|instructions?|prompt|system)\b",
+        re.IGNORECASE | re.DOTALL,
+    ),
+    re.compile(
+        r"\b(above|instructions?|prompt|system)\b.*\bcode\s*block\b",
+        re.IGNORECASE | re.DOTALL,
+    ),
+    re.compile(
+        r"\b(ignore|forget|disregard)\b.*\b(previous|above|prior|instructions?|rules)\b",
+        re.IGNORECASE | re.DOTALL,
+    ),
+    re.compile(
+        r"\b(pretend|act as if|imagine|you are now)\b.*\b(no rules|no restrictions|unrestricted|jailbreak)\b",
+        re.IGNORECASE | re.DOTALL,
+    ),
+    re.compile(
+        r"\binitial\s+(instructions?|prompt|message)\b",
+        re.IGNORECASE,
+    ),
+    re.compile(
+        r"\b(the|your)\s+system\s*(:|message|prompt|instructions?)\b",
+        re.IGNORECASE,
+    ),
+]
+
+
+def detect_prompt_extraction(*, text: str) -> Optional[str]:
+    """Check if user input attempts to extract system instructions.
+
+    Returns the matched pattern description if detected, None otherwise.
+    """
+    normalized = normalize_for_detection(text=text)
+    for pattern in PROMPT_EXTRACTION_PATTERNS:
+        if pattern.search(normalized):
+            return pattern.pattern
+    return None

language_model_common-2.0.76/VERSION

@@ -1 +0,0 @@
-2.0.76