Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

17.5 KB
Raw Blame
from __future__ import annotations

import dataclasses
from collections.abc import Mapping
from typing import Any, Protocol, overload, override

from configs import dify_config
from graphon.file import File
from graphon.nodes.variable_assigner.common.helpers import UpdatedVariable
from graphon.variables.segments import (
    ArrayFileSegment,
    ArraySegment,
    BooleanSegment,
    FileSegment,
    FloatSegment,
    IntegerSegment,
    NoneSegment,
    ObjectSegment,
    Segment,
    StringSegment,
)
from graphon.variables.utils import dumps_with_segments

_MAX_DEPTH = 100


class _QAKeys:
    """dict keys for _QAStructure"""

    QA_CHUNKS = "qa_chunks"
    QUESTION = "question"
    ANSWER = "answer"


class _PCKeys:
    """dict keys for _ParentChildStructure"""

    PARENT_MODE = "parent_mode"
    PARENT_CHILD_CHUNKS = "parent_child_chunks"
    PARENT_CONTENT = "parent_content"
    CHILD_CONTENTS = "child_contents"


@dataclasses.dataclass(frozen=True)
class _PartResult[T]:
    value: T
    value_size: int
    truncated: bool


class MaxDepthExceededError(Exception):
    pass


class UnknownTypeError(Exception):
    pass


type JSONTypes = int | float | str | list[object] | dict[str, object] | None | bool


@dataclasses.dataclass(frozen=True)
class TruncationResult:
    result: Segment
    truncated: bool


class BaseTruncator(Protocol):
    """Protocol for variable truncation strategies."""

    def truncate(self, segment: Segment) -> TruncationResult: ...

    def truncate_variable_mapping(self, v: Mapping[str, Any]) -> tuple[Mapping[str, Any], bool]: ...


