src/autoresttest/llm/value_generator.py

import json
import random
import string
from collections import defaultdict
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional

import requests

from autoresttest.config import get_config
from autoresttest.models import (
    OperationProperties,
    ParameterKey,
    ParameterProperties,
    RequestData,
    RequestRequirements,
    RequestResponse,
    SchemaProperties,
)
from autoresttest.prompts import (
    ENUM_EXAMPLE_CONSTRAINT_PROMPT,
    FAILED_PARAMETER_MATCHINGS_PROMPT,
    FAILED_PARAMETER_RESPONSE_PROMPT,
    FEWSHOT_PARAMETER_GEN_PROMPT,
    FEWSHOT_REQUEST_BODY_GEN_PROMPT,
    IDENTIFY_AUTHENTICATION_GEN_PROMPT,
    IDENTIFY_AUTHENTICATION_SYSTEM_MESSAGE,
    PARAMETER_NECESSITY_PROMPT,
    PARAMETER_REQUIREMENTS_PROMPT,
    PARAMETERS_GEN_PROMPT,
    PARAMETERS_GEN_SYSTEM_MESSAGE,
    REQUEST_BODY_GEN_PROMPT,
    REQUEST_BODY_GEN_SYSTEM_MESSAGE,
    RETRY_PARAMETER_REQUIREMENTS_PROMPT,
    VALUE_AGENT_BODY_FEWSHOT_PROMPT,
    VALUE_AGENT_PARAMS_FEWSHOT_PROMPT,
    get_informed_agent_body_prompt,
    get_informed_agent_params_prompt,
    get_value_agent_body_prompt,
    get_value_agent_params_prompt,
    template_gen_prompt,
)
from autoresttest.utils import (
    attempt_fix_json,
    param_key_to_label,
    remove_nulls,
)

from .llm import LanguageModel

CONFIG = get_config()


def randomize_boolean():
    return random.choice([True, False])


def randomize_null():
    return None


def randomize_integer():
    percent = random.randint(1, 100)
    if percent <= 60:
        return random.randint(0, 20)
    elif percent <= 90:
        return random.randint(0, 1000)
    else:
        return random.randint(-(2**10), (2**10))


def randomize_float():
    percent = random.randint(1, 100)
    if percent <= 60:
        return random.uniform(0, 20)
    elif percent <= 90:
        return random.uniform(0, 1000)
    else:
        return random.uniform(-(2**10), (2**10))


def randomize_string():
    percent = random.randint(1, 100)
    if percent <= 60:
        length = random.randint(1, 8)
    elif percent <= 90:
        length = random.randint(4, 20)
    else:
        length = random.randint(1, 50)
    return "".join(random.choices(string.ascii_letters + string.digits, k=length))


def randomize_array():
    percent = random.randint(1, 100)
    if percent <= 60:
        length = random.randint(1, 8)
    elif percent <= 90:
        length = random.randint(4, 20)
    else:
        length = random.randint(0, 50)
    return [random.randint(-9999, 9999) for _ in range(length)]


def randomize_object():
    if random.randint(1, 100) <= 90:
        length = random.randint(4, 10)
    else:
        length = random.randint(0, 50)
    return {
        random.choice(string.ascii_letters): random.randint(-9999, 9999)
        for _ in range(length)
    }


def randomized_array_length():
    if random.randint(0, 100) <= 90:
        return random.randint(4, 10)
    else:
        return random.randint(0, 50)


def identify_generator(value: Any):
    generators = {
        "integer": randomize_integer,
        "float": randomize_float,
        "number": randomize_float,
        "boolean": randomize_boolean,
        "string": randomize_string,
        "array": randomize_array,
        "object": randomize_object,
        "null": randomize_null,
    }
    return generators.get(value) or random_generator()


def random_generator():
    generators = {
        "integer": randomize_integer,
        "float": randomize_float,
        "number": randomize_float,
        "boolean": randomize_boolean,
        "string": randomize_string,
        "array": randomize_array,
        "object": randomize_object,
        "null": randomize_null,
    }
    return random.choice(list(generators.values()))


class NaiveValueGenerator:
    def __init__(
        self,
        parameters: Dict[ParameterKey, ParameterProperties],
        request_body: Dict[str, SchemaProperties] | None,
    ):
        self.parameters: Dict[ParameterKey, ParameterProperties] = parameters
        self.request_body: Dict[str, SchemaProperties] | None = request_body

    def generate_value(self, item_properties: SchemaProperties) -> Any:
        if item_properties is None:
            return None

        item_type = getattr(item_properties, "type", None)
        props = getattr(item_properties, "properties", None)
        if props is not None and not isinstance(props, dict):
            props = None
        if item_type == "object" or props is not None:
            return {
                item_name: self.generate_value(prop_schema)
                for item_name, prop_schema in (props or {}).items()
            }
        items = getattr(item_properties, "items", None)
        if not isinstance(items, SchemaProperties):
            items = None
        if item_type == "array":
            if items is not None:
                return [
                    self.generate_value(items) for _ in range(randomized_array_length())
                ]
            else:
                return randomize_array()
        elif items is not None:
            return [
                self.generate_value(items) for _ in range(randomized_array_length())
            ]
        generator = identify_generator(item_type) if item_type else random_generator()
        return generator()

    def generate_parameters(self) -> Dict[ParameterKey, Any]:
        query_parameters = {}
        for parameter_name, parameter_properties in self.parameters.items():
            schema = parameter_properties.schema
            if schema is not None:
                randomized_value = self.generate_value(schema)
            else:
                randomized_value = random_generator()()
            query_parameters[parameter_name] = randomized_value
        return query_parameters

    def generate_request_body(self):
        if not self.request_body:
            return None
        request_properties = {}
        for item_name, item_properties in self.request_body.items():
            randomized_value = self.generate_value(item_properties)
            request_properties[item_name] = randomized_value  # save diff mime types
        return request_properties


@dataclass
class PromptData:
    GEN_PROMPT: str
    FEWSHOT_PROMPT: str
    schema: Dict
    select_params: Dict = field(default_factory=dict)
    is_request_body: bool = False
    response: requests.Response | None = None
    failed_mappings: Dict = field(default_factory=dict)


