OpenAPIToolset: lack user-provided logger to troubleshoot API calls

[asnowfix]

** Please make sure you read the contribution guide and file the issues in the right place. **
Contribution guide.

Is your feature request related to a problem? Please describe.
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

When using OpenAPIToolset, it is not possible to give our own logger to be able to have a fine-grained control of what are the underlying API attempts triggered by the LLM. We only have exceptions in case of failure, but we do not have the necessary information tune the LLM promptamd/or API description.

Describe the solution you'd like
A clear and concise description of what you want to happen.

allow ``openapi_kwargs["logger"] = logger

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Use LangGraph

Additional context
Add any other context or screenshots about the feature request here.

This Issue relates to our enterprise usage attempt of ADK:

• OpenAPIToolset does not provide a way to use a different CA (eg. Enterprise TLS proxy) #3720
• OpenAPIToolset: tool_name_prefix is present in BaseToolset but unreachable in OpenAPIToolset #3779
• OpenAPIToolset: lack user-provided logger to troubleshoot API calls #3780
• OpenAPIToolset: add header_provider, as McpToolsset has #3782

[xuanyang15]

Hi @asnowfix, thanks for reporting this feature request? Could you please clarify how do you plan to use the logger?

Do you mean something like this:

import logging

# Create and configure a custom logger
my_logger = logging.getLogger("my_api_logger")
my_logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
my_logger.addHandler(handler)

# Pass it to OpenAPIToolset
toolset = OpenAPIToolset(
    spec_dict=api_spec,
    custom_logger=my_logger
)

ADK should pass the custom logger to rest api tool, where it should use this custom logger to log API calls (e.g. request, response, errors, etc)? e.g.

class RestApiTool(BaseTool):
  """A generic tool that interacts with a REST API.

  * Generates request params and body
  * Attaches auth credentials to API call.

  Example::

    # Each API operation in the spec will be turned into its own tool
    # Name of the tool is the operationId of that operation, in snake case
    operations = OperationGenerator().parse(openapi_spec_dict)
    tool = [RestApiTool.from_parsed_operation(o) for o in operations]
  """

  def __init__(
      self,
      name: str,
      description: str,
      endpoint: Union[OperationEndpoint, str],
      operation: Union[Operation, str],
      auth_scheme: Optional[Union[AuthScheme, str]] = None,
      auth_credential: Optional[Union[AuthCredential, str]] = None,
      should_parse_operation=True,
      ssl_verify: Optional[Union[bool, str, ssl.SSLContext]] = None,
      custom_logger: Optional[logging.Logger] = None,
  ):

  ......

  self._logger = custom_logger if custom_logger is not None else logger
  
  ......

  @override
  async def run_async(
      self, *, args: dict[str, Any], tool_context: Optional[ToolContext]
  ) -> Dict[str, Any]:
    return await self.call(args=args, tool_context=tool_context)

  async def call(
      self, *, args: dict[str, Any], tool_context: Optional[ToolContext]
  ) -> Dict[str, Any]:
    """Executes the REST API call.

    Args:
        args: Keyword arguments representing the operation parameters.
        tool_context: The tool context (not used here, but required by the
          interface).

    Returns:
        The API response as a dictionary.
    """

   ......   

    # Got all parameters. Call the API.
    request_params = self._prepare_request_params(api_params, api_args)
    if self._ssl_verify is not None:
      request_params["verify"] = self._ssl_verify

    # Log the API request
    self._logger.debug(
        "API Request: %s %s",
        request_params.get("method", "").upper(),
        request_params.get("url", ""),
    )
    self._logger.debug("API Request params: %s", request_params.get("params"))
    if "json" in request_params:
      self._logger.debug("API Request body: %s", request_params.get("json"))

    response = requests.request(**request_params)

    # Log the API response
    self._logger.debug(
        "API Response: %s %s - Status: %d",
        request_params.get("method", "").upper(),
        request_params.get("url", ""),
        response.status_code,
    )

    # Parse API response
    try:
      response.raise_for_status()  # Raise HTTPError for bad responses
      result = response.json()
      self._logger.debug("API Response body: %s", result)
      return result
    except requests.exceptions.HTTPError:
      error_details = response.content.decode("utf-8")
      self._logger.warning(
          "API call failed for tool %s: Status %d - %s",
          self.name,
          response.status_code,
          error_details,
      )
      return {
          "error": (
              f"Tool {self.name} execution failed. Analyze this execution error"
              " and your inputs. Retry with adjustments if applicable. But"
              " make sure don't retry more than 3 times. Execution Error:"
              f" Status Code: {response.status_code}, {error_details}"
          )
      }
    except ValueError:
      self._logger.debug("API Response (non-JSON): %s", response.text)
      return {"text": response.text}  # Return text if not JSON

[asnowfix]

Yeah, this is what I had in mind: dump of the query & the response (with sensitive headers replaced by REFACTED), so that we can troubleshoot API usage for which we do not have a server side access. AND let our API enterprise users troubleshoot our own API’s using their agents without granting them server side access on our end.

[xuanyang15]

Hi @asnowfix I have submitted the changes for #3782, is this feature (custom logger) still needed? Since you mentioned 3782 is an alternative.

[asnowfix]

Custom logger is still useful, as it allows full request/response logging. Most if the issues will be troubleshooted with an http interceptor, but I guess some info (especially the detailled response) could still be missing.