class VariableTruncator(BaseTruncator):
    """
    Handles variable truncation with structure-preserving strategies.

    This class implements intelligent truncation that prioritizes maintaining data structure
    integrity while ensuring the final size doesn't exceed specified limits.

    Uses recursive size calculation to avoid repeated JSON serialization.
    """

    def __init__(
        self,
        string_length_limit=5000,
        array_element_limit: int = 20,
        max_size_bytes: int = 1024_000,  # 1000 KiB
    ):
        if string_length_limit <= 3:
            raise ValueError("string_length_limit should be greater than 3.")
        self._string_length_limit = string_length_limit

        if array_element_limit <= 0:
            raise ValueError("array_element_limit should be greater than 0.")
        self._array_element_limit = array_element_limit

        if max_size_bytes <= 0:
            raise ValueError("max_size_bytes should be greater than 0.")
        self._max_size_bytes = max_size_bytes

    @classmethod
    def default(cls) -> VariableTruncator:
        return VariableTruncator(
            max_size_bytes=dify_config.WORKFLOW_VARIABLE_TRUNCATION_MAX_SIZE,
            array_element_limit=dify_config.WORKFLOW_VARIABLE_TRUNCATION_ARRAY_LENGTH,
            string_length_limit=dify_config.WORKFLOW_VARIABLE_TRUNCATION_STRING_LENGTH,
        )

    @override
    def truncate_variable_mapping(self, v: Mapping[str, Any]) -> tuple[Mapping[str, Any], bool]:
        """
        `truncate_variable_mapping` is responsible for truncating variable mappings
        generated during workflow execution, such as `inputs`, `process_data`, or `outputs`
        of a WorkflowNodeExecution record. This ensures the mappings remain within the
        specified size limits while preserving their structure.
        """
        budget = self._max_size_bytes
        is_truncated = False
        truncated_mapping: dict[str, Any] = {}
        length = len(v.items())
        used_size = 0
        for key, value in v.items():
            used_size += self.calculate_json_size(key)
            if used_size > budget:
                truncated_mapping[key] = "..."
                is_truncated = True
                continue
            value_budget = (budget - used_size) // (length - len(truncated_mapping))
            if isinstance(value, Segment):
                part_result = self._truncate_segment(value, value_budget)
            else:
                part_result = self._truncate_json_primitives(value, value_budget)
            is_truncated = is_truncated or part_result.truncated
            truncated_mapping[key] = part_result.value
            used_size += part_result.value_size
        return truncated_mapping, is_truncated

    @staticmethod
    def _segment_need_truncation(segment: Segment) -> bool:
        return not isinstance(
            segment, (NoneSegment, FloatSegment, IntegerSegment, FileSegment, BooleanSegment, ArrayFileSegment)
        )

    @staticmethod
    def _json_value_needs_truncation(value: Any) -> bool:
        if value is None:
            return False
        return not isinstance(value, (bool, int, float))

    @override
    def truncate(self, segment: Segment) -> TruncationResult:
        if isinstance(segment, StringSegment):
            result = self._truncate_segment(segment, self._string_length_limit)
        else:
            result = self._truncate_segment(segment, self._max_size_bytes)

        if result.value_size > self._max_size_bytes:
            if isinstance(result.value, StringSegment):
                fallback_result = self._truncate_string(result.value.value, self._max_size_bytes)
                return TruncationResult(StringSegment(value=fallback_result.value), True)

            # Apply final fallback - convert to JSON string and truncate
            json_str = dumps_with_segments(result.value)
            if len(json_str) > self._max_size_bytes:
                json_str = json_str[: self._max_size_bytes] + "..."
            return TruncationResult(result=StringSegment(value=json_str), truncated=True)

        return TruncationResult(
            result=segment.model_copy(update={"value": result.value.value}), truncated=result.truncated
        )

    def _truncate_segment(self, segment: Segment, target_size: int) -> _PartResult[Segment]:
        """
        Apply smart truncation to a variable value.

        Args:
            value: The value to truncate (can be Segment or raw value)

        Returns:
            TruncationResult with truncated data and truncation status
        """

        if not VariableTruncator._segment_need_truncation(segment):
            return _PartResult(segment, self.calculate_json_size(segment.value), False)

        result: _PartResult[Any]
        # Apply type-specific truncation with target size
        match segment:
            case ArraySegment():
                result = self._truncate_array(segment.value, target_size)
            case StringSegment():
                result = self._truncate_string(segment.value, target_size)
            case ObjectSegment():
                result = self._truncate_object(segment.value, target_size)
            case _:
                raise AssertionError("this should be unreachable.")

        return _PartResult(
            value=segment.model_copy(update={"value": result.value}),
            value_size=result.value_size,
            truncated=result.truncated,
        )

    @staticmethod
    def calculate_json_size(value: Any, depth=0) -> int:
        """Recursively calculate JSON size without serialization."""
        if isinstance(value, Segment):
            return VariableTruncator.calculate_json_size(value.value)
        if isinstance(value, UpdatedVariable):
            # TODO(Workflow): migrate UpdatedVariable serialization upstream and drop this fallback.
            return VariableTruncator.calculate_json_size(value.model_dump(), depth=depth + 1)
        if depth > _MAX_DEPTH:
            raise MaxDepthExceededError()
        match value:
            case str():
                # Ideally, the size of strings should be calculated based on their utf-8 encoded length.
                # However, this adds complexity as we would need to compute encoded sizes consistently
                # throughout the code. Therefore, we approximate the size using the string's length.
                # Rough estimate: number of characters, plus 2 for quotes
                return len(value) + 2
            case bool():
                return 4 if value else 5  # "true" or "false"
            case int() | float():
                return len(str(value))
            case None:
                return 4  # "null"
            case list():
                # Size = sum of elements + separators + brackets
                total = 2  # "[]"
                for i, item in enumerate(value):
                    if i > 0:
                        total += 1  # ","
                    total += VariableTruncator.calculate_json_size(item, depth=depth + 1)
                return total
            case dict():
                # Size = sum of keys + values + separators + brackets
                total = 2  # "{}"
                for index, key in enumerate(value.keys()):
                    if index > 0:
                        total += 1  # ","
                    total += VariableTruncator.calculate_json_size(str(key), depth=depth + 1)  # Key as string
                    total += 1  # ":"
                    total += VariableTruncator.calculate_json_size(value[key], depth=depth + 1)
                return total
            case File():
                return VariableTruncator.calculate_json_size(value.model_dump(), depth=depth + 1)
            case _:
                raise UnknownTypeError(f"got unknown type {type(value)}")

    def _truncate_string(self, value: str, target_size: int) -> _PartResult[str]:
        if (size := self.calculate_json_size(value)) < target_size:
            return _PartResult(value, size, False)
        if target_size < 5:
            return _PartResult("...", 5, True)
        truncated_size = min(self._string_length_limit, target_size - 5)
        truncated_value = value[:truncated_size] + "..."
        return _PartResult(truncated_value, self.calculate_json_size(truncated_value), True)

    def _truncate_array(self, value: list[object], target_size: int) -> _PartResult[list[object]]:
        """
        Truncate array with correct strategy:
        1. First limit to 20 items
        2. If still too large, truncate individual items
        """

        truncated_value: list[object] = []
        truncated = False
        used_size = self.calculate_json_size([])

        target_length = self._array_element_limit

        for i, item in enumerate(value):
            # ``File`` is routed through ``_truncate_json_primitives`` (whose
            # dedicated ``File`` branch returns the file as-is with its real
            # serialized size). That preserves the count cap
            # (``array_element_limit``) and the byte budget (``target_size``)
            # for ``list[File]`` — the original "Dirty fix" branch above this
            # loop bypassed both guarantees and reported ``used_size=2`` even
            # when the returned array serialized to well over the budget.
            # See https://github.com/langgenius/dify/issues/39218.
            if i >= target_length:
                return _PartResult(truncated_value, used_size, True)
            if i > 0:
                used_size += 1  # Account for comma

            if used_size > target_size:
                break

            remaining_budget = target_size - used_size
            if item is None or isinstance(item, (str, list, dict, bool, int, float, File, UpdatedVariable)):
                part_result = self._truncate_json_primitives(item, remaining_budget)
            else:
                raise UnknownTypeError(f"got unknown type {type(item)} in array truncation")
            truncated_value.append(part_result.value)
            used_size += part_result.value_size
            truncated = part_result.truncated
        return _PartResult(truncated_value, used_size, truncated)

    @classmethod
    def _maybe_qa_structure(cls, m: Mapping[str, Any]) -> bool:
        qa_chunks = m.get(_QAKeys.QA_CHUNKS)
        if qa_chunks is None:
            return False
        return isinstance(qa_chunks, list)

    @classmethod
    def _maybe_parent_child_structure(cls, m: Mapping[str, Any]) -> bool:
        parent_mode = m.get(_PCKeys.PARENT_MODE)
        if parent_mode is None:
            return False
        if not isinstance(parent_mode, str):
            return False
        parent_child_chunks = m.get(_PCKeys.PARENT_CHILD_CHUNKS)
        if parent_child_chunks is None:
            return False
        return isinstance(parent_child_chunks, list)

    def _truncate_object(self, mapping: Mapping[str, Any], target_size: int) -> _PartResult[Mapping[str, Any]]:
        """
        Truncate object with key preservation priority.

        Strategy:
        1. Keep all keys, truncate values to fit within budget
        2. If still too large, drop keys starting from the end
        """
        if not mapping:
            return _PartResult(mapping, self.calculate_json_size(mapping), False)

        truncated_obj = {}
        truncated = False
        used_size = self.calculate_json_size({})

        # Sort keys to ensure deterministic behavior
        sorted_keys = sorted(mapping.keys())

        for i, key in enumerate(sorted_keys):
            if used_size > target_size:
                # No more room for additional key-value pairs
                truncated = True
                break

            pair_size = 0

            if i > 0:
                pair_size += 1  # Account for comma

            # Calculate budget for this key-value pair
            # do not try to truncate keys, as we want to keep the structure of
            # object.
            key_size = self.calculate_json_size(key) + 1  # +1 for ":"
            pair_size += key_size
            remaining_pairs = len(sorted_keys) - i
            value_budget = max(0, (target_size - pair_size - used_size) // remaining_pairs)

            if value_budget <= 0:
                truncated = True
                break

            # Truncate the value to fit within budget
            value = mapping[key]
            if isinstance(value, Segment):
                value_result = self._truncate_segment(value, value_budget)
            else:
                value_result = self._truncate_json_primitives(mapping[key], value_budget)

            truncated_obj[key] = value_result.value
            pair_size += value_result.value_size
            used_size += pair_size

            if value_result.truncated:
                truncated = True

        return _PartResult(truncated_obj, used_size, truncated)

    @overload
    def _truncate_json_primitives(
        self, val: UpdatedVariable, target_size: int
    ) -> _PartResult[Mapping[str, object]]: ...

    @overload
    def _truncate_json_primitives(self, val: str, target_size: int) -> _PartResult[str]: ...

    @overload
    def _truncate_json_primitives(self, val: list[object], target_size: int) -> _PartResult[list[object]]: ...

    @overload
    def _truncate_json_primitives(self, val: dict[str, object], target_size: int) -> _PartResult[dict[str, object]]: ...

    @overload
    def _truncate_json_primitives(self, val: bool, target_size: int) -> _PartResult[bool]: ...  # type: ignore

    @overload
    def _truncate_json_primitives(self, val: int, target_size: int) -> _PartResult[int]: ...

    @overload
    def _truncate_json_primitives(self, val: float, target_size: int) -> _PartResult[float]: ...

    @overload
    def _truncate_json_primitives(self, val: None, target_size: int) -> _PartResult[None]: ...

    @overload
    def _truncate_json_primitives(self, val: File, target_size: int) -> _PartResult[File]: ...

    def _truncate_json_primitives(
        self,
        val: UpdatedVariable | File | str | list[object] | dict[str, object] | bool | int | float | None,
        target_size: int,
    ) -> _PartResult[Any]:
        """Truncate a value within an object to fit within budget."""
        match val:
            case UpdatedVariable():
                # TODO(Workflow): push UpdatedVariable normalization closer to its producer.
                return self._truncate_object(val.model_dump(), target_size)
            case str():
                return self._truncate_string(val, target_size)
            case list():
                return self._truncate_array(val, target_size)
            case dict():
                return self._truncate_object(val, target_size)
            case File():
                # File objects should not be truncated, return as-is
                return _PartResult(val, self.calculate_json_size(val), False)
            case None | bool() | int() | float():
                return _PartResult(val, self.calculate_json_size(val), False)
            case _:
                raise AssertionError("this statement should be unreachable.")


class DummyVariableTruncator(BaseTruncator):
    """
    A no-op variable truncator that doesn't truncate any data.

    This is used for Service API calls where truncation should be disabled
    to maintain backward compatibility and provide complete data.
    """

    @override
    def truncate_variable_mapping(self, v: Mapping[str, Any]) -> tuple[Mapping[str, Any], bool]:
        """
        Return original mapping without truncation.

        Args:
            v: The variable mapping to process

        Returns:
            Tuple of (original_mapping, False) where False indicates no truncation occurred
        """
        return v, False

    @override
    def truncate(self, segment: Segment) -> TruncationResult:
        """
        Return original segment without truncation.

        Args:
            segment: The segment to process

        Returns:
            The original segment unchanged
        """
        # For Service API, we want to preserve the original segment
        # without any truncation, so just return it as-is
        return TruncationResult(result=segment, truncated=False)