class SmartValueGenerator:
    def __init__(
        self,
        operation_properties: OperationProperties,
        requirements: Optional[RequestRequirements] = None,
        engine="gpt-4o",
        temperature=CONFIG.creative_temperature,
    ):
        self.operation_properties: OperationProperties = operation_properties
        self.processed_operation = remove_nulls(operation_properties.to_dict())
        self.parameters_raw: Dict[ParameterKey, ParameterProperties] = (
            operation_properties.parameters or {}
        )
        self.parameter_lookup: Dict[str, ParameterKey] = {
            param_key_to_label(key): key for key in self.parameters_raw.keys()
        }
        # Fallback lookup: plain parameter name -> ParameterKey (for when LLM strips ::location suffix)
        self.parameter_name_lookup: Dict[str, ParameterKey] = {
            key[0]: key for key in self.parameters_raw.keys()
        }
        self.parameters: Dict[str, Dict] = {
            label: remove_nulls(param.to_dict())
            for label, param in (
                (param_key_to_label(key), param)
                for key, param in self.parameters_raw.items()
            )
        }
        self.request_body: Dict[str, Dict] | None = self.processed_operation.get(
            "request_body"
        )
        self.summary: str = self.processed_operation.get("summary")
        self.language_model = LanguageModel(temperature=temperature)
        self.parameter_requirements_raw: Dict[ParameterKey, Any] = (
            requirements.parameter_requirements if requirements else {}
        )
        self.parameter_requirements_labels: Dict[str, Any] = {
            param_key_to_label(key): value
            for key, value in self.parameter_requirements_raw.items()
        }
        self.request_body_reqs: Dict[str, Any] = (
            requirements.request_body_requirements if requirements else {}
        )
        self.parameters_reqs: Dict[str, Any] = self.parameter_requirements_labels

    def _format_param_dict_for_prompt(self, params: Optional[Dict]) -> Dict:
        """
        Convert a parameter dict to a format suitable for LLM prompts.

        Accepts dicts with either:
        - ParameterKey tuples as keys (converted via param_key_to_label)
        - String keys (used as-is, e.g., for body property names)

        This dual-type support is intentional since the codebase uses ParameterKey
        for operation parameters but strings for request body properties.
        """
        if not params:
            return {}
        formatted = {}
        for key, value in params.items():
            if isinstance(key, tuple):
                label = param_key_to_label(key)
            else:
                label = str(key)
            formatted[label] = value
        return formatted

    def _compose_parameter_gen_prompt(self, prompt_data: PromptData, necessary=False):
        GEN_PROMPT = prompt_data.GEN_PROMPT
        FEWSHOT_PROMPT = prompt_data.FEWSHOT_PROMPT
        schema = prompt_data.schema
        select_params = prompt_data.select_params
        is_request_body = prompt_data.is_request_body

        prompt = f"{GEN_PROMPT}\n"
        prompt += template_gen_prompt(summary=self.summary, schema=schema)

        if necessary:
            prompt += (
                PARAMETER_NECESSITY_PROMPT + "\n".join(select_params.keys()) + "\n\n"
            )
        else:
            prompt += (
                PARAMETER_REQUIREMENTS_PROMPT + "\n".join(select_params.keys()) + "\n\n"
            )

        prompt += "Reminder:\n" + ENUM_EXAMPLE_CONSTRAINT_PROMPT + "\n"

        if FEWSHOT_PROMPT:
            prompt += "Here are some examples of creating values from specifications:\n"
            prompt += FEWSHOT_PROMPT + "\n"

        if is_request_body:
            prompt += "REQUEST_BODY VALUES:\n"
        else:
            prompt += "PARAMETER VALUES:\n"

        return prompt

    def _compose_retry_parameter_gen_prompt(self, prompt_data: PromptData):
        GEN_PROMPT = prompt_data.GEN_PROMPT
        FEWSHOT_PROMPT = prompt_data.FEWSHOT_PROMPT
        schema = prompt_data.schema
        select_params = prompt_data.select_params
        is_request_body = prompt_data.is_request_body
        response = prompt_data.response
        failed_mappings = prompt_data.failed_mappings

        if not is_request_body:
            failed_mappings = self._format_param_dict_for_prompt(failed_mappings)

        prompt = f"{GEN_PROMPT}\n{FEWSHOT_PROMPT}\n"
        prompt += template_gen_prompt(summary=self.summary, schema=schema)
        prompt += (
            RETRY_PARAMETER_REQUIREMENTS_PROMPT
            + "\n".join(select_params.keys())
            + "\n\n"
        )
        prompt += (
            FAILED_PARAMETER_MATCHINGS_PROMPT
            + json.dumps(failed_mappings, indent=2)
            + "\n"
        )
        if response is not None:
            prompt += FAILED_PARAMETER_RESPONSE_PROMPT + response.text + "\n\n"
        if is_request_body:
            prompt += "REQUEST_BODY VALUES:\n"
        else:
            prompt += "PARAMETERS VALUES:\n"
        # print("Prompt: ", prompt)
        return prompt

    def compose_informed_value_prompt(
        self, prompt_data: PromptData, responses: List[RequestResponse]
    ):
        GEN_PROMPT = prompt_data.GEN_PROMPT
        schema = prompt_data.schema
        is_request_body = prompt_data.is_request_body
        few_shot_prompt = prompt_data.FEWSHOT_PROMPT

        prompt = f"{GEN_PROMPT}\n\n"
        prompt += template_gen_prompt(summary=self.summary, schema=schema)
        if is_request_body:
            prompt += get_informed_agent_body_prompt() + "\n"
            for request_response in responses:
                if request_response is not None:
                    if request_response.request.request_body:
                        prompt += f"PAST REQUEST BODY: {request_response.request.request_body}\n"
                    prompt += f"STATUS CODE: {request_response.response.status_code}\n"
                    prompt += f"RESPONSE: {request_response.response.text[:1000]}\n\n"

        else:
            prompt += get_informed_agent_params_prompt() + "\n"
            for request_response in responses:
                if request_response is not None:
                    formatted_params = self._format_param_dict_for_prompt(
                        request_response.request.parameters
                    )
                    prompt += f"PAST PARAMETERS: {formatted_params}\n"
                    prompt += f"STATUS CODE: {request_response.response.status_code}\n"
                    prompt += f"RESPONSE: {request_response.response.text[:1000]}\n\n"

        prompt += "Regardless of the past responses:"
        prompt += ENUM_EXAMPLE_CONSTRAINT_PROMPT + "\n"

        prompt += "Here are some examples of creating values from specifications:\n"
        prompt += few_shot_prompt + "\n"

        if is_request_body:
            prompt += "REQUEST_BODY VALUES:\n"
        else:
            prompt += "PARAMETER VALUES:\n"
        return prompt

    def _compose_auth_gen_prompt(self, schema):
        prompt = IDENTIFY_AUTHENTICATION_GEN_PROMPT
        prompt += template_gen_prompt(summary=self.summary, schema=schema) + "\n"
        prompt += "AUTHENTICATION PARAMETERS:\n"
        # print("Prompt: ", prompt)
        return prompt

    def _isolate_nonreq_params(self, schema: Dict[str, Dict], is_request_body=False):
        if not isinstance(schema, dict):
            return {}
        nonreq_params = {}
        for param_name, param_properties in schema.items():
            if not is_request_body and param_name not in self.parameters_reqs:
                nonreq_params[param_name] = param_properties
            if is_request_body and param_name not in self.request_body_reqs:
                nonreq_params[param_name] = param_properties
        return nonreq_params

    def _isolate_nonreq_request_body(self, schema: Dict) -> Dict:
        properties = schema.get("properties")
        items = schema.get("items")
        if properties:
            # NOTE: We do not handle nested objects
            nonreq_request_body = self._isolate_nonreq_params(properties)
        elif items:
            nonreq_request_body = self._isolate_nonreq_request_body(items)
        else:
            nonreq_request_body = self._isolate_nonreq_params(schema)
        return nonreq_request_body

    def _form_parameter_gen_prompt(
        self, schema: Dict, is_request_body: bool, necessary: bool = False
    ):
        if is_request_body:
            prompt_data = PromptData(
                GEN_PROMPT=REQUEST_BODY_GEN_PROMPT,
                FEWSHOT_PROMPT=FEWSHOT_REQUEST_BODY_GEN_PROMPT,
                schema=schema,
                select_params=self._isolate_nonreq_request_body(schema),
                is_request_body=is_request_body,
            )
            return self._compose_parameter_gen_prompt(prompt_data, necessary=necessary)
        else:
            prompt_data = PromptData(
                GEN_PROMPT=PARAMETERS_GEN_PROMPT,
                FEWSHOT_PROMPT=FEWSHOT_PARAMETER_GEN_PROMPT,
                schema=schema,
                select_params=self._isolate_nonreq_params(schema),
                is_request_body=is_request_body,
            )
            return self._compose_parameter_gen_prompt(prompt_data, necessary=necessary)

    def _form_retry_parameter_gen_prompt(
        self,
        schema: Dict,
        failed_mappings: Dict,
        response: requests.Response,
        is_request_body: bool,
    ):
        if is_request_body:
            prompt_data = PromptData(
                GEN_PROMPT=REQUEST_BODY_GEN_PROMPT,
                FEWSHOT_PROMPT=FEWSHOT_REQUEST_BODY_GEN_PROMPT,
                schema=schema,
                select_params=self._isolate_nonreq_request_body(schema),
                is_request_body=is_request_body,
                response=response,
                failed_mappings=failed_mappings,
            )
            return self._compose_retry_parameter_gen_prompt(prompt_data)
        else:
            prompt_data = PromptData(
                GEN_PROMPT=PARAMETERS_GEN_PROMPT,
                FEWSHOT_PROMPT=FEWSHOT_PARAMETER_GEN_PROMPT,
                schema=schema,
                select_params=self._isolate_nonreq_params(schema),
                is_request_body=is_request_body,
                response=response,
                failed_mappings=failed_mappings,
            )
            return self._compose_retry_parameter_gen_prompt(prompt_data)

    def _form_value_agent_prompt(
        self, schema: Dict, is_request_body: bool, num_values: int
    ):
        if is_request_body:
            prompt_data = PromptData(
                GEN_PROMPT=get_value_agent_body_prompt(num_values),
                FEWSHOT_PROMPT=VALUE_AGENT_BODY_FEWSHOT_PROMPT,
                schema=schema,
                select_params=self._isolate_nonreq_request_body(schema),
                is_request_body=is_request_body,
            )
            return self._compose_parameter_gen_prompt(prompt_data, necessary=False)
        else:
            prompt_data = PromptData(
                GEN_PROMPT=get_value_agent_params_prompt(num_values),
                FEWSHOT_PROMPT=VALUE_AGENT_PARAMS_FEWSHOT_PROMPT,
                schema=schema,
                select_params=self._isolate_nonreq_params(schema),
                is_request_body=is_request_body,
            )
            return self._compose_parameter_gen_prompt(prompt_data, necessary=True)

    def _validate_parameters(self, schema: Optional[Dict]) -> Dict[ParameterKey, Any]:
        if schema is None:
            return {}
        parameters: Dict[ParameterKey, Any] = {}
        for parameter_name, parameter_value in schema.items():
            param_key = self.parameter_lookup.get(parameter_name)
            if param_key and param_key not in self.parameter_requirements_raw:
                parameters[param_key] = parameter_value
        parameters.update(self.parameter_requirements_raw)
        return parameters

    def generate_parameters(self, necessary=False) -> Optional[Dict[ParameterKey, Any]]:
        """
        Uses the OpenAI language model to generate values for the parameters using JSON outputs
        :return: A dictionary of the generated parameters
        """
        if self.parameters is None or len(self.parameters) == 0:
            return None

        parameter_prompt = self._form_parameter_gen_prompt(
            schema=self.parameters, is_request_body=False, necessary=necessary
        )
        generated_parameters = self.language_model.query(
            user_message=parameter_prompt,
            system_message=PARAMETERS_GEN_SYSTEM_MESSAGE,
            json_mode=True,
        )
        try:
            generated_parameters = json.loads(generated_parameters)
        except json.JSONDecodeError:
            if not generated_parameters or not generated_parameters.strip():
                generated_parameters = {}
            else:
                generated_parameters = attempt_fix_json(generated_parameters)
        parameter_matchings = self._validate_parameters(
            generated_parameters.get("parameters") if isinstance(generated_parameters, dict) else None
        )
        return parameter_matchings

    def validate_request_body(self, schema: Any) -> Any:
        if schema is None:
            return {}
        if type(schema) is dict:
            # NOTE: We do not handle nested objects
            schema.update(self.request_body_reqs)
            return schema
        elif type(schema) is list:
            for i in range(len(schema)):
                schema[i] = self.validate_request_body(schema[i])
        return schema

    def generate_request_body(self, necessary=False) -> Optional[Dict[str, Any]]:
        """
        Uses the OpenAI language model to generate values for the request body using JSON outputs
        :return: A dictionary of the generated request body
        """
        if self.request_body is None or len(self.request_body) == 0:
            return None

        request_body = {}
        for mime_type, schema in self.request_body.items():
            request_body_prompt = self._form_parameter_gen_prompt(
                schema=schema, is_request_body=True, necessary=necessary
            )
            generated_request_body = self.language_model.query(
                user_message=request_body_prompt,
                system_message=REQUEST_BODY_GEN_SYSTEM_MESSAGE,
                json_mode=True,
            )
            try:
                generated_request_body = json.loads(generated_request_body)
            except json.JSONDecodeError:
                if not generated_request_body or not generated_request_body.strip():
                    generated_request_body = {}
                else:
                    generated_request_body = attempt_fix_json(generated_request_body)
            validated_request_body = self.validate_request_body(
                generated_request_body.get("request_body") if isinstance(generated_request_body, dict) else None
            )
            if validated_request_body:  # Only add if we got valid content
                request_body[mime_type] = validated_request_body
        return request_body  # Returns {} if all mime types failed

    def generate_retry_parameters(
        self, failed_request_data: RequestData, response: requests.Response
    ) -> Optional[Dict[ParameterKey, Any]]:
        """
        Uses the OpenAI language model to generate values for the parameters using JSON outputs
        :return: A dictionary of the generated parameters
        """
        if self.parameters is None or len(self.parameters) == 0:
            return None

        parameter_prompt = self._form_retry_parameter_gen_prompt(
            schema=self.parameters,
            failed_mappings=failed_request_data.parameters or {},
            response=response,
            is_request_body=False,
        )
        generated_parameters = self.language_model.query(
            user_message=parameter_prompt,
            system_message=PARAMETERS_GEN_SYSTEM_MESSAGE,
            json_mode=True,
        )
        try:
            generated_parameters = json.loads(generated_parameters)
        except json.JSONDecodeError:
            if not generated_parameters or not generated_parameters.strip():
                generated_parameters = {}
            else:
                generated_parameters = attempt_fix_json(generated_parameters)
        parameter_matchings = self._validate_parameters(
            generated_parameters.get("parameters") if isinstance(generated_parameters, dict) else None
        )
        return parameter_matchings

    def generate_retry_request_body(
        self, failed_request_data: RequestData, response: requests.Response
    ) -> Optional[Dict[str, Any]]:
        """
        Uses the OpenAI language model to generate values for the request body using JSON outputs
        :return: A dictionary of the generated request body
        """
        if self.request_body is None or len(self.request_body) == 0:
            return None

        request_body = {}
        for mime_type, schema in self.request_body.items():
            request_body_prompt = self._form_retry_parameter_gen_prompt(
                schema=schema,
                failed_mappings=(
                    failed_request_data.request_body.get(mime_type, {})
                    if failed_request_data.request_body
                    else {}
                ),
                response=response,
                is_request_body=True,
            )
            generated_request_body = self.language_model.query(
                user_message=request_body_prompt,
                system_message=REQUEST_BODY_GEN_SYSTEM_MESSAGE,
                json_mode=True,
            )
            try:
                generated_request_body = json.loads(generated_request_body)
            except json.JSONDecodeError:
                if not generated_request_body or not generated_request_body.strip():
                    generated_request_body = {}
                else:
                    generated_request_body = attempt_fix_json(generated_request_body)
            validated_request_body = self.validate_request_body(
                generated_request_body.get("request_body") if isinstance(generated_request_body, dict) else None
            )
            if validated_request_body:  # Only add if we got valid content
                request_body[mime_type] = validated_request_body
        return request_body  # Returns {} if all mime types failed

    def determine_auth_params(self):
        """
        Determines if the operation consists of any authentication information sent as parameters in either the query or the request body
        :return:
        """
        auth_prompt = self._compose_auth_gen_prompt(self.processed_operation)
        auth_parameters = self.language_model.query(
            user_message=auth_prompt,
            system_message=IDENTIFY_AUTHENTICATION_SYSTEM_MESSAGE,
            json_mode=True,
        )
        try:
            auth_parameters = json.loads(auth_parameters)
        except json.JSONDecodeError:
            if not auth_parameters or not auth_parameters.strip():
                auth_parameters = {}
            else:
                auth_parameters = attempt_fix_json(auth_parameters)
        return auth_parameters.get("authentication_parameters") if isinstance(auth_parameters, dict) else None

    def _validate_value_params(
        self, schema: Optional[Dict]
    ) -> Dict[ParameterKey, List[Any]]:
        if schema is None:
            return {}
        param_mappings: Dict[ParameterKey, List[Any]] = defaultdict(list)
        for param_name, param_values in schema.items():
            # Try exact match first (e.g., "name::query"), then fallback to plain name (e.g., "name")
            param_key = self.parameter_lookup.get(param_name)
            if param_key is None:
                # Fallback: LLM may have stripped the ::location suffix
                param_key = self.parameter_name_lookup.get(param_name)
            if param_key in self.parameters_raw:
                for param_value in param_values.values():
                    param_mappings[param_key].append(param_value)
        return param_mappings

    def generate_value_agent_params(
        self, num_values: int
    ) -> Dict[ParameterKey, List[Any]]:
        """

        :param num_values:
        :return: A LIST of parameter mappings (dicts) for the operation; should have num_values items in list where each list has the parameter mappings
        """
        if self.parameters is None or len(self.parameters) == 0:
            return {}

        parameter_prompt = self._form_value_agent_prompt(
            schema=self.parameters, is_request_body=False, num_values=num_values
        )
        generated_parameters = self.language_model.query(
            user_message=parameter_prompt,
            system_message=PARAMETERS_GEN_SYSTEM_MESSAGE,
            json_mode=True,
        )
        try:
            generated_parameters = json.loads(generated_parameters)
        except json.JSONDecodeError:
            if not generated_parameters or not generated_parameters.strip():
                generated_parameters = {}
            else:
                generated_parameters = attempt_fix_json(generated_parameters)
        parameter_matchings = self._validate_value_params(
            generated_parameters.get("parameters") if isinstance(generated_parameters, dict) else None
        )
        return parameter_matchings

    def _validate_value_body(self, schema: Optional[Dict]) -> List:
        if schema is None:
            return []
        values = [body for body in schema.values()]
        return values

    def generate_value_agent_body(self, num_values: int) -> Dict[str, List]:
        """

        :param num_values:
        :return: A LIST of request body mappings (dicts) for the operation; should have num_values items in list where each list has the request body mappings
        """
        if self.request_body is None or len(self.request_body) == 0:
            return {}

        request_body = {}
        for mime_type, schema in self.request_body.items():
            request_body_prompt = self._form_value_agent_prompt(
                schema=schema, is_request_body=True, num_values=num_values
            )
            generated_request_body = self.language_model.query(
                user_message=request_body_prompt,
                system_message=REQUEST_BODY_GEN_SYSTEM_MESSAGE,
                json_mode=True,
            )
            try:
                generated_request_body = json.loads(generated_request_body)
            except json.JSONDecodeError:
                if not generated_request_body or not generated_request_body.strip():
                    generated_request_body = {}
                else:
                    generated_request_body = attempt_fix_json(generated_request_body)
            validated_request_body = self._validate_value_body(
                generated_request_body.get("request_body") if isinstance(generated_request_body, dict) else None
            )
            request_body[mime_type] = validated_request_body
        return request_body

    def generate_informed_value_agent_body(
        self, num_values: int, responses: List[RequestResponse]
    ) -> dict[str, Any]:
        if self.request_body is None or len(self.request_body) == 0:
            return {}

        request_body = {}
        for mime_type, schema in self.request_body.items():
            prompt_data = PromptData(
                GEN_PROMPT=get_value_agent_body_prompt(num_values),
                FEWSHOT_PROMPT=VALUE_AGENT_BODY_FEWSHOT_PROMPT,
                schema=schema,
                select_params=self._isolate_nonreq_request_body(schema),
                is_request_body=True,
            )
            request_body_prompt = self.compose_informed_value_prompt(
                prompt_data, responses
            )
            generated_request_body = self.language_model.query(
                user_message=request_body_prompt,
                system_message=REQUEST_BODY_GEN_SYSTEM_MESSAGE,
                json_mode=True,
            )
            try:
                generated_request_body = json.loads(generated_request_body)
            except json.JSONDecodeError:
                if not generated_request_body or not generated_request_body.strip():
                    generated_request_body = {}
                else:
                    print("Handling a JSON decode error...")
                    generated_request_body = attempt_fix_json(generated_request_body)
            validated_request_body = self._validate_value_body(
                generated_request_body.get("request_body") if isinstance(generated_request_body, dict) else None
            )
            request_body[mime_type] = validated_request_body
        return request_body

    def generate_informed_value_agent_params(
        self, num_values: int, responses: List[RequestResponse]
    ) -> Dict[ParameterKey, List[Any]]:
        if self.parameters is None or len(self.parameters) == 0:
            return {}

        prompt_data = PromptData(
            GEN_PROMPT=get_value_agent_params_prompt(num_values),
            FEWSHOT_PROMPT=VALUE_AGENT_PARAMS_FEWSHOT_PROMPT,
            schema=self.parameters,
            select_params=self._isolate_nonreq_params(self.parameters),
            is_request_body=False,
        )
        parameter_prompt = self.compose_informed_value_prompt(prompt_data, responses)
        generated_parameters = self.language_model.query(
            user_message=parameter_prompt,
            system_message=PARAMETERS_GEN_SYSTEM_MESSAGE,
            json_mode=True,
        )
        try:
            generated_parameters = json.loads(generated_parameters)
        except json.JSONDecodeError:
            if not generated_parameters or not generated_parameters.strip():
                generated_parameters = {}
            else:
                generated_parameters = attempt_fix_json(generated_parameters)
        parameter_matchings = self._validate_value_params(
            generated_parameters.get("parameters") if isinstance(generated_parameters, dict) else None
        )
        return parameter_matchings