Method _coerce_tool_arguments

examples/server/server.py:7076–7133

(
        self,
        tool_name: str,
        arguments: Dict[str, str],
        *,
        partial: bool,
    )

        return decoded

    def _coerce_tool_arguments(
        self,
        tool_name: str,
        arguments: Dict[str, str],
        *,
        partial: bool,
    ) -> Dict[str, Any]:
        if self._tool_content_type(tool_name) == "text":
            raw_input = arguments.get("input", "")
            if not isinstance(raw_input, str):
                raw_input = str(raw_input)
            return {"input": raw_input}
        if self._tools is None:
            raise CompletionResponseParsingError(
                f"response included tool call '{tool_name}' but the request declared no tools"
            )
        tool = next(
            (
                candidate
                for candidate in self._tools
                if candidate.get("type") == "function"
                and candidate.get("function", {}).get("name") == tool_name
            ),
            None,
        )
        if tool is None:
            raise CompletionResponseParsingError(
                f"response included undeclared tool call '{tool_name}'"
            )
        parameters = tool.get("function", {}).get("parameters") or {
            "type": "object",
            "properties": {},
            "required": [],
        }
        properties = parameters.get("properties", {})
        coerced: Dict[str, Any] = {}
        for argument_name, raw_value in arguments.items():
            if argument_name not in properties:
                raise CompletionResponseParsingError(
                    f"tool '{tool_name}' returned unexpected argument '{argument_name}'"
                )
            coerced[argument_name] = self._coerce_tool_argument(
                raw_value,
                properties[argument_name],
                tool_name=tool_name,
                argument_name=argument_name,
            )
        if not partial:
            missing = [
                argument_name
                for argument_name in parameters.get("required", [])
                if argument_name not in coerced
            ]
            if missing:
                raise CompletionResponseParsingError(
                    f"tool '{tool_name}' response is missing required arguments: {', '.join(missing)}"
                )
        return coerced