time_fmt = "%Y-%m-%d %H:%M:%S"
time_pattern = r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$"
class DataSoilDashboardQueryPayloadTimeShift(BaseModel):
    shiftInterval: list[PositiveInt] = Field(description="Each element in the array represents a time offset relative to the query timestamp for individual time comparison analysis. If time comparison analysis dose not described, keep it **VOID**.",max_length=2,default=[])
    timeUnit: Literal["DAY"] = Field(default="DAY",description="The unit of specific comparison time offset. This is the description about each value of unit:" +
        "Unit **DAY** represents one day."
    )
class DataSoilDashboardQueryPayloadQueryParamWhereFilter(BaseModel):
    field: str = Field(description="The dimension **CODE** in the selected dimension list that requires enums filtering or pattern filtering.")
    operator: Literal["IN", "NI", "LIKE", "NOT_LIKE"] = Field(description="Operators for enums filtering or pattern filtering. This is the description about each value of operator: " +
        "The **IN** operator represents enums filtering and can be described as sql 'WHERE <dimension> IN <enums>'. " +
        "The **NI** operator represents enums filtering and can be described as sql 'WHERE <dimension> NOT IN <enums>'. " +
        "The **LIKE** operator represents pattern filtering and can be described as sql 'WHERE <dimension> LIKE %<pattern>%'. " +
        "The **NOT_LIKE** operator represents pattern filtering and can be described as sql 'WHERE <dimension> NOT LIKE %<pattern>%'."
    )
    value: list[str] = Field(description="If for enums filtering, every element represents th practical enums of the dimension. Otherwise for pattern filtering, only **one** element is required and it represents a wildcard pattern.",min_length=1)
    @field_validator("field")
    def field_block(cls, v: str, info: ValidationInfo) -> str:
        if v == "dt":
            raise ValueError("Instruction: The time filtering should be described in 'time' field, not in the 'filters' field.")
        return v
    @field_validator("value")
    def value_block(cls, v: Optional[list[str]], info: ValidationInfo) -> Optional[list[str]]:
        if info.data["operator"] in {"LIKE", "NOT_LIKE"} and len(v) > 1:
            raise ValueError("Instruction: For pattern filtering, the size of 'value' in 'where' must be **ONE**.")
        return v
class DataSoilDashboardQueryPayloadQueryParamWhere(BaseModel):
    time: list[Union[str, int]] = Field(
        description="The target time range which is **left closed and right opened** for the query, **excluding** the comparison periods required for time comparison analysis. " +
            f"The first element is start time, precise to second, a string formatted as **{time_fmt}**. The final time interval **include** this value. " +
            f"The last element is end time, precise to second, a string formatted as **{time_fmt}**. The final time interval **exclude** this value.",
        min_length=2,
        max_length=2,
    )
    filters: list[DataSoilDashboardQueryPayloadQueryParamWhereFilter] = Field(description="Enums filtering or pattern filtering condition of dimension in the dimensions list. Metric's filtering and time's filtering is **forbidden**.")
    relation: Literal["AND"] = Field(description="Boolean relationships between filters across multiple dimensions. This is the description about each value of relation: " +
        "The **AND** represents boolean logic **and**."
    )
    @field_validator("time")
    def value_block(cls, v: list[Union[int, str]], info: ValidationInfo) -> list[Union[int, str]]:
        if isinstance(v[0], str) and not re.search(time_pattern, v[0]):
            raise ValueError(f"Instruction: the start time of time range must be formatted as **{time_fmt}**")
        if isinstance(v[1], str) and not re.search(time_pattern, v[1]):
            raise ValueError(f"Instruction: the end time of time range must be formatted as **{time_fmt}**")
        return v
class DataSoilDashboardQueryPayloadQueryParamOrderBy(BaseModel):
    field: str = Field(description="The metric **CODE** in the selected metric list that requires metric sorting.")
    direction: Literal["ASC", "DESC"] = Field(description="Sorting direction for specified metric. The **ASC** represents ascending order by metric values, while the **DESC** represents descending order by metric values.")
    shift: int = Field(default=0)
    limit: int = Field(description="The number of rows to return from the dataset after sorting by the designated metric.",default=50)
