Strange Tool Outputs to Inputs Conversion

[jacobreesmontgomery]

Background

I have a Foundry agent equipped with four different user-defined tools to enable natural language querying. In this case, I am instructing the agent to call on the tools in a specified, sequential order. Each of these tools returns a JSON-formatted string, and in some cases, I want to convert this JSON-formatted string to its Pydantic model equivalent at the beginning of the given tool. Importantly, these JSON-formatted strings, which are returned from each tool, are then ingested via a string argument in the next tool.

Here are the method signatures of each tool for further context:

async def _determine_relevant_tables_and_cols(
        self,
        user_question: str,
    ) -> str:
        """
        Determine the relevant tables and columns for the user's question.

        :param user_question: The user's question to be processed.
        :type user_question: str

        :return: A JSON string containing the relevant tables and columns.
        :rtype: str
        """

async def _prune_irrelevant_columns_from_database_schema(
        self,
        relevant_tables_and_cols: str,
    ) -> str:
        """
        Prune irrelevant columns from the provided database schema metadata.

        :param relevant_tables_and_cols: A JSON string containing the relevant tables and columns.
        :type relevant_tables_and_cols: str

        :return: A JSON string containing the pruned schema metadata.
        :rtype: str
        """

async def _generate_query_v2(
        self,
        user_question: str,
        pruned_database_schema: str,
    ) -> str:
        """
        Generate an Azure SQL query based on the provided context for the database.

        :param user_question: The user's question.
        :type user_question: str
        :param pruned_database_schema: A JSON string containing the pruned database schema metadata.
        :type pruned_database_schema: str

        :return: The generated Azure SQL query
        :rtype: str
        """

async def _execute_generated_query(self, query: str) -> str:
        """
        Executes a SQL query.

        :param query: The SQL query to execute
        :type query: str

        :return: The results of the executed query as a JSON-formatted string
        :rtype: str
        """

The Issue

I am seeing a discrepency between the output of the prior tool and the input of the current tool, despite making zero data interventions on my side. It seems like the prior tool's output is getting chopped off before being passed to the next tool as an argument.

Example

• Tool output from _determine_relevant_tables_and_cols: '{"relevant_tables_and_cols":[{"table_name":"some_table_name","columns":["col1", "col2", "col3"]}]}'
• Tool input to _prune_irrelevant_columns_from_database_schema: '[{"table_name":"some_table_name","columns":["col1", "col2", "col3"]}]'

In this example, you can see that it's removing the relevant_tables_and_cols key and only retaining the values. I noticed this happening in other scenarios, too.

The Desired Behavior

The desired outcome of mine is for the output of the previous tool to not change before becoming an input to the next tool. This would allow me to much more easily and predictably ingest the input back into a Pydantic model.

Any help would be very much appreciated!

[jacobreesmontgomery]

Is this an intentional behavior from the Foundry SDK to look for a match between the tool output and the argument name and if so, extract the value from it?