class DataSoilDashboardQueryPayloadQueryParamGroupBy(BaseModel):
    field: str = Field(description="The dimension **CODE** in the selected dimension list for dimension grouping analysis.")
    extendFields: list[str] = Field(default=[])
    orderBy: Optional[DataSoilDashboardQueryPayloadQueryParamOrderBy] = Field(description="Sorting config for query results based on a specific **metric**. Dimension sorting is forbidden.",default=None)
class DataSoilDashboardQueryPayloadQueryParam(BaseModel):
    queryType: Literal["DETAIL_TABLE"] = Field(description="This is the description about each value of queryType: " +
        "The **DETAIL_TABLE​​** displays metrics grouped by each unique dimension combination where the levels of all grouped dimensions are the same."
    )
    interval: DashboardInterval = Field(description="The time granularity for time-based grouping analysis. This is the description about each value of granularity: " +
        "The **BY_ONE_MINUTE** represents aggregating time at one-minute intervals. " +
        "The **BY_FIVE_MINUTE** represents aggregating time at five-minute intervals. " +
        "The **BY_HOUR** represents aggregating time at one-hour intervals. " +
        "The **BY_DAY** represents aggregating time at one-day intervals. " +
        "The **BY_WEEK** represents aggregating time at one-week intervals. " +
        "The **BY_MONTH** represents aggregating time at one-month intervals. " +
        "The **SUM** represents NOT aggregating time."
    )
    resultField: list[str] = Field(default=[])
    where: DataSoilDashboardQueryPayloadQueryParamWhere = Field(description="Filtering condition for dimensions. Including target time range and enums filtering or pattern filtering for non-time dimensions.")
    groupBy: list[DataSoilDashboardQueryPayloadQueryParamGroupBy] = Field(description="A list of dimensions grouping analysis info derived from the dimensions list. If these dimensions require roll-up, a sorting config for each dimension is also required, otherwise all sorting config should be **VOID**. The sorting config specifies the ordering of rolled-up dimensional data when the dimension is the lowest-level among all non-aggregated dimensions.")
    orderBy: DataSoilDashboardQueryPayloadQueryParamOrderBy = Field(description="Sorting config for query results based on a specific **metric**. Dimension sorting is forbidden.")
    heavyQuery: bool = Field(default=False)
    @field_validator("groupBy")
    def groupBy_block(cls, v: list[DataSoilDashboardQueryPayloadQueryParamGroupBy], info: ValidationInfo) -> list[DataSoilDashboardQueryPayloadQueryParamGroupBy]:
        if "dt" in {e.field for e in v}:
            if info.data["interval"] == "SUM":
                raise ValueError("Instruction: the interval can not be **SUM** when **time-based grouping is required**.")
        else:
            if info.data["interval"] != "SUM":
                raise ValueError("Instruction: the interval must be **SUM** when **time-based grouping is not required**.")
        return v

class DataSoilDashboardQueryPayload(BaseModel):
    model_config = ConfigDict(
        frozen=False,
    )
    apiCode: str = Field(default="")
    requestId: str = Field(default="")
    applicationCode: str = Field(default="")
    applicationToken: str = Field(default="")
    debug: bool = Field(default=False)
    timeShift: DataSoilDashboardQueryPayloadTimeShift = Field(description="Time comparison analysis config.",default=DataSoilDashboardQueryPayloadTimeShift())
    dynamicQueryParam: DataSoilDashboardQueryPayloadQueryParam
    forceFlush: bool = Field(default=False)


@tool(response_format="content_and_artifact")
def query_datasoil_data_tool(payload: DataSoilDashboardQueryPayload, state: Annotated[dict, InjectedState]) -> Tuple[str, dict]:
    <any code>

generation_llm_with_tools = generation_llm.bind_tools(
    tools=[DataSoilDashboardQueryPayload],
    tool_choice=DataSoilDashboardQueryPayload.__name__,
)

generation_llm_with_tools.invoke([HumanMessage(content="any